__all__ is an list containing 6 elements: 'get_cache', 'cache', 'DEFAULT_CACHE_ALIAS', 'InvalidCacheBackendError', 'CacheKeyWarning' and 'BaseCache' DEFAULT_CACHE_ALIAS is a string 'default'. call the function warnings.warn with string "'get_cache' is deprecated in favor of 'caches'.", RemovedInDjango19Warning, and stacklevel set to 2 as arguments. call the _create_cache with backend and dictionary kwargs as arguments, substitute the result for cache. call the function signals.request_finished.connect with argument cache.close. if KeyError exception is caught, call the function import_string with argument backend. remove 'LOCATION' key from kwargs dictionary and put it into location, or use an empty string if key doesnt exists. if not, call the function conf.copy, substitute it for params. call the function params.update with argument kwargs. remove 'BACKEND' key from params dictionary and put it into backend. remove 'LOCATION' key from kwargs dictionary and put it into location, or use an empty string if key doesnt exists. call the import_string with argument backend, substitute it for backend_cls. evaluate the function backend_cls with location and params as arguments, return the result. call the function local, substitute the result for self._caches. return value under the alias key of self._caches.caches dictionary. except if AttributeError is caught, self._caches.caches is an empty dictionary. except if KeyError exception is caught, call the function _create_cache with argument alias. substitute cache for value under the alias key of self._caches.caches dictionary. get attribute 'caches' from the self._caches if exists, otherwise get an empty dictionary, call the values method on the return value, return it. call the CacheHandler function, substitute the result for caches. get attribute name from value under the DEFAULT_CACHE_ALIAS key of caches dictionary, return it. delete the attribute name from the cache dictionary under the DEFAULT_CACHE_ALIAS key. call the DefaultCacheProxy function, substitute it for cache. for every cache in return value of the function caches.all. call the function cache.close. call the function signals.request_finished.connect with argument close_caches. DEFAULT_TIMEOUT is a instance of the class object. MEMCACHE_MAX_KEY_LENGTH is integer 250. if key_func is not of None type, if key_function is callable object, if not, evaluate the function import_string with key_func as argument, return the result. call the params.get method with string 'TIMEOUT' and integer 300 as arguments, use the string 'timeout' and previous result as the arguments for the call to the params.get method, substitute the result for timeout. if timeout is not None, convert timeout into an integer. timeout is integer 300. call the params.get with string 'OPTIONS' and empty dictionary as arguments, substitute the result for options. call the options.get method with string 'MAX_ENTRIES' and integer 300 as arguments, use the string 'max_entries' and previous result as the arguments for the call to the params.get method, substitute the result for max_entries. convert max_entries into a string, substitute it for self._max_entries. self._max_entries is integer 300. call the options.get method with string 'CULL_FREQUENCY' and integer 3 as arguments, use the string 'cull_frequency' and previous result as the arguments for the call to the params.get method, substitute the result for cull_frequency. convert cull_frequency into an integer and substitute it for self._cull_frequency. call the params.get method with string 'KEY_PREFIX' and an empty string as arguments, substitute the result for self._key_prefix. call the method params.get with 2 arguments, string 'KEY_FUNCTION' and None, use the result as the argument for the call to the function get_key_func, substitute the result for the self.key_func. if timeout equals to DEFAULT_TIMEOUT, timeout is a integer -1. if timeouts is None return None, otherwise return the sum of function time.time return value and timeout. d is an empty dictionary. for every k in keys, if val is not None, substitute val for value under the k key of dictionary d. if ascii value of char is smaller than integer 33 or is equal to integer 127, self.app_label is a string 'django_cache'. self.model_name is a string 'cacheentry'. self.verbose_name is a string 'cache entry'. self.verbose_name_plural is a string 'cache entries'. self.object_name is a string 'CacheEntry'. _meta is class Options class instance initialized with table argument. substitute CacheEntry for self.cache_model_class. call the method router.db_for_read with self.cache_model_class as argument, substitute the result for db. call the ops.quote_name method with argument self._table on the value under the db key of connections dictionary, substitute the result for table. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method cursor.execute with string "SELECT cache_key, value, expires FROM %s WHERE cache_key = %%s" as argument, substitute the '%s' with table and list containing key, respectively. call the cursor.fetchone method, substitute the result for row. if row is None, call the timezone.now function, substitute the result for now. substitute third element of row list for expires. and expires is not an instance of datetime. convert expires to a string, use it as argument for the call to the function typecast_timestamp, substitute the result for expires. if expires is lesser than now, call the method router.db_for_write with argument self.cache_model_class, substitute the result for db. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method ops.process_clob with second element of row as argument, on the object under the db key of connections dictionary, substitute the result for value. call the function force_bytes with argument value, use the result as an argument for the call to the method base64.b64decode, call the method self.get_backend_timeout with argument timeout, substitute the result for timeout. call the method router.db_for_write with argument self.cache_model_class, substitute the result for db. call the ops.quote_name method with argument self._table on the object under the db key of connections dictionary, substitute the result for table. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method cursor.execute with string "SELECT COUNT(*) FROM %s" as argument, substitute the '%s' with table. fetch one record from the database cursor points at, substitute the first element of return value for num. call the timezone.now function, substitute the result for now. call the function now.replace with microseconds set to integer 0, substitute the result for now. if timeout is None, substitute the datetime.max for exp. call the function datetime.utcfromtimestamp with argument timeout, substitute it for exp. if not, call the function datetime.fromtimestamp with argument timeout, substitute it for exp. call the exp.replace with microsecond set to integer 0, substitute the result for exp. if num is greater than self._max_entries, call the method self._cull with db, cursor and now as arguments. call the method pickle.dumps with value and pickle.HIGHEST_PROTOCOL as arguments, substitute it for pickled. call the method base64.b64encode with argument pickled, substitute the result for b64encoded. call the method b64encoded.decode with string 'latin1' as argument, substitute the result for b64encoded. with return value of the function transaction.atomic with using set to db as arguments, perform the following, call the method cursor.execute with string "SELECT cache_key, expires FROM %s WHERE cache_key = %%s" as argument, substitute the '%s' with table and list containing key, respectively. fetch one entry from the database that cursor points at, substitute it for the result. if result is true, substitute the second element of result for current_expires. convert current_expires to a string, use it as the argument for the call to the function typecast_timestamp, substitute the result for current_expires. on the object under the db key of connections dictionary call the method ops.value_to_db_datetime with argument exp, substitute the result for the exp. if mode equals to string 'add' and current_expires is lesser than now, or mode equals to string 'set', and result is true, call the method cursor.execute with string "UPDATE %s SET value = %%s, expires = %%s WHERE cache_key = %%s" as argument, substitute the '%s' with table and 3 elements of a list: b64encoded, exp and key, respectively. if not, call the method cursor.execute with string "INSERT INTO %s (cache_key, value, expires) VALUES (%%s, %%s, %%s)", substitute the '%s' with table and 3 elements of a list: b64encoded, exp and key, respectively. if DatabaseError exception is caught, if not, call the method router.db_for_write with argument self.cache_model_class, substitute the result for db. call the ops.quote_name method with argument self._table on the object under the db key of connections dictionary, substitute the result for table. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method router.db_for_write with argument self.cache_model_class, substitute the result for db. call the ops.quote_name method with argument self._table on the object under the db key of connections dictionary, substitute the result for table. call the function datetime.utcnow, substitute the result for now. if not, call the function datetime.now, substitute the result to now. call the method now.replace with the argument microsecond set to integer 0, substitute the result for now. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method cursor.execute with string "SELECT cache_key FROM %s WHERE cache_key = %%s and expires > %%s" as argument, if not, call the method now.replace with argument tzinfo set to None, substitute it for now. call the ops.quote_name method with argument self._table on the object under the db key of connections dictionary, substitute the result for table. call the method cursor.execute with string "DELETE FROM %s WHERE expires < %%s" as argument, substitute the '%s' with table and list containing return value of the method call ops.value_to_db_datetime with argument now on the object under the db key of connections dictionary, respectively. call the method cursor.execute with string "SELECT COUNT(*) FROM %s" as argument, substitute the '%s' with table. fetch next entry for the database that cursor points into, substitute first element of it for num. if num is greater than self._max_entries, divide num by self._cull_frequency, floor the result and substitute it for cull_num. evaluate the method connections[db].ops.cache_key_culling_sql, evaluate the result by table modulus, call the method cursor.execute, with previous result and list containing cull_num, respectively as arguments. call the method cursor.execute with string "DELETE FROM %s WHERE cache_key < %%s" as argument, call the method router.db_for_write with argument self.cache_model_class, substitute the result for db. call the ops.quote_name method with argument self._table on the object under the db key of connections dictionary, substitute the result for table. call the cursor method on the value under the db key of connections dictionary, preform following with return value named cursor, call the method cursor.execute with string "DELETE FROM %s" as argument, substitute the '%s' with table. cache_suffix is a string '.djcache'. with return value of the function io.open with fname and string 'rb' as arguments, named as f, call f.read function, use the result as the argument for zlib.decompress function call, call the pickle.loads function with the previous result as argument, return the result. if IOError, renamed to e, exception is caught, if e.errno equals to errno.ENOENT, call the method tempfile.mkstemp with dir set to self._dir, substitute result for fd and tmp_path, respectively. with return value of the function io.open with fname and string 'rb' as arguments, named as f, call the method self.get_backend_timeout with argument timeout, substitute it for expiry. call the function pickle.dumps with expiry and integer -1 as arguments, use the result as the argument for the call to f.write function. call the function pickle.dumps with argument value, use the result and integer -1 as arguments for the call to the function zlib.compress, use the result as an argument for the call to the f.write method. call the function file_move_safe with tmp_path, fname, allow_overwrite set to boolean True as arguments. finally perform, if renamed is boolean False, if exception OSError, renamed to e, is caught, if e.errno does not equals to errno.ENOENT, with call to the io.open function with fname and string 'rb' as arguments, renamed to f, call the self._list_cache_files method, substitute the result for filelist. if num_entries is lesser than self._max_entries, divide num_entries by self._cull_frequency, convert the result to an integer, call the random.sample function with filelist and previous result as arguments, substitute the result for filelist. for every fname in filelist, if OSError, renamed to e, exception is caught, if e.errno is not equal to errno.EEXIST, if fname is contained in self._list_cache_files method return value, call the function pickle.load with argument f, substitute the result for exp. if exp is not None and exp is lesser than return value of the function time.time, call close method on a file stream. __caches is an empty dictionary. __expire_info is an empty dictionary. __locks is an empty dictionary. call the _caches.setdefault method with name and empty dictionary as arguments, substitute the result for self_cache. call the _expire_info.setdefault method with name and empty dictionary as arguments, substitute the result for self_expire_info. call the _lock.setdefault method with name and RWLock() as arguments, substitute the result for self_lock. call the pickle.dumps function with value and pickle.HIGHEST_PROTOCOL as arguments. substitute None for pickled. call the self._lock.reader method, with the result perform the following, if pickled is not None. evaluate pickle.loads with argument pickled, return the result. if pickle.PickleError exception is caught, if KeyError exception is caught, call the function pickle.dumps with value and pickle.HIGHEST_PROTOCOL as the arguments, substitute the result for pickled. call the function pickle.dumps with value and pickle.HIGHEST_PROTOCOL as the arguments, substitute the result for pickled. call the self._lock.reader method, with the result perform the following, if KeyError exception is caught, if exp is None or exp is greater than the return value of the call to the function time.time, if not, for every k in doomed, if KeyError exception is caught, if KeyError exception is caught, renamed methods is a tuple containing 3 elements: '_get_memcache_timeout', 'get_backend_timeout' and RemovedInDjango19Warning. split server with ';' as delimiter, substitute the result for self._servers. if not, substitute server for self._servers. substitute value_not_found_exception for self.LibraryValueNotFoundException. substitute library for self._lib. call the params.get function with string 'OPTIONS' and None as arguments, substitute the result for self._options. property decorator, if timeout equals to DEFAULT_TIMEOUT, if timeout is None, timeout is a integer -1. if timeout is greater than integer 2592000, convert return value of the function time.time to an integer, increment timeout by it. if val is None, define the method get_many with 3 arguments, self class instance, keys and version set to None. call the method self._cache.get_multi with argument new_keys, substitute the result for ret. if ret is true. _ is an empty dictionary. zip together new_keys and keys, convert it to dictionary, assign it to m. for every k and v in return value of the ret.items function, substitute v for value under the k-th element of m key of _ dictionary. substitute _ for ret. call the method self._cache.disconnect_all. if delta is smaller than integer 0, val is None. if val is None, if delta is smaller than integer 0. val is None. if val is None, safe_data is an empty dictionary. call the method self_cache.delete_multi with argument list containing keys mapped through function l. call the method self._cache_flush_all. call method __init__ from the base class of the class MemcachedCache with arguments: server, params, library set to memcache and value_not_found_exception set to ValueError. property decorator, call method __init__ from the base class of the class PyLibMCCache with arguments: server, params, library set to pylibmc and value_not_found_exception set to pylibmc.NotFound. decorator cached_property, substitute self._options for client.behaviors. TEMPLATE_FRAGMENT_KEY_TEMPLATE is a string 'template.cache.%s.%s'. if vary_on is None, vary_on is an empty tuple. call the function urlquote with argument var for every var in vary_on, join the results into a string separated by ':', substitute it for key. substitute '%s' in TEMPLATE_FRAGMENT_KEY_TEMPLATE string with fragment_name and args.hexdigest(), respectively, return the result. from .messages import CheckMessage, Debug, Info, Warning, Error, Critical, DEBUG, INFO, WARNING, ERROR and CRITICAL into default name space. from .registry import register, run_checks, tag_exists and Tags into default name space. __all__ is a list containing next strings, 'CheckMessage', 'Debug', 'Info', 'Warning', 'Error', 'Critical', decorator register with argument Tags.compatibility. errors is an empty list call the function _check_test_runner with dictionary kwargs as argument, use the result as an argument for the call to the function errors.extend. call the function _check_boolean_field_default_value with dictionary kwargs as argument, use the result as an argument for the call to the function errors.extend. weight is an integer 0. increment weight by integer 2. if AttributeError exception is caught, if AttributeError exception is caught, increment weight by integer 2. increment weight by integer 2. increment weight by integer 2. increment weight by integer 2. if string 'django.middleware.clickjacking.XFrameOptionsMiddleware' is not contained in settings.MIDDLEWARE_CLASSES set, increment weight by integer 2. if weight is greater or equal to integer 6, call the Warning function with 3 arguments: hint tuple containing one string, Django 1.6 introduced a new default test runner. It looks like this project was generated using Django 1.5 or earlier. You should ensure your tests are all running & behaving as expected. See https://docs.djangoproject.com/en/dev/releases/1.6/#new-test-runner for more information.", obj set to None and id set to a string '1_6.W001', put the result into a list and return it. if not, decorator register with argument Tags.compatibility. errors is an empty list. call the function _check_middleware_classes with dictionary kwargs as argument, use the result as an argument for the call to the function errors.extend. call the Warning function with 4 arguments: string "MIDDLEWARE_CLASSES is not set.", hint tuple containing one string, "Django 1.7 changed the global defaults for the MIDDLEWARE_CLASSES. django.contrib.sessions.middleware.SessionMiddleware, django.contrib.auth.middleware.AuthenticationMiddleware, and django.contrib.messages.middleware.MessageMiddleware were removed from the defaults. If your project needs these middleware then you should configure this setting.", obj set to None, and id set to a string '1_7.W001', put the result into a list and return it. if not, DEBUG is integer 10. INFO is integer 20. WARNING is integer 30. ERROR is integer 40. CRITICAL is integer 50. decorator python_2_unicode_compatible. substitute level for self.level. substitute msg for self.msg. substitute hint for self.hint. substitute id for self.id. if for all attr in list of attributes 'level', 'msg', 'hint', 'obj' and 'id', self and other have the same attribute attr, obj is a string "?". substitute model._meta.app_label for app. convert app and model._meta.object_name to strings, join them with separating '.' character, substitute it for obj. if not, call the function force_str with argument self.obj, substitute the result for obj. if self.hint exists, replace '%s' in a string "\n\tHINT: %s" with value of self.hint, substitute it for hint, otherwise hint is an empty string. replace all '%s' from string "%s: %s%s%s" with values of obj, id, self.msg and hint, respectively, return the result. decorator register with Tags.models as an argument. only if app_configs is None ot model._meta.app_config is contained in app_configs, error is a list containing all the previous elements. chain all errors elements into a list, return it. decorator register with Tags.models and Tags.signals as arguments. errors is an empty list. for name in attributes of models_signals object, get models.signals name attribute, store it in obj. for every reference and receivers in return value of the call of obj.unresolved_references.items method, for every receiver, _ and _ in receivers, description is a string "The '%s' function" replaced by value of receiver.__name__. if not, call the Error function with 4 arguments, string "%s was connected to the '%s' signal with a lazy reference to the '%s' sender, admin is a string 'admin' compatibility is a string 'compatibility'. models is a string 'models' signal is a string 'signals' replace tags for check.tags. if check is not contained in self.registered_checks. errors is an empty list. if tags is not None. append check to checks list, for every check in self.register_checks, if check has an attribute 'tags' and check.tags and tags set intersection is a non empty set. if not. substitute self.registered_checks for checks. for every check in checks, call the check function with argument app_config set to app_config, substitute the result for new_errors. if new_errors is not an iterable object raise an error with error message "The function %r did not return a list. All functions registered with the checks registry must return a list.", with '%s' replaced by value of check. call the method errors.extend with argument new_errors. append check.tags into a list for every check in self.registered_checks if check has 'tags' attribute, put the elements into a set and return it. call the function CheckRegistry, substitute the result for registry. substitute registry.run_checks for run_checks. substitute registry.tag_exists for tag_exists. if token is None, if not, call the function lazy with arguments _get_val and six.text_type, substitute the result for _get_val. return an dictionary containing 1 entry: return value of the function _get_val for 'csrf_token'. context_extras is an empty dictionary. context_extras is an empty dictionary. call the translation.get_language function, substitute the result for the value under the 'LANGUAGE_CODE' key of the context_extras dictionary. call the translation.get_language_bidi function, substitute the result for the value under the 'LANGUAGE_BIDI' key of the context_extras dictionary. return an dictionary containing 1 entry: return value of the function timezone.get_current_timezone_name for 'TIME_ZONE'. NON_FIELD_ERRORS is an string '__all__'. if not, messages is an instance of the ValidationError class created with an argument messages. extend the self.error_list list with message.error_list. if not, substitute code for self.code. substitute params for self.params. property getter decorator, property getter decorator, call the operator.add on the values of the self object converted into a dictionary, until it is reduced to a single value, return it. if not, call the method extend with an argument error_list on the return value of the method error_dict.setdefault called with 2 arguments: NON_FIELD_ERRORS and an empty list. if not, if error.params is true, __all__ is an list containing a string 'File'. from io import BytesIO, StringIO and UnsupportedOperation into default name space. decorator python_2_unicode_compatible, bring integer 2 to the power of 10, multiply it by 64, substitute the result for DEFAULT_CHUNK_SIZE. if name is None, get 'name' attribute from the file object, if it doesnt exists use None, substitute it for name. if file object has an attribute 'mode', substitute file.mode for self.mode. if OSError or TypeError errors occurred. get the position of the self.file file pointer, substitute it for pos. size is a property object with _get_size as getter method and _set_size as setter method. closed is a property object with _get_closed as a getter method. if chunk_size is false, substitute the self.DEFAULT_CHUNK_SIZE for chunk_size. if AttributeError or UnsupportedOperation exception occurred. if chunk_size is false, substitute self.DEFAULT_CHUNK_SIZE for chunk_size. buffer_ is None. evaluate the function BytesIO with argument chunk, substitute it for chunk_buffer. for every line in chunk_buffer, if buffer_ is true, increment line by buffer_. buffer_ is None. if last element of line is newline or carriage return character, if not, substitute line for buffer_. if buffer_ is not None, if not, decorator python_2_unicode_compatible, if not, substitute BytesIO for stream_class. call the function force_bytes with argument content, substitute it for content. call the __init__ method with stream_class(content) and name set to name arguments, from the base class of the ContentFile class. get property attribute _get_width, and substitute it for width. get property attribute _get_height, and substitute it for width. from PIL module import ImageFile as PillowImageFile. if file_or_path has an attribute 'read', substitute file_or_path for file. get the position in bytes from the start of the file, store it in file_pos. set the file position pointer at the beginning. if not, open file named file_or_path for reading, store the file object handle in file. chunk_size is an integer 1024. endless while loop, if zlib.error as e exception is raised, if not, if p.image is not empty, double the chunk size. execute regardless of the exception being raised, if close is True, close file file. if not, set the file position pointer at file_pos. __all__ is a tuple containing strings: 'LOCK_EX', 'LOCK_SH', 'LOCK_NB', 'lock' and 'unlock'. return result of the f.fileno method if f has an 'fileno' attribute, otherwise return f. from ctypes import sizeof, c_ulong, c_void_p, c_int64, Structure, Union, POINTER, windll and byref into default name space. from ctypes.wintypes import BOOL, DWORD and HANDLE into default name space. LOCK_SH is a integer 0. LOCK_NB is a hexadecimal 1. LOCK_EX is a hexadecimal 2. if size of c_ulong does not equals to size of c_void_p, substitute c_int64 for ULONG_PTR. if not, substitute c_ulong for ULONG_PTR. substitute c_void_p for PVOID. _fields_ is a list containing 2 tuples: first tuple contains: string 'Offset' and DWORD, second contains: string 'OffsetHigh' and DWORD. _anonymous_ is a list containing one string: '_offset'. _fields_ is a list containing 2 tuples: first tuple contains: string '_offset' and _OFFSET, second contains: string 'Pointer' and PVOID. _anonymous_ is a list containing one string: '_offset_union'. _fields_ is a list containing 4 tuples: first tuple contains: string 'Internal' and ULONG_PTR, second contains: string 'InternalHigh and ULONG_PTR, third: '_offset_union' and _OFFSET_UNION, forth 'hEvent' and HANDLE. call the function POINTER with argument OVERLAPPED, substitute the result for LPOVERLAPPED. substitute windll.kernel32.LockFileEx for LockFileEx. substitute BOOL for LockFileEx.restype. LockFileEx.argtypes is a list containing 6 elements: HANDLE, DWORD, DWORD, DWORD, DWORD and LPOVERLAPPED. substitute windll.kernel32.UnlockFileEx for UnlockFileEx. substitute BOOL for UnlockFileEx.restype. UnlockFileEx.argtypes is a list containing 5 elements: HANDLE, DWORD, DWORD, DWORD and LPOVERLAPPED. call the function msvcrt.get_osfhandle with return value of the _fd(f) function as argument, substitute the result for hfile. call the OVERLAPPED function, substitute the result for overlapped. call the LockFileEx function with 6 arguments: hfile, flags, integer 0, integer 0, hexadecimal value FFFF0000, return value of the byref function called with argument overlapped, substitute the result for ret. call the function msvcrt.get_osfhandle with return value of the _fd(f) function as argument, substitute the result for hfile. call the OVERLAPPED function, substitute the result for overlapped. call the LockFileEx function with 5 arguments: hfile, integer 0, integer 0, hexadecimal value FFFF0000, return value of the byref function called with argument overlapped, substitute the result for ret. if not, substitute fcntl.LOCK_SH for LOCK_SH. substitute fcntl.LOCK_NB for LOCK_NB. substitute fcntl.LOCK_EX for LOCK_EX. LOCK_EX, LOCK_SH and LOCK_NB are all equal to integer 0. if not, call the function fcntl.flock with return value of the _fd(f) function and flags as arguments, substitute the result for ret. all the function fcntl.flock with return value of the _fd(f) function and fcntl.LOCK_UN as arguments, substitute the result for ret. from shutil import copystat into default name space. call the function stat.S_IMODE with argument st.st_mode, substitute the result for mode. call the os.utime function with arguments dst and tuple containing 2 elements: st.st_atime and st.st_mtime. __all__ is a list containing a string 'file_move_safe'. if exception OSError occurred, if call to the function _samefile with old_file_name and new_file_name evaluates to boolean True, call the os.rename function with arguments old_file_name and new_file_name. if OSError exception is caught, open file old_file_name in read bytes mode, with file descriptor as f, call the function locks.lock with arguments fd and locks.LOCK_EX. current_chunk is None. as long as current_chunk is not an empty string, read chunk_size bytes from the old_file file, substitute the result for current_chunk. finally perform, call the function locks.unlock with fd as argument. call the function copystat with old_file_name and new_file_name as arguments. if OSError, renamed to e, is caught, if attribute 'winerror' of object e is not equal to integer 32 and if 'errno' attribute is not equal to integer 13, __all__ is a tuple containing strings: 'Storage', 'FileSystemStorage', 'DefaultStorage' and 'default_storage'. call the self._open method with name and mode arguments, return the result. if name is None, substitute content.name for name. if content has an 'chunks' attribute, content is a File object instance created with content argument. call the itertools.count function with argument integer 1, substitute the result for count. decorator deconstructible, and directory_permissions_mode set to None. if location is None, substitute the location for self.base_location. if base_url is None, append character '/' to the base_url. substitute base_url for self.base_url. self.file_permissions_mode is a tuple containing: file_permissions_mode if file_permissions_mode is not None, or settings.FILE_UPLOAD_PERMISSIONS if it is. self.directory_permissions_mode is a tuple containing: directory_permissions_mode if directory_permissions_mode is not None, finally perform, if not, if exception OSError, renamed to e, occurred, if e.errno is not equal to errno.EEXIST, if content has an attribute 'temporary_file_path', call the function file_move_safe with content.temporary_file_path function result and full_path. if not, binary or 'O_BINARY' attribute of the os object, or integer 0 if it doesnt exists. call the os.open function with full_path, flags and octal number 0o666 as arguments, substitute the result for fd. _file is None. call the function locks.lock with fd and locks.LOCK_EX as arguments. for every chunk in content.chunks function return value, if _file is None, call the function os.fdopen with arguments fd and mode, substitute it for _file. write the chunk to the file _file. finally perform, call the function locks.unlock with argument fd. if _file is not None, close the _file file. if not, if OSError, renamed to e, is caught, if e.errno equals to errno.EEXIST, if not, if not, if name is boolean False raise an assert error with message string "The name argument is not allowed to be empty.". if OSError, renamed to e, is caught, if e.errno equals to errno.EEXIST, directories, files are empty lists. if not, call the urljoin function with arguments: self.base_url and result of the call to the function filepath_to_uri with argument name, return the result. call the function that is the return value of get_storage_class method, substitute the result for self._wrapped. call the DefaultStorage method, substitute the result for default_storage. __all__ is a tuple, containing strings 'NamedTemporaryFile' and 'gettempdir'. dir set to None as the arguments. call the method tmpfile.mkstemp with suffix set to suffix, prefix set to prefix and dir set to dir, store the result in the fd and name, respective. call the os.fdopen function with fd, mode and bufsize as the arguments, assign the file handle object to self.file. substitute os.unlink for unlink. if OSError or IOError exceptions were raised, if OSError exception was raised, property decorator, to be called by property built-in function. call the file.__exit__ method on self with exc, value and tb as the arguments. substitute TemporaryFile for NamedTemporaryFile. if not, substitute tempfile.NamedTemporaryFile for NamedTemporaryFile. substitute tempfile.gettempdir for gettempdir. __all__ is a tuple containing strings: 'UploadedFile', 'TemporaryUploadedFile', 'InMemoryUploadedFile' and 'SimpleUploadedFile'. bring integer 2 to the power of 10, multiply it by integer 64, substitute the result for DEFAULT_CHUNK_SIZE. substitute size for self.size. substitute content_type for self.content_type. substitute charset for self.charset. substitute content_type_extra for self.content_type_extra. if name is not None, substitute the first 255 elements of ext for ext. name is a property object with _get_name as a getter method and _set_name as a setter method. call the method tempfile.NamedTemporaryFile with arguments: suffix set to string '.upload' and dir set to settings.FILE_UPLOAD_TEMP_DIR. if not, call the method tempfile.NamedTemporaryFile with argument suffix set to string '.upload'. call the method __init__ from the base class of the TemporaryUploadedFile class with arguments: file, name, content_type, size, charset and content_type_extra. if OSError, renamed to e, exception is caught, if e.errno is not equal to errno.ENOENT, call the method __init__ from the base class of the InMemoryUploadedFile base class, with 6 arguments: file, name, content_type, size, charset, content_type_extra. substitute field_name for self.field_name. if content is empty, substitute it for an empty string. content_type, length of content, None and None. decorator classmethod. call the method cls with 3 arguments: value under the 'filename' key of file_dict, value under the 'content' key of file_dict, __all__ is a string containing strings: 'UploadFileException', 'StopUpload', 'SkipFile', 'FileUploadHandler', decorator python_2_unicode_compatible, substitute connection_reset for self.connection_reset. return string 'StopUpload: Halt current upload.'. if not, bring integer 2 to the power of 10, multiply it by integer 64, substitute the result for chunk_size. substitute field_name for self.field_name. substitute file_name for self.file_name. substitute content_type for self.content_type. substitute content_length for self.content_length. substitute charset for self.charset. substitute content_type_extra for self.content_type_extra. if not, if not, response_fixes is a list with http.fix_location_header and http.conditional_content_removal as elements. request_middleware is an empty list. evaluate the function import_string with middleware_path as argument, substitute the result for my_class. call the mw_class function, store the result in the mw_instance. if MiddlewareNotUsed exception is raised, if mw_instance has an attribute named 'process_request'. if mw_instance has an attribute named 'process_view'. if mw_instance has an attribute named 'process_template_response'. insert mw_instance.process_template_response at the beginning of self._template_response_middleware. if mw_instance has an attribute named 'process_response'. insert mw_instance.process_response at the beginning of self._response_middleware. if mw_instance has an attribute named 'process_exception'. insert mw_instance.process_exception at the beginning of self._exception_middleware. substitute self._request_middleware for request_middleware. get attribute '_non_atomic_requests' from the view object, if the attribute doesnt exist return the empty set, substitute the result for non_atomic_requests. call the method connections.all(), perform the following for every db in the result, if value under the key 'ATOMIC_REQUESTS of db.settings_dic dictionary is True and db.alias is not present in the non_atomic_requests, call the function transaction.atomic, with using set to db.alias as the argument, return value is a function which is called, call the function resolver.resolve_error_handler with status_code as an argument, assign the result to the callback and param_dict, respectively. if an exception occurred, call the method urlresolvers.set_urlconf with urlconf as the argument. call the method urlresolvers.RegexURLResolver with raw literal string '^/' and urlconf as the arguments, substitute the result for resolver. for every middleware_method in self._request_middleware, call the function urlresolvers.set_urlconf with urlconf as the argument. call the method urlresolvers.RegexURLResolver with raw literal string '^/' and urlconf as the arguments, substitute the result for resolver. assign the values to the callback, callback_args, callback_kwargs, respectively, from the resolver_match tuple. substitute resolver_match for request.resolver_match. for every middleware_method in self._view_middleware, call the method self.make_view_atomic with callback as the argument, substitute the result for the wrapped_callback. as the arguments, substitute the result for response. if Exception, renamed to e, exception is caught, for every middleware_method in self._exception_middleware, get the name of the callback, substitute it for view_name. if not, get the name of the type of the callback, append the string '.__call__' to it, substitute it for view_name. for every middleware_method in self._template_response_middleware, if exception http.Http404 as e is caught, if not, if exception PermissionDenied is caught, if exception SuspiciousOperation as e is caught, substitute '%s' in 'django.security.%s' with the name of the type of the class object e, use it as the argument for the call to the, if SystemExit exception is caught, otherwise if any other exception is caught, for every middleware_method in self._response_middleware, if any exception is caught, if resolver.urlconf_module is None: call the function reraise from the module six, with list of arguments exec_info. call the resolver.resolve_error_handler with integer 500 as the argument, assign the resulting tuple elements to the callback, ISO_8859_1 is a string 'iso-8859-1', UTF_8 is a string 'utf-8'. substitute limit for self.remaining. substitute buf_size for self.buf_size. if size is None or size is greater than self.remaining, if size equals to integer zero. read size number of bytes from self.stream stream, store the result in the result. if size is None, if not, if size is not zero, if not, if chunk is empty, call the function BytesIO with self.buffer as argument, store the result is sio. if size is not empty, call the sio.readline method with size as an argument, substitute the result for line. if not, call the sio.readline method, substitute the result for line. call the sio.read method, substitute the result for self.buffer. call the get_script_name function with environ as argument, substitute the result for script_name. call the get_path_info function with environ as argument, substitute the result for path_info. if path_info is empty, path_info is a character '/'. substitute environ for self.environ. substitute path_info for self.path_info. strip trailing '/' from the script_name string, remove first occurrence of '/' in path_info string, append second result to the first, separated with '/', assign the result to self.path. assign path_info to the value under the 'PATH_INFO' key of the self.META dictionary. assign script_name to the value under the 'SCRIP_NAME' key of the self.META dictionary. convert value under the 'REQUEST_METHOD' key of the environ dictionary to uppercase, substitute it for self.method. get the value under the 'CONTENT_TYPE' key of environ dictionary, if the key doesnt exist get the empty string, use it to call the cgi.parse_header method, assign the result to the _ and content_params respectively. if string 'charset' is contained in content_params, get the value under the 'charset' key of content_params dictionary, use it to call the codec.lookup method. if exception LookupError is caught, if not, get the value under the 'charset' key of content_params dictionary, substitute it for self.encoding. convert value under the 'CONTENT_LENGTH' key of the environ dictionary to an integer, substitute it for content_length. content_length is integer 0. return value under the 'wsgi.url_scheme' key of self.environ dictionary. decorator cached_property. call the get_bytes_from_wsgi function with self.environ, string 'QUERY_STRING' and empty string as arguments, substitute the return value for raw_query_string. evaluate the http.QueryDict method with raw_query_string and encoding set to self._encoding as arguments, return the result. decorator cached_property. call get_str_from_wsgi function with self.environ, string 'HTTP_COOKIE' and empty string as arguments, substitute it for raw_cookie. evaluate the function http.parse_cookie with raw_cookie as an argument, return the result. _get_post is a getter function and _set_post is a setter function for POST attribute of this class. _get_files is getter function for FILES attribute of this class. evaluate function Lock() assign the result to initLock. substitute WSGIRequest for request_class. if exception is caught, call the get_script_name function with environ as argument, use the result as an argument for call to the set_script_prefix function. call the signals.request_started.send method with sender set to self.__class__ as argument. if UnicodeDecodeError exception is caught, call the logger.warning method with string 'Bad Request (UnicodeDecodeError)', exec_info set to sys.exec_info() and dictionary extra if not, format the previous in a tuple, append the tuple to the response_headers. call the start_response function with force_str(status) method return value and response_headers as arguments. call the function get_bytes_from_wsgi with environ, string 'PATH_INFO' and character '/' as arguments, substitute the result for path_info. return path_info.decode method return value called with UTF_8 as the argument. call the get_bytes_from_wsgi function with environ, string 'SCRIPT_URL' and empty strings as arguments, substitute the result for script_url. if script_url is false, call the get_bytes_from_wsgi function with environ, string 'REDIRECT_URL' and empty strings as arguments, substitute the result for script_url. if script_url is true, call the get_bytes_from_wsgi function with environ, string 'PATH_INFO' and empty strings as arguments, substitute the result for path_info. if not, call the get_bytes_from_wsgi function with environ, string 'SCRIPT_NAME' and empty strings as arguments, substitute the result for script_name. return scrip_name.decode method result called with UTF_8 as argument. from django.core.mail.message import EmailMessage, EmailMultiAlternatives, SafeMIMEText, SafeMIMEMultipart, DEFAULT_ATTACHMENT_MIME_TYPE, make_msgid, BadHeaderError and forbid_multi_line_headers into default name space. __all__ is a list of strings, 'CachedDnsName', 'DNS_NAME', 'EmailMessage', 'EmailMultiAlternatives', 'SafeMIMEText', call the klass method with fail_silently set to fail_silently and dictionary arguments kwds as arguments, return the result. if html_message is True, call the mail.attach_alternative method with html_message and string 'text/html' as arguments. message, settings.SERVER_EMAIL, list of second elements of a for every a in settings.Managers and connection set to connection, as arguments, assign the result to mail. if html_message is true, call method mail.attach_alternative as html_message and string 'text/hmtl' as arguments. call the mail.send method with fail_silently=fail_silently as argument. message, settings.SERVER_EMAIL, list of second elements of a for every a in settings.Managers and connection set to connection, as arguments, assign the result to mail. if html_message is true, call the mail.attach_alternative method with html_message and string 'text/html' as arguments. call the mail.send method with fail_silently set to fail_silently as argument. substitute fail_silently for self.fail_silently. pop the value under the 'stream' key of the kwargs dictionary, if it exists replace it for self.stream, if not replace sys.stdout for self.stream. call the method threading.RLock, substitute the result for self._lock. call the method msg.as_bytes, substitute the result for msg_data. if method msg.get_charset evaluates to true, call the get_output_charset method on the return value of the msg.get_charset method, substitute the result for charset, otherwise if it is false, substitute the string 'utf-8' for charset. call the method msg_data.decode with argument charset, substitute the result for msg_data. if email_messages is false, msg_count is an integer 0. call the method self.open, substitute the result for stream_created. increment msg_count by one. if stream_created is true, if Exception exception is caught, pop the value under the 'file_path' key of kwargs dictionary, substitute it for self.file_path. if not, if OSError, renamed to err, is caught, call the strftime function with argument string "%Y%m%d-%H%M%S" on the return value of the function datetime.datetime.now, substitute the result for timestamp. fname is a string "%s-%s.log", with '%s' replaced by timestamp and absolute value of the return value of the function id with argument self, respectively. finally perform, if mail doesnt have an 'outbox' attribute, mail.outbox is an empty list. msg_count is integer 0. increment mes_count by one. call the method mail.outbox.extend with messages. use_tls set to None, fail_silently set to False, use_ssl set to None, timeout set to None and unpacked dictionary kwargs. call the __init__ method from the base class of the EmailBackend class with argument fail_silently set to fail_silently. if username is None substitute settings.EMAIL_HOST_USER for self.username, if not substitute username for self.username. if password is None substitute settings.EMAIL_HOST_PASSWORD for self.username, if not substitute password for self.password. if use_tls is None substitute settings.EMAIL_USE_TLS for self.username, if not substitute use_tls for self.use_tls. if use_ssl is None substitute settings.EMAIL_USE_SSL for self.username, if not substitute use_ssl for self.use_ssl. substitute timeout for self.timeout. call the method threading.RLock, substitute the result for self._lock. substitute smtplib.SMTP_SSL for connection_class if self.use_ssl is true, if not substitute smtplib.SMTP for connection_class. connection_params is a dictionary with 1 initial entry: return value of the function DNS_NAME.get_fqdn for 'local_hostname'. set value under the 'timeout' key of the connection_params to self.timeout. if smtplib.SMTPException exception is caught, if ssl.SSLError or smtplib.SMTPServerDisconnected exception occurred, if smtplib.SMTPException exception is caught, finally perform, if email_messages is false, call the method self.open, substitute the result for the new_conn_created. num_sent is an integer 0. if sent is true, increment num_sent by one. if new_conn_created is true, call the email_message.recipients method, if it evaluates to false, call the function sanitize_address with arguments email_message.from_email and email_message.encoding, substitute the result for from_email. call the function sanitize_address with arguments addr and email_message.encoding, for every addr in return value of the function email_message.recipients, store the results in a recipients list. call the method self.connection.sendmail with arguments: from_email, recipients and return value of the function message.as_bytes. if smtplib.SMTPException exception is caught, from email import charset as Charset, encoders as Encoders, message_from_string and generator. from email.mime.text import MIMEText into default name space. from email.mime.multipart import MIMEMultipart into default name space. from email.mime.base import MIMEBase into default name space. from email.mime.message import MIMEMessage into default name space. from email.header import Header into default name space. from email.utils import formatdate, getaddresses, formataddr and parseaddr into default name space. call the function Charset.Charset with argument string 'utf-8', substitute the result for utf8_charset. utf8_charset.body_encoding is None. DEFAULT_ATTACHMENT_MIME_TYPE is a string 'application/octet-stream'. call the function time.time, substitute the result for timeval. call the function time.gmtime with argument timeval, use string '%Y%m%d%H%M%S' and the previous result as an argument for the call to the time.strftime function, substitute the result for utcdate. if AttributeError exception is caught, pid is integer 1. call the function random.randrange with argument integer 100000, substitute the result for randint. if idstring is None, idstring is an empty string. if not, append idstring to the '.' character, substitute it for idstring. substitute DNS_NAME for idhost. msgid is a string '<%s.%s.%s%s@%s>', replace '%s' with utcdate, pid, randint, idstring and idhost, respectively. ADDRESS_HEADERS is a set containing strings: 'from', 'sender', 'reply-to', 'to', 'cc', 'bcc', 'resent-from', 'resent-sender', call the function force_text with argument val, substitute it for val. if characters '\n' or '\r' are contained in val, raise an BadHeaderError exception with argument string "Header values can't contain newlines (got %r for header %r)", call the method val.encode with argument string 'ascii'. if UnicodeEncodeError exception is caught, convert name to lower case, if it is contained in ADDRESS_HEADERS,s call the function sanitize_address with arguments addr and encoding, for every addr in return value of the getadresses function with tuple containing val as argument, join all the results into a string separated by ', ', substitute the result for val. if not, call the encode function on the Header class instance, created with arguments val and encoding, substitute the result for val. if not, if name converted to lower case equals to string 'subject', call the encode function on the Header class instance, created with argument val, substitute the result for val. call the parseaddr function with return value of the force_text with argument addr, as argument, substitute the result for addr. nm and addr are addr. call the encode function on the Header class instance, created with arguments nm and encoding, substitute the result for nm. if UnicodeEncodeError exception is caught, call the encode function on the Header class instance, created with arguments nm and string 'utf-8', substitute the result for nm. call the addr.encode method with string 'ascii' as an argument. if UnicodeEncodeError exception is caught, if character '@' is contained in addr, call the addr.split method with character '@' and integer 1 as arguments, substitute the result for localpart and domain, respectively. instantiate Header class with localpart and encoding, convert it to a string, substitute the result for localpart. call the decode function with argument string 'ascii' on the return value of the method domain.encode with argument string 'idna' substitute the result for domain. join localpart and domain in a string separated by '@' character, substitute it for addr. if not, call the encode function on the Header class instance, created with arguments addr and encoding, substitute the result for addr. call the formataddr function with argument tuple containing 2 elements nm and addr. fp is a instance of a class six.StringIO. g is an instance of a class generator.Generator called with fp and mangle_from_ set to False. call the method g.flatten with arguments self and unixfrom set to unixfrom. if six.PY2 is boolean True, substitute as_string for as_bytes. if not, fp is a instance of a class six.BytesIO. g is an instance of a class generator.BytesGenerator called with fp and mangle_from_ set to False. call the method g.flatten with arguments self and unixfrom set to unixfrom. call the function forbid_multi_line_headers with 3 arguments: name, val and string 'ascii', substitute the result for name and val, respectively. call the method MIMEMessage.__setitem__ with arguments self, name and val. if charset equals to string 'utf-8', delete the value under the 'Content-Transfer-Encoding' key of self dictionary. if integers 3 and 2 in a tuple are smaller than the sys.version_info and sys.version_info is smaller than integers 3,4 and 4 in a tuple, respectively, call the method text.encode with argument utf8_charset.output_charset, substitute the result for payload. call the method payload.decode with 2 arguments: string 'ascii' and string 'surrogateescape', substitute the result for self._payload. call the method self.set_charset with utf8_charset as an argument. if not, call the method payload.decode with 2 arguments: text and utf8_charset, substitute the result for self._payload. call the method self.replace_header with argument string 'Content-Type', 'text/%s; charset="%s"', where '%s' symbols are replaced by: subtype and charset, respectively. if not, call the method MIMEText.__init__ with 4 arguments: self, text, subtype and charset. call the function forbid_multi_line_headers with 3 arguments: name, val and self.encoding, substitute the result for name and val, respectively. call the method MIMEText.__setitem__ with arguments self, name and val. call the method MIMEMultipart.__init__ with 5 arguments: self, _subtype, boundary, _subparts and unpacked dictionary _params. call the function forbid_multi_line_headers with 3 arguments: name, val and self.encoding, substitute the result for name and val, respectively. call the method MIMEMultipart.__setitem__ with arguments self, name and val. content_subtype is a string 'plain'. mixed_subtype is a string 'mixed'. encoding is None. if to is true, if not, if cc is true, put cc into a list, assign it to self.cc. if not, if bcc is true, put bcc into a list, assign it to self.bcc. if not, if from_email exists substitute from_email for self.from_email, if not substitute settings.DEFAULT_FROM_EMAIL for self.from_email. substitute subject for self.subject. substitute body for self.body. if attachments exists substitute it for self.attachments, if not attachments is an empty list. if headers exists substitute it for self.extra_headers, if not extra_headers is an empty dictionary. call the self._create_message method with argument msg, substitute it for msg. substitute self.subject for value under the 'Subject' key of msg dictionary. join elements of self.cc into a string separated by ', ', substitute the result for value under the 'Cc' key of msg dictionary. if 'date' is not in header_names, call the formatdate function, substitute it for value under the 'Date' key of msg dictionary. convert name to lower case if it equals to string 'from' or 'to, if content is not None raise an error. if mimetype is not None raise an error. if not, if content is not None raise an error. read the whole file f, substitute the result for content. call the method self.attach with arguments filename, content and mimetype. substitute msg for body_msg. msg is an instance of a class SafeMIMEMultipart, created with arguments: _subtype set to self.mixed_subtype and encoding set to encoding. call the method msg.attach with an argument body_msg. for every attachment in self.attachments, call the method msg.attach with an argument attachment. if not, call the method self._create_attachment with an unpacked list attachment as an argument, use the result as an argument for the call to the msg.attach method. call the method mimetype.split with arguments: character '/' and integer 1, substitute the result for basetype and subtype, respectively. if basetype equals a string 'text', attachment is an instance of a class SafeMIMEText, created with arguments: content, subtype and encoding. call the message_from_string function with an argument content, substitute the result for content. attachment is an instance of a class SafeMIMEMessage, created with the arguments content and subtype. if not, attachment is an instance of a class MIMEBase, created with the arguments basetype and subtype. call the method attachment.set_payload with an argument content. call the method Encoders.encode_base64 with an argument attachment. if mimetype is None, call the mimetypes.guess_type with an argument filename, assign the result to the mimetype and _, respectively. if mimetype is None, substitute DEFAULT_ATTACHMENT_MIME_TYPE for mimetype. call the method self._create_mime_attachment with the arguments content and mimetype, substitute the result for attachment. if filename is true, call the method filename.encode with an argument string 'ascii' if UnicodeEncodeError exception is caught, if six.PY2 is true, call the method filename.encode with an argument string 'utf-8', substitute the result for filename. filename is a tuple containing 3 initial elements: string 'utf-8', and empty string and filename. call the method attachment.add_header with 3 arguments: string 'Content-Disposition', string 'attachment' and filename set to filename. alternative_subtype is a string 'alternative'. call the method __init__ from the base class of the EmailMultiAlternatives class, with 9 arguments: subject, body, from_email, to, bcc, connection, attachments, headers and cc. if alternatives exists substitute it for self.alternatives, if not self.alternatives is an empty list. if content is None, raise an error. if mimetype is None, raise an error. substitute msg for body_msg. msg is an instance of a class SafeMIMEMultipart, created with the arguments: _subtype set to self.alternative_subtype and encoding set to encoding. call the msg.attach with an argument body_msg. for every alternative in self.alternatives, call the method self._create_mime_attachment with unpacked list alternative as an argument, use the result as an argument for the call to the msg.attach method. call the function socket.getfqdn, substitute the result for self._fqdn. DNS_NAME is a instance of CachedDnsName class. for every f in return value of the os.listdir function called with an argument command_dir, append f without 3 last elements to a list, only if f doesnt start with character '_' and doesnt ends with string '.py', return the resulting list. if OSError exception is caught, replace '%s' in string '%s.management.commands.%s' with app_name and name, respectively, use it as an result for the call to the decorator lru_cache.lru_cache with an argument maxsize set to None. commands is an dictionary containing elements: string 'django.core' for every name in the function find_commands return value, called with first element of __path__ as an argument. call the function get_commands, substitute the value under the name key of the return value, for app_name. if KeyError exception is caught, substitute app_namefor command. if not, call the function load_command_class with arguments: app_name and name, substitute the result for command. if command.use_argparse is true, create dictionary out of the unpacked dictionary options, using defaults._get_kwargs as a mapping function, substitute the result for defaults. if not, create dictionary out of the unpacked dictionary options, using defaults.__dict__ as a mapping function, substitute the result for defaults. if argv is true, substitue it for self.argv, if not substitute sys.argv for self.argv. if commands_only is true, call the function get_commands, call the method keys on the result, substitute sorted result for usage. if not, usage is a list containing 4 entries: an empty string, string "Type '%s help ' for help on a specific subcommand.", where '%s' is replaced with self.prog_name, an empty string and string "Available subcommands:". call the method collections.defaultdict with a argument: lambda function without arguments that returns an empty list, substitute the result for commands_dict. for every name and app in return value of the function six.iteritems calle with return argument of function get_commands as an arugment, if not, call the method app.rpartition with an argument '.', substitute last element of the result for app. call the color_style function, substitute the result for style. for every app in sorted return value of the commands_dict.keys function, for every name in sorted value under the app key of the commands_dict dictionary, call the function get_commands, substitute it for commands. substitute value under the subcommand key of the commands dictionary for app_name. if KeyError exception is caught, call the method sys.stderr.write with an argument string "Unknown command: %r\nType '%s help' for usage.\n", where '%r' is replaced with subcommand and '%s' is replaced with self.prog_name. call the function sys.exit with an argument integer 1. substitute app_name for klass. if not, call the function load_command_class with arguments app_name and subcommand, substitute the result for klass. slit by whitespace the value under the 'COMP_WORDS' key of the os.environ dictionary, substitute the result without the first element for cwords. convert to an integer value under the 'COMP_CWORD' key of the os.environ dictionary, substitute it for cword. substitute cwords element at the cword decremented by 1 index for curr. if IndexError exception is caugh, curr is an empty string. call the function get_commands, convert the result to a list, append string 'help' to it, substitute it for subcommands. options is a list containing a tuple with 2 entries: string '--help' and None. if cword equlals a integer 1, filter all the subcommands element through the lambda function with an argument x, that evaluates the method x.startswith, call the method self.fetch_command with first element of cwords as an argument, substitute it for subcommand_cls. if first element of cwords equals a string 'runfcgi', append tuple containing two entries: k and integer 1 to options, for every k in FASTCGI_OPTIONS. otherwise if first element of cwords is contanied in tuple with 8 entries: 'dumpdata', 'sql', 'sqlall', 'sqlclear', 'sqlcustom', call the method apps.get_app_configs, substitute the result for app_configs. if subcommand_cls.use_argparse is true, append to options a tuple containing 2 entries: firs element of sorted list of the s_opt.option_strings, and evaluated boolean expression s_opt.nargs doesnt equal to integer 0, for every s_opt in parser._actions, only if s_opt.option_strings is true, if not, append to options a tuple containing 2 entries: result of the method s_opt.get_opt_string and s_opt.nargs, for every s_opt in parser.option_list. for every x in slice of cwords from the second element to the element at the cword decremented by 1 index, split x by character '=' and append first element of the result to the prev_opts list. for every opt in options, if first element of opt is not contained in prev_opts, append opt to the list, substitute it for options. append tuple containing 2 elements: k and v to a list, for every k and v in options, only if k starts with curr, sort the result and substitute it for options. for every option in options, substitute first element of options for opt_label. if second element of options is true, append '=' to opt_label. print opt_label to the standard output. call the function sys.exit with an integer 1 as an argument. if IndexError exception is caught, subcommand is a string 'help'. and args, respectively. call the method handle_default_options with an argument options. if CommandError exception is caught, no_settings_commands is a list containing entries: 'help', 'version', '--help', '--version', '-h', 'compilemessages', 'makemessages', if ImproperlyConfigured renamed to exc, exception is caught, substitute exc for self.settings_exception, if subcommand is contained in no_settings_commands, call the method django.setup. if subcommand equals to a string 'help'. call the method self.main_help_text with an argument commands_only set to boolean True, append new line to it, write it to sys.stdout. call the method self.main_help_text append new line to it, write it to sys.stdout. if not, call the method django.get_version append new line to it, write it to sys.stdout. and a list containing a string '-h', call the method self.main_help_text, append new line to it, write it to sys.stdout. if not, utility is a instance of ManagementUtility class, created with an argument argv. call the method utility.execute. from argparse import ArgumentParser into default name space. from optparse import OptionParser into default name space. substitute cmd for self.cmd. if self.cmd._called_from_command_line is true, if not, if options.pythonpath is true, if out has an 'isatty' argument and return value of the function out.isatty is true, substitute style_func for self.style_func. substitute ending for self.ending. if ending is None substitute self.ending for ending. if ending is true and msg doesnt end with ending, append ending to msg. if f is not None append it to a list for every f in tuple containing 3 elements: style_func, self.style_func, and lambda function returning x for x, substitute the firs element of resulting list for style_func. call the function style_func with an argument msg, use the result as an argument for the call to the function force_str, options_list is an empty tuple. help is an empty string. if self has an 'requires_model_validation' attribute, has_old_option is boolean True, otherwise it is boolean False. if self has an 'requires_system_checks' attribute, has_new_option is boolean True, otherwise it is boolean False. if has_old_option is true, call the function warnings.warn with 2 arguments: string '"requires_model_validation" is deprecated ' 'in favor of "requires_system_checks".' and RemovedInDjango19Warning. if has_old_option and has_new_option are both true, raise an ImproperlyConfigured exception wiht an argument string 'Command %s defines both "requires_model_validation" ' or if it is false, but has_old_option is true use self.requires_model_validation, if they are both false use boolean True as an argument. property decorator, substitute '%s' in the string '%%prog %s [options] %s' with subcommand and self.args, respectively, substitute it for usage. if not, call the function warnings.warn with 2 arguments: string "OptionParser usage for Django management commands " "is deprecated, use ArgumentParser instead" and RemovedInDjango20Warning. parser is an instance of the object OptionParser, created with arguments: prog set to prog_name, usage set to return value of the method self.usage called with an argument subcommand, version set to return value of the method self.get_version. call the method parser.add_option with 8 arguments: string '-v', string '--verbosity', action set to string 'store', dest set to string 'no_color' default set to boolean False and help set to a string "Don't colorize the command output.". for every opt in self.option_list, if not, call the function vars with an argument options, substitute the result for cmd_options. if not, if not, call the function vars with an argument options, substitute the result for cmd_options. call the function handle_default_options with an argument options. if Exception, renamed to e, exception is caught, if it exists, get 'stderr' attribute of self, substitute it for stderr, if not, stderr is an instance of OutputWrapper class, created with arguments sys.stderr and self.style.ERROR. replace '%s' in string '%s: %s' with e.__class__.__name__ and e, respectively, write it to the stderr stream. call the function sys.exit with an argument integer 1. self.stdout is an instance of OutputWrapper class created with an argument: value under the 'stdout' key of the options dictionary, if the key doesnt exists use sys.stdout as an argument. if value under the 'no_color' key of the options dictionary. self.stderr is an OutputWrapper object instance, created with value under the 'stderr' key of the options dictionary as an argument, if the key doesnt exists use sys.stderr as an argument. if not, self.stderr is an instance of an OutputWrapper object, created with 2 arguments: value under the 'stderr' key of the options dictionary, if it doesnt exists use the sys.stderr instead, and self.style.ERROR. saved_locale is None. raise an CommandError exception with an argument string, "Incompatible values of 'leave_locale_alone' " call the method translation.get_language, substitute th result for saved_locale. call the method translation.activate with an argument string 'en-us'. if self.requires_system_checks is true and values under the 'skip_validation' and 'skip_checks' keys of the options dictionary are false, if output is true, append the result to the '\n' string, write it to self.stdout. finally perform, if saved_locale is not None, call the method translation.activate with an argument saved_locale. app_configs is not None. if not, call the method self.check with 2 arguments app_configs set to app_configs, display_num_errors set to display_num_errors, return the result. call the method checks.run_checks with 2 arguments: app_configs set to app_configs, tags set t tags, substitute the result for all_issues. msg is an empty string. visible_issue_count is an integer 0. if all_issues is true, append e to debugs list for every e in all_issues, if e.level is lesser than checks.INFO and result of the method e.is_silenced in false. append e to infos list for every e in all_issues, if checks.INFO is lesser or equal to e.level, and e.level is lesser than checks.WARNING and result of the method e.is_silenced in false. append e to warnings list for every e in all_issues, if checks.WARNING is lesser than or equal to e.level, and e.level is lesser than checks.WARNING and result of the method e.is_silenced in false. append e to errors list for every e in all_issues, if checks.ERROR is lesser than or equal to e.level, and e.level is lesser than checks.CRITICAL. append e to criticals list for every e in all_issues, if checks.CRITICAL is lesser than or equal to e.level. sorted_issues is a list of tuples with 5 entries: criticals and 'CRITICALS', errors and 'ERRORS', warnings and 'WARNINGS', infos, 'INFOS' for every issues and group_name in sorted_issues, if issues is true, if e.is_serious method evaluates to true, call the function color_style, on the result call the method ERROR with result of the force_str called with an argument e, if not call the function color_style on the result call the method ERROR with result of the force_str called with an argument e, for every e in issues, formatted is a tuple containing the previous result. sort elements formatted, join them in the list separated with newline character, substitute the result for formatted. substitute '%s' in the string '\n%s:\n%s\n', with group_name and formatted, substitute the result for msg. if msg is true, replace '%s' in string "System check identified some issues:\n%s" with msg, substitute it for msg. if display_num_errors is true, if msg is true, append newline character to msg. append string "System check identified %s (%s silenced)." to msg, replace first '%s' for: string "no issues", if visible_issue_count equals to integer 0, or for string "1 issue" if visible_issue_count equals integer 1, or for string "%s issues", with '%s' replaced by visible_issue_count, subtract visible_issue_count from length of all_issues, and substitute it for second '%s' in the stirting string. if any element in the return value of the e.is_serious method is true, and if return value of the method e.is_silenced is false, missing_args_message is an string "Enter at least one application label.". call the method apps.get_app_config with an argument app_lable, for every app_label in app_labels, append the results to app_configs list. output is an empty list. if app_output is true, substitute self.handle_app for handle_app. if AttributeError exception is caught, if not, call the function warnings.warn with 3 argument: string "AppCommand.handle_app() is superseded by AppCommand.handle_app_config().", label is a string 'label' substitute string "Enter at least one %s.", with '%s' replaced by label, for missing_args_message. output is an empty list. for every label in labels, call the method self.handle_label with 2 arguments: label and unpacked dictionary options, substitute the result for label_output. if label_output is true, call the function warnings.warn with 2 arguments: string "NoArgsCommand class is deprecated and will be removed in Django 2.0. " substitute sys.platform for plat. evaluate the logic expression, plat does not equals to string 'Pocket PC', and plat does not equals to string 'win32' or string 'ANICON' is in os.environ, substitute the evaluated boolean for supported_platform. if sys.stdout has an attribute named 'isatty' and call to the sys.stdout.isatty returns boolean True, substitute True for is_a_tty. if supported_platform is False or is_a_tty is False, call the function supports_color, if evaluates to False, substitute return value of function no_style for style. if not, get the value under the key 'DJANGO_COLORS' of os.environ dictionary, if key doesnt exists return empty string, assign the result to DJANGO_COLORS. call the function termcolors.parse_color_setting with DJANGO_COLORS as an argument, assign the result to color_settings. if color_setting is True, style is an instance of the dummy class. for every role in termcolors.PALETTES list at the index termcolors.NOCOLOR_PALETTE, assign the value of the dictionary color_settings under the key role to format, if key doesnt exist assign the empty dictionary. sets the role attribute of the style object to the value of the call to the termcolors.make_style function with dictionary format as an argument. substitute style.ERROR for style.ERROR_OUTPUT. if not, substitute return value of function no_style for style. help is a string "Checks the entire Django project for potential problems.". if value under the 'list_tags' key of options dictionay is true, call the method registry.tags_available, sort the result and join it into a string, separate by newlines, write it to self.stdout. if app_labels is true, call the method apps.get_app_config with an argument app_label, for every app_label in app_labels, append the results to a list, substitute the resulting list for app_config. if not, app_configs is None. get the value under the 'tags' key of the options dictionary, if it exists substitute it for tags, if not, tags is None. call the method self.check with arguments: app_configs set to app_configs, tags set to tags, display_num_errors set to boolean True. open the file fn in read mode, with file descriptor as f, read 4 bytes from file f and store it in sample. evaluate the boolean expression, if first three characters of sample equals to string of bytes '\xef\xbb\xbf\', if IOError or OSError exceptions occurred, help is string 'Compiles .po files to .mo files for use with builtin gettext support.'. program is string 'msgfmt' program_options is list containing string '--check-format'. get the value under the key 'locale' of the options dictionary, substitute it for locale. get the value under the key 'exclude' of the options dictionary, substitute it for exclude. if evaluation of the function find_command with self.program as argument equals to None, raise CommandError exception, with sring "Can't find %s. Make sure you have GNU gettext tools 0.15 or newer installed." as argument, substitute '%s' with self.program. if basedirs is empty, raise CommandError exception with string "This script should be run from the Django Git checkout or your project or app tree, or with the settings module specified.", as argument. all_locales is an empty string. for every basedir in basedirs, take locale or all_locales, whichever is not empty, respectively, and substitute it for locales. locales is relative complement of set exclude in set locales. for every basedir in basedirs, if locales in not empty, if not, dirs is a list containing basedir. locations is an empty list. for every ldir in dirs, for dirpath, dirnames and filenames, respectively, in directory tree tuple starting from the ldir, extend locations with tuple containing dirpath and f, for every f in filenames, only if it ends with string '.po'. if locations is not empty, call the self.compile_messages with locations as argument, for every i and tuple containing dirpath and f, in enumerated list of locations, call the self.stdout.write method with string 'processing file %s in %s\n' as argument, replacing all the occurrences of '%s' with f and dirpath, respectively. evaluate function has_bom with po_path as argument. raise CommandError exception with string "The %s file has a BOM (Byte Order Mark). Django only supports .po files encoded in UTF-8 and without any BOM.", with '%s' replaced with po_path, as argument. if i equals to integer 0 and call the self.stderr.write, with string "The po files under %s are in a seemingly not writable location. mo files will not be updated/created." as argument, with '%s' replaced by dirpath. extend self.program list with self.program_options, string '-o', return value of the npath function with string '.mo' appended to the base_path as argument, and return value of the npath function with string '.po' appended to the base_path as argument, substitute it for args. call the popen_wrapper with args as the argument, assign the result to the output, errors and status, respectively. if status is True, if errors is True, msg is a string "Execution of %s failed: %s", with '%s' replaced by self.program and errors. if not, msg is a string "Execution of %s failed", with '%s' replaced by self.program. help is an string "Creates the tables needed to use the SQL cache backend.". get value under the 'database' key of the options dictionary, substitute it for db. for every tablename in tablenames, call the method self.create_table with arguments: db and tablename. if not, substitute value under the cache_alias key of the caches dictionary for cache. all the method self.create_table with arguments: db and cache._table. cache is an instance of BaseDatabaseCache class, created with arguments: tablename and an empty dictionary. call the method router.allow_migrate with 2 arguments: database and cache.cache_model_class, if it evaluates to false, replace '%s' in string "Cache table '%s' already exists." with tablename, write it to the self.stdout stream. name set to a string 'cache_key', max_length set to integer 255, unique set to boolean True and primary_key set to boolean True, return value of the method models.TextField called with argument name set to a string 'value', and return value of the method models.DateTimeField called with 2 arguments: name set to string 'expires' and db_index set to True. table_output is an empty list. index_output is an empty list. for every f in fields, if f.primary_key is true, if f.db_index is true, if f.unique is true, substitute "UNIQUE " for unique, otherwise unique is an empty string. replace '%s' in string "CREATE %sINDEX %s ON %s (%s);" with: unique, return value of the function qn called with an argument: full_statement is a list containing: string "CREATE TABLE %s (", where %s is replaced by result of the function qn called with an argument tablename. for every i and line in enumerated iterable table_output, join full_statement into a string, separated by newlines, use it as an argument for the call to the method curs.execute. if DatabaseError, renamed to e, exception is caught, tablename and return value of the function force_text called with an argument e, respectively. for every statement in index_output, execute statement on the database that curs points to. replace '%s' in string "Cache table '%s' created." with tablename, write it to self.stdout. help is a tuple containing a string "Runs the command-line client for specified database, or the default database if none is provided.". if OSError exception is caught, return dictionary created out of tuple elements k and printable representation of v, call the function module_to_dict with an argument global_settings, substitute it for default_settings. output is an empty string. help is a tuple containing a string "Output the contents of the database as a fixture of the given " dest is 'use_base_manager', default is boolean False and help is a string '(use multiple --exclude to exclude multiple apps/models).'. call the method parser.add_argument with 3 arguments: string '--pks', dest set to string 'primary_keys', get the value under the 'format' key of the options dictionary, substitute the result for format. get the value under the 'indent' key of the options dictionary, substitute the result for indent. get the value under the 'database' key of the options dictionary, substitute the result for database. get the value under the 'exclude' key of the options dictionary, substitute the result for exclude. get the value under the 'output' key of the options dictionary, substitute the result for output. get the value under the 'traceback' key of the options dictionary, substitute the result for traceback. get the value under the 'use_natural_keys' key of the options dictionary, substitute the result for use_natural_keys. if use_natural_keys is true, call the function warnings.warn with an argument string "``--natural`` is deprecated; use ``--natural-foreign`` instead.", and RemovedInDjango19Warning. get the value under the ' use_natural_foreign_keys' key of the options dictionary, substitute the result for use_natural_foreign_keys. get the value under the 'use_natural_primary_keys' key of the options dictionary, substitute the result for use_natural_primary_keys. get the value under the 'use_base_manager' key of the options dictionary, substitute the result for use_base_manager. get the value under the 'primary_keys' key of the options dictionary, substitute the result for pks. if pks is true, split string pks by ',', substitute the result for primary_keys. if not, primary_keys is an empty list. excluded_apps is an empty set. excluded_models is an empty set. for every exclude in excludes, if '.' is contained in exclude, call the method apps.get_model with exclude as an argument, substitute it for model. if LookupError exception is caught, add model to excluded_models set. if not, if LookupError exception is caught, if primary_keys is true, for every app_config in return value of the method apps.get_app_configs, only if app_config.models_module is not None, and app_config is not contained in excluded_apps. if not, app_list is an instance of a class OrderedDict. for every label in app_labels, split label by '.', assign the result to app_label and model_label, respectively. if LookupError exception is caught, if LookupError exception is caught, if app_list_value is not None, if mode is not contained in app_list_value, if primary_keys is true, substitute label for app_label. if LookupError exception is caught, if format is not contained in return value of the method serializers.get_public_serializer_formats, call the method serializers.get_serializer with an argument format. if serializers.SerializerDoesNotExist exception is caught, call the method app_list.items, use the result as an argument for the call to the function sort_dependencies, for every model in result, if model is contained in excluded_models, if model._meta.proxy is false and return value of the function router.allow_migrate called with arguments using and model is true, if use_base_manager is true, substitute model._base_manager for objects. if not, substitute model._default_manager for objects. call the method objects.using with an argument using, call the method order_by on the result with an argument model._meta.pk.name, substitute the result for queryset. if primary_keys is true, call the method queryset.filter with an argument pk__in set to primary_keys, substitute the result for queryset. for every obj in result of the method queryset.iterator, open the output file in writing mode if output is true, assign the file descriptor to stream, otherwise stream is None. call the method serializers.serialize with 6 arguments: format, result of the function get_objects, indent set to indent, use_natural_foreign_keys set to use_natural_foreign_keys, use_natural_primary_keys set to use_natural_primary_keys, and stream set to stream, if the stream is true, otherwise stream set to self.stdout. finally perform, if stream is true, close the file stream. if Exception, renamed to e, exception is caught, if show_traceback is true, model_dependencies is an empty list. models is an empty set. if model_list is None, for every model in model_list, add model to models set. if model has an 'natural_key' attribute, get 'dependencies' attribute of the model.natural_key, substitute it for deps, if the attribute doesnt exist, deps in an empty list. if deps is true, for every dep in deps call the method apps.get_model with an argument dep, and append the result to the list, substitute it for deps. if not, deps is an empty list. if rel_model has an attribute 'natural_key' and rel_model is not equal to model, if rel_model has an 'natural_key' attribute and rel_model is not equal to model, call the methof model_dependencies.reverse. model_list is an empty list. while model_dependencies is true, skipped is an empty list. while model_dependencies is true, remove first element from model_dependencies, assign it to model and deps, respectively. for every d in deps, if d is not contained in models and d is contained in model_list add boolean True to a tuple, otherwise add boolean False, for every candidate in the result perform following, if candidate is false, if found is true, if not, if changed is false, raise an CommandError with argument: string "Can't resolve dependencies for %s in serialized app list.", where '%s' is replaced with: model._meta.app_label and model._meta.object_name joined into a string, with separator '.', result joined into a string, separated by string ', ' for every model and deps in sorted list of elements skipped sorted by key: return value of the lambda function with an argument obj, and result the __name__ field of the first element of obj. substitute skipped for model_dependencies. help is a tuple containing a string: 'Removes ALL DATA from the database, including data added during ' substitute value under the 'database' key of the options dictionary for database. substitute value under the 'verbosity' key of the options dictionary for verbosity. substitute value under the 'interactive' key of the options dictionary for interactive. get the value 'reset_sequences' key of the options dictionary, if it exists substitute it for reset_sequences, otherwise reset_sequences is boolean True. get the value 'allow_cascade' key of the options dictionary, if it exists substitute it for allow_cascade, otherwise allow_cascade is boolean False. get the value 'inhibit_post_migrate' key of the options dictionary, if it exists substitute it for inhibit_post_migrate, otherwise inhibit_post_migrate is boolean False. call the method sql_flush with 5 arguments: self.style, connection, only_django set to boolean True, reset_sequences set to reset_sequences, allow_cascade set to allow_cascade, substitute the result for sql_list. if interactive is true, request user input from the standard input, assign it o confirm, with the query string: "You have requested a flush of the database." "This will IRREVERSIBLY DESTROY all data currently in the %r database, and return each table to an empty state." "Are you sure you want to do this?"Type 'yes' to continue, or 'no' to cancel: ", where '%s' is replaced with value under the 'NAME' key of the connection.settings_dict dictionary. if not, confirm is a string 'yes'. if confirm equals a string 'yes', for every sql in sql_list, call the method cursor.execute with an argument sql. if Exception, renamed to e, exception is caught, new_msg is a tuple containing a string: "Database %s couldn't be flushed. Possible reasons:\n" " * The database isn't running or isn't configured correctly.\n * At least one of the expected database tables doesn't exist.\n" " * The SQL was invalid.\nHint: Look at the output of 'django-admin.py sqlflush'. That's the SQL this command wasn't able to run.\n" "The full error: %s", where '%s' is replaced by value under the 'NAME' key of the connection.settings_dict dictionary and e. call the function six.reraise with 3 arguments: CommandError, CommandError created with argument new_msg, and third element of the return value of the function sys.exc_info. if inhibit_post_migrate is false, call the method self.emit_post_migrate with arguments verbosity, interactive and database. if value under the 'load_initial_data' key of the options dictionary is true, call the function call_command with 3 arguments: string 'loaddata', string 'initial_data' and unpacked dictionary options. if not, write string "Flush cancelled.\n" to self.stdout stream. class static method, all_models is an empty list. extend all_models list with the result. call the function emit_post_migrate_signal with 4 arguments: all_models converted into a set, verbosity, interactive and database. help is an string "Introspects the database tables in the given database and outputs a Django model module.". db_module is a string 'django.db'. for every line in return value of the method self.handle_inspection called with an argument options, if NotImplementedError exception is caught, raise an CommandError exception with an argument "Database inspection isn't supported for the currently selected database backend.". substitute the result for connection. get the value under the 'table_name_filter' key of the options dictionary, substitute it for table_name_filter. table2model is a lambda function with an argument table_name, return value is the return value of the re.sub method, called with 3 arguments: raw string '[^a-zA-Z0-9]', empty string and result of the method table_name.title. strip_prefix is a lambda function with an argument s, return value is s without the first element if s starts with string 'u'', yield string "# * Remove `managed = False` lines if you wish to allow Django to create, modify, and delete the table" as the result. yield string "# Feel free to rename the models, but don't rename db_table values or field names." as the result. yield string "# Also note: You'll have to insert the output of 'django-admin.py sqlcustom [app_label]'" as the result. known_models is an empty list. if table_name_filter is not None and table_name_filter is callable object, call the function table_name_filter with an argument table_name, if it evaluates to true, if NotImplementedError exception is caught, relations is an empty dictionary. if NotImplementedError exception is caught, indexes is an empty dictionary. used_column_names is an empty list. comment_notes is an empty list. extra_params is an instance of the class OrderedDict. substitute first element of row for column_name. if i is contained in relations, is_relation is boolean True, otherwise is_relation is boolean False. call the method self.normalize_col_name with 3 arguments column_name, used_column_names, is_relation, assign the result to att_name, params and notes, respectively. add params to extra_params dictionary. extend comment_notes list with notes. if column_name is contained in indexes, if value under the 'primary_key' key of the dictionary contained under the column_name key of the dictionary indexes is true, if is_relation is true, if second element of the i-th row of relations equals table_name, rel_to is string 'self', otherwise call the method table2model with second element of the i-th row of relations and substitute it for rel_to. if rel_to is contained in known_models, append rel_to to string 'ForeignKey(, substitute the result for field_type. if not, append rel_to to string 'ForeignKey(, append character "'" to it, substitute the result for field_type. if not, call the method self.get_field_type with 3 arguments connection, table_name and row, assign the result to field_type, field_params, field_notes, respectively. add field_params to extra_params dictionary. extend comment_notes list with field_notes. append '(' to field_type. if field_type equals a string 'AutoField(', if seventh element of row is true, if field_type equals a string 'BooleanField(', field_type is a string 'NullBooleanField(' if not, if field_type is not equal to string 'TextField(' or string 'CharField(', field_desc is a string '%s = %s%s', where '%s' is replaced with: att_name, an empty string if '.' is contained in field_type, or with string 'models.' if it is not and field_type. if extra_params is true, if field_desc doesnt end with '(', append string ', ' to field_desc. in string '%s=%s' replace '%s' with k and return value of the function strip_prefix with an argument printable representation of v, for every k and v in return value of the extra_params.items method, join all results into a string separated by a string ', ', substitute it for field_desc. append string ')' to field_desc. if comment_notes is true, join elements of comment_notes into a string, separated by whitespaces, append it to the string ' #', append the result to field_desc. for meta_line in return value of the method self.get_meta called with an argument table_name. field_params is an empty dictionary. field_notes is an empty list. convert col_name to lowercase, substitute the result for new_name. if new_name is not equal to col_name, if is_relation, if new_name ends with string '_id', substitute new_name, without the last 3 elements for new_name. if not, substitute col_name for value under the 'db_column' key of the field_params dictionary. cal the method re.subn with 3 arguments: raw string '\W', string '_' and new_name. if num_repl is greater than integer 0, call the method new_name.find, with an argument string '__', if it evaluates to greater or equal than integer 0, while the result of the method new_name.find, called with an argument string '__' is greater or equals integer 0, replace all the occurrences of '__' with '_' in new_name. convert col_name to lowercase, on the result call the method find with an argument string '__', if the result is greater of equal to integer 0, if new_name starts with a string '_', if new_name ends with a string '_', convert new_name to a string and append string 'field' to it, substitute the result for new_name. call the method keyword.iskeyword with an argument new_name, if it evaluates to true, append string '_field' to new_name. if first element of new_name is digit, convert new_name to a string and append it to string 'number_', substitute the result for new_name. if new_name is contained in used_column_names, num is an integer 0. in string '%s_%d', replace '%s' with new_name and '%d' with num, while the result is contained in used_column_names, increment num by one. in string '%s_%d', replace '%s' with new_name and '%d' with num, substitute the result for new_name. if col_name is not equal to new_name and field_notes is true, substitute col_name for value under the 'db_column' key of the field_params dictionary. return new_name, field_params and field_notes. field_params is an instance of a class OrderedDict. field_notes is an empty list. call the method connection.introspection.get_field_type with 2 arguments: second element of row and row, substitute the result for field_type. if KeyError exception is caught, field_type is a string 'TextField'. if field_type is a tuple, substitute field_type for field_type and new_params, respectively. call the method field_params.update with an argument new_params.1 if field_type equals a string CharField' and fourth element of row is true, convert fourth element of row to an integer, substitute it for value under the 'max_digits' key of the field_params. if field_type equals a string 'DecimalField', if fifth and sixth elements of row are None, append string 'max_digits and decimal_places have been guessed, as this database handles decimal fields as float' to field_notes. if fifth element of row is not None, substitute it for value under the 'max_digits' key of the field_params, otherwise, value under the 'max_digits' key of the field_params is integer 10. if sixth element of row is not None, substitute it for value under the 'decimal_places' key of the field_params, otherwise, value under the 'decimal_places' key of the field_params is integer 5. if not substitute fifth element of row for value under the 'max_digits' key of the field_params. substitute sixth element of row for value under the 'decimal_places' key of the field_params. return field_type, field_params and field_notes. help is an string 'Installs the named fixture(s) in the database.'. missing_args_message is a tuple containing a string "No database fixture specified. Please provide the " get the value under the 'ignore' key of the options dictionary, substitute it for self.ignore. get the value under the 'app_label' key of the options dictionary, substitute it for self.app_label. get the value under the 'hide_empty' key of the options dictionary, if the key exists substitute it for self.hide_empty, call the method transaction.atomic with an argument using set to self.using, with the result, call the method self.loaddata with an argument fixture_labels. call the method transaction.get_autocommit with an argument self.using, if it evaluates to true, call the method serializers.get_public_serializer_formats, substitute the result for self.serialization_formats. self.compression_formats is an dictionary with 3 initial entries: tuple containing 2 elements: open and string 'rb' for None, tuple with 2 arguments: gzip.GzipFile and string 'rb' for 'gz', tuple with 2 arguments: SingleZipReader and string 'r' for 'gzip'. if has_bz2 is true, substitute tuple with 2 elements: bz2.BZ2File and string 'r' for value under the 'bz2' key of the self.compression_formats dictionary. for every fixture_label in fixture_labels, call the method self.load_label with an argument fixture_label. for model in self.models append model._meta.db_table to a list, substitute the resulting list for table_names. if Exception, renamed to e, exception is caught, e.args is a tuple, containing 1 element: string "Problem installing fixtures: %s", where '%s' is replaced with e. call the method connection.ops.sequence_reset_sql with 2 arguments: return value of the no_style and self.models, substitute the result for sequence_sql. if sequence_sql is true, write a string "Resetting sequences\n" to self.stdout stream. for every line in sequence_sql, call the method cursor.execute with an argument line. where '%d' is replaced with self.loaded_object_count and self.fixture_count, respectively. if not, for every fixture_file, fixture_dir and fixture_name in return value of the method self.find_fixtures called with an argument fixture_label, self.parse_name, assign the result to _, ser_fmt and cmp_fmt, respectively. get the value under the cmp_fmt key of the self.compression_formats dictionary, assign it to open_method and mode. call the function open_method with arguments: fixture_file and mode, substitute the result for fixture. objects_in_fixture is integer 0. loaded_objects_in_fixture is integer 0. call the method self.stdout.write with an argument string "Installing %s fixture '%s' from %s.", substitute '%s' with ser_fmt, fixture_name and return value of the function humanize called with an argument fixture_dir. call the method serializers.deserialize with 4 arguments: ser_fmt, fixture, using set to self.using, and ignorenonexistent set to self.ignore, substitute the result for objects. for every obj in objects, increment objects_in_fixture by one. call the method router.allow_migrate with 2 arguments: self.using and obj.object.__class__, if it evaluates to true, increment loaded_objects_in_fixture by one. add obj.object.__class__ to self.models set. call the method obj.save with an argument using set to self.using. if DatabaseError or IntegrityError, renamed to e, exceptions are caught, e.args is a tuple containing string "Could not load %(app_label)s.%(object_name)s(pk=%(pk)s): %(error_msg)s, increment self.loaded_object_count by loaded_objects_in_fixture. increment self.fixture_object_count by objects_in_fixture. if Exception, renamed to e, exception is caught, e.args is a tuple containing string "Problem installing fixture '%s': %s", where '%s' is replaced with fixture_file, e. finally perform, call the method fixture.close. if objects_in_fixture equals integer 0, call the method warnings.warn with 2 arguments: string "No fixture data found for '%s'. (File format may be invalid.)", where '%s' is replaced with fixture_name, and RuntimeWarning. decorator method lru_cache.lru_cache with an argument maxsize set to None. call the method self.parse_name with an argument fixture_label, substitute the result for fixture_name, ser_fmt, cmp_fmt, respective. databases is a list containing 2 elements: self.using and None. call the method self.compression_formats.keys, convert it to list, substitute it for cmp_fmts if cmp_fmt is None, otherwise cmp_fmts is a list containing cmp_fmt. call the method serializers.get_public_serializer_formats, substitute the result for ser_fmts if ser_fmt is None, call the method self.stdout.write with an argument string "Loading '%s' fixtures...", where '%s' is replaced with fixture_name. if not, substitute self.fixture_dirs for fixture_dirs. for every ext in combo, if ext is true, join it to a string, separated by '.', put the result in a tuple, perform the previous for every combo in result of the function product called with 3 arguments: databases, ser_fmts and cmp_fmts, substitute the result for suffixes. join fixture_name and suffix into a string, separated by '.' for every suffix in suffixes, put the results in set, substitute it for targets. fixture_files is an empty list. for every fixture_dir in fixture_dirs, call the method self.stdout.write with an argument string "Checking %s for fixtures...", where '%s' is replaced with result of the function humanize, called with an argument fixture_dir. fixture_files_in_dir is an empty list. call the method self.stdout.write with an argument string "No fixture '%s' in %s.", where '%s' is replaced with fixture_name, fixture_name and result of the function humanize called with an argument fixture_dir. extend fixture_files list with fixture_files_in_dir. if fixture_name is not equal to string 'initial_data' and fixture_files is false, call the method warnings.warn with an argument string "No fixture named '%s' found." where '%s' is replaced with fixture_name. decorator cached_property, dirs is an empty dictionary. call the method fixture_name.rsplit with 2 arguments: character '.' and integer 2, substitute the result for parts. substitute the last element of parts for cmp_fmt. substitute the last element of parts for parts. if not, cmp_fmt is None. if last element of parts is contained in self.serialization_formats, substitute the last element of parts for ser_fmt. substitute the last element of parts for parts. if not, raise an CommandError with an argument string "Problem installing fixture '%s': %s is not a known serialization format.", replace '%s' with: elements of last element of parts joined into a string and last element of parts. if not, ser_fmt is None. join elements of parts into a string, separated with '.', substitute it for name. return name, ser_fmt and cmp_fmt. call the method re.compile with 2 arguments: raw string '^(?P"Plural-Forms.+?\\n")\s*$', and result of the bitwise OR performed on the re.MULTILINE and re.DOTALL operands, substitute the result for plural_forms_re/ STATUS_OK is integer 0. for every program in programs, call the function find_command with an argument program, if it evaluates to None, raise an CommandError exception with an argument "Can't find %s. Make sure you have GNU gettext tools 0.15 or newer installed.", where '%s' is replaced with program. total_ordering decorator, substitute dirpath for self.dirpath. substitute locale_dir for self.locale_dir. property decorator. if command.verbosity is greater than integer 1, if domain equals a string 'djangojs' and file_ext is contained in command.extensions, perform the following: call the method fp.read, substitute the result for src_data. call the function prepare_js_for_gettext with an argument src_data, substitute it for src_data. call the function io.open with 3 arguments: work_file, string 'w' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: call the method fp.write with an arguments src_data. append command.xgettext_options to the list containing 10 elements: string 'xgettext', string '-d', domain, string '--language=C', otherwise if domains equals a string django' and, file_ext equals '.py' or file_ext is contained in command.extensions, if file_ext is contained in command.extensions, is_templatized is boolean True, otherwise it is boolean False. if is_templatized is true, with the result renamed to fp, perform the following: call the method fp.read, substitute the result for src_data. convert self.file to string and append string '.py' to it, substitute the result for thefile. call the function templatize with 2 arguments: src_data and sliced orig_file, without first 2 elements, substitute the result for content. and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: call the method fp.write with an argument content. append command.xgettext_options to list containing 15 elements: string 'xgettext', string '-d', domain, string '--language=Python', if not, call the function popen_wrapper with argument args, assign the result to msgs, errors and status. if errors is true, if status is not equal to STATUS_OK, if is_templatized is true, call the method command.stdout.write with an argument errors. if msgs is true, if six.PY2 is true, call the method msgs.decode with an argument string 'utf-8', substitute the result for msgs. if is_templatized is true, append work_file to string '#: ', substitute it for old. append orig_file to string '#: ', substitute it for new. if not, append work_file to string '#: ', substitute it for old. append orig_file to string '#: ', substitute it for new. replace every occurrence of old for new in msgs, substitute the result for msgs. call the function write_pot_file with 2 arguments: potfile and msgs. if is_templatized is true, separated by newline, substitute it for msgs. if not, replace every occurrence of string 'charset=CHARSET' for string 'charset=UTF-8' in msgs, substitute the result for msgs. call the function io.open with 3 arguments: potfile, string 'a' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: call the method fp.write with an argument msgs. help is a string "Runs over the entire source tree of the current directory and " msgmerge_options is an list with elements: strings '-q' and '--previous'. msguniq_options is an list with elements: string '--to-code=utf-8'. msgattrib_options is an list with elements: string '--no-obsolete'. xgettext_options is an list with elements: strings '--from-code=UTF-8' and '--add-comments=Translators'. get the value under the 'locale' key of the options dictionary, substitute it for locale. get the value under the 'exclude' key of the options dictionary, substitute it for exclude. get the value under the 'domain' key of the options dictionary, substitute it for self.domain. get the value under the 'all' key of the options dictionary, substitute it for process_all. get the value under the 'extensions' key of the options dictionary, substitute it for extensions. get the value under the 'symlinks' key of the options dictionary, substitute it for self.symlinks. get the value under the 'ignore_patterns' key of the options dictionary, substitute it for ignore_patterns. get the value under the 'use_default_ignore_patterns' key of the options dictionary, if it is true, append list containing 4 elements: 'CVS', '.*', '*~' and '*.pyc', to ignore_patterns. put elements of ignore_patterns into a set, substitute the length of it for self.ignore_patterns. get the value under the 'no_wrap' key of the options dictionary, if it is true, get the value under the 'no_location' key of the options dictionary, if it is true, get the value under the 'no_obsolete' key of the options dictionary, substitute it for self.no_obsolete. get the value under the 'keep_pot' key of the options dictionary, substitute it for self.keep_pot. if self.domain is not equal to string 'django' or string 'djangojs', if extensions is false, substitute it for exts, otherwise exts is a list containing string 'js'. if not, if extensions is false, substitute it for exts, otherwise exts is a list containing 2 elements: string 'html' and string 'txt'. call the function handle_extensions exts, substitute self.extensions. evaluate the boolean expression: locale is None and exclude is false and process_all is false, if not, if not, if process_all is true, substitute all_locales for locales. if not, if locale is not false or None, substitute it for locales, otherwise substitute all_locales for locales. locales is a difference between the locales and exclude sets. if locales is true, call the function check_programs with 3 arguments: strings 'msguniq', 'msgmerge' and 'msgattrib'. call the function check_programs with an argument string 'xgettext'. call the method self.build_potfiles, substitute the result for potfiles. for every locale in locales, replace '%s' in string "processing locale %s\n" with locale, write it to self.stdout. for every potfile in potfiles, call the method self.write_po_file with 2 arguments: potfile and locale. finally perform, call the method self.find_files with an argument string '.', substitute the result for file_list. for f in file_list, if except UnicodeDecodeError exception is caught, substitute '%s' in string "UnicodeDecodeError: skipped file %s in %s" with f.file and f.dirpath, write it to self.stdout. potfiles is an empty list. append self.msguniq_options to a list containing a string 'msguniq', append list containing potfile to the result, substitute it for args. call the function popen_wrapper with an argument args, assign the result to msgs, errors and status, respectively. if six.PY2 is true, call the method msgs.decode with an argument string 'utf-8', substitute it for msgs. if errors is true, if status is not equal to STATUS_OK, call the function io.open with 3 arguments: potfile, string 'w' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: write msgs to fp. ignore is a lambda function with pattern as an argument, return value is the return value of the function fnmatch.fnmatchcase, called with arguments: filename and pattern. call the function ignore with an argument pattern, for every pattern in ignore_patterns, for p in self.ignore_patterns if p ends with dir_suffix take sliced list p from the start, to the negative length of the dir_suffix as the end index and append it to a list, if p doesnt end with dir_suffix, append p to a list, substitute resulting list for norm_patterns. all_files is an empty list. call the function os.walk with 3 arguments: root, topdown set to boolean True, followlinks set to self.symlinks, for every dirpath, dirnames and filenames in the result, for every dirname in list dirnames, use the result as an argument for the call to the os.path.join function, use the result and the norm_patterns as arguments for the call to the is_ignored function, if it evaluates to true, remove dirname from the dirnames. replace '%s' in string 'ignoring directory %s\n' with dirname, write it to self.stdout stream. remove dirname from the dirnames. for every filename in filenames, call the function is_ignored, with arguments: file_path and self.ignore_patterns, if it evaluates to true, replace '%s' in string 'ignoring file %s in %s\n' with filename and dirpath, write it to self.stdout. if not, locale_dir is None. if locale_dir is false, substitute self.default_locale_path for locale_dir. if locale_dir is false, sort all_files and return it. append self.msgmerge_options to a list containing string 'msgmerge', append to it a list containing pofile and potfile, substitute the result for args. call the function popen_wrapper with an argument args, assign the result to msgs, errors and status. if six.PY2 is true, call the method msgs.decode with an argument string 'utf-8', substitute the result for msgs. if errors is true, if statue is not equal to STATUS_OK. if not, call the function io.open with 3 arguments: potfile, string 'r' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: read file fp and substitute the result for msgs. call the method self.copy_plural_forms with arguments: msgs and locale, substitute it for msgs. substitute '%s' in string "#. #-#-#-#-# %s.pot (PACKAGE VERSION) #-#-#-#-#\n" with self.domain, replace all the occurrences of previous string in msgs for an empty string, substitute the result for msgs. call the function io.open with 3 arguments: pofile, string 'w' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: write msgs to fp. append self.msgattrib_options to a list containing string 'msgattrib', append to it a list containing string '-o', pofile and pofile, substitute the result for args. call the function popen_wrapper with an argument args, assign the result to msgs, errors and status, respectively. if errors is true, if status is not equal to STATUS_OK, domains is a tuple with 2 elements: strings 'djangojs' and 'django'. if not, domains is a tuple with element string 'django'. for every domain in domains, call the function io.open with 3 arguments: django_po, string 'r' and encoding set to string 'utf-8' as arguments, with the result renamed to fp, perform the following: read data from file fp, use the result as an argument for the call to the function plural_forms_re.search, substitute it for m. if m is true, replace '%s' in string "copying plural forms: %s\n" with plural_form_line, write it to self.stdout. lines is an empty list. split msgs by newline characters, for every line in result, if found is false and, line is false or return value of the function plural_forms_re.search called with an argument line is false, append newline to plural_form_line, substitute the result for line. join elements of lines into a string, separated by newline characters, substitute it for msgs. help is a string "Creates new migration(s) for apps.". get the value under the 'interactive' key of the options dictionary, substitute it for self.interactive. get the value under the 'dry_run' key of the options dictionary, if the key exists substitute it for self.dry_run, if not, self.dry_run is boolean False. get the value under the 'merge' key of the options dictionary, if the key exists substitute it for self.merge, if not, self.empty is boolean False. crate a set containing of app_labels elements, substitute it for app_labels. bad_app_labels is an empty set. for every app_label in app_labels, call the method apps.get_app_config with an argument app_label. if LookupError exception is caught, call the method bad_app_labels with an argument app_label, if bad_app_labels is true, for every app_label in bad_app_labels, write string "App '%s' could not be found. Is it in INSTALLED_APPS?" with '%s' where '%s' is replaced with app_label, write it for self.stderr. exit the program with the integer 2 as exit code. call the method loader.detect_conflicts, substitute the result for conflicts. for every app and names in result of the method conflicts.items, join names into a string, separated by ', ', join it with app into a string, separated with string '; ', substitute it for name_str. substitute '%s\ in string "Conflicting migrations detected (%s).\nTo fix them run 'python manage.py makemigrations --merge'", write string "No conflicts detected to merge." to self.stdout stream. call the method self.handle_merge with 2 arguments: loader and conflicts, return the result. autodetector is an instance of the MigrationAutodetector class, created with 3 arguments: result of the method loader.project_state, if app_labels is false, crate a dictionary with app mapping and from the class Migration, created with arguments: string 'custom' and app, for every app in app_labels. call the method autodetector.arrange_for_graph with 2 arguments: changes, loader.graph, substitute the result for changes. call the method self.write_migration_files with an argument changes. call the method autodetector.changes with 3 arguments: graph set to loader.graph, trim_to_apps set to app_labels, substitute '%s' in string "No changes detected in app '%s'" with the result of the method app_labels.pop, write it to self.stdout. substitute '%s' in string "No changes detected in apps '%s'" with the app_labels joined into a string, separated by string "', '", write it to self.stdout. if not, write string "No changes detected" to self.stdout stream. call the method self.write_migration_files with an argument changes. directory_created is an empty dictionary. for every app_label and app_migrations in result of the method changes.items, use it as an argument for the call to the method self.style.MIGRATE_HEADING, write the result to self.stdout. for every migration in app_migrations, writer is an instance of MigrationWriter class, created with an argument migration. write the result to self.stdout. for every operation in migration.operations, crate a file named init_path. call the method writer.as_string, substitute the result for migration_string. write migration_string to file fh. use it as an argument for the call to the method self.style.MIGRATE_HEADING, write the result to self.stdout. call the method writer.as_string, append newline to the result, write it to self.stdout. questioner is an instance of a InteractiveMigrationQuestioner class. if not, questioner is an instance of a InteractiveMigrationQuestioner class, created with an argument: defaults set to dictionary with entry: boolean True for 'ask_merge'. for every app_label and migration_names in result of the method conflicts.items, merge_migrations is an empty list. for every migration_name in migration_names, call the method loader.get_migration with arguments app_label and migration_name, substitute the result for migration. call the method loader.graph.forwards_plan with argument a tuple, with 2 elements: app_label and migration_name, common_ancestor is None. for m in merge_migrations append m.ancestry to a list, zip the resulting list into tuples of pairs, for every level in result, apply operator.eq function to elements of level iterable, until level is reduced to a single value, if the result is true, substitute first element of level for common_ancestor. if not, if common_ancestor is None, for every migration in merge_migrations, call the method migration.ancestry.index with an argument common_ancestor, increment the result by one, slice migration.ancestry list from the last result as an starting index to the end, substitute the slice for migration.branch. migration.merged_operations is an empty list. for every node_app and node_name in migration.branch, call the method loader.get_migration with arguments node_app and node_name, extend the migration.merged_operations with the operations field of the result. use it as an argument for the call to the method self.style.MIGRATE_HEADING, write the result to self.stdout. for every migration in merge_migrations, use it as an argument for the call to the method self.style.MIGRATE_HEADING, write the result to self.stdout. for every operation in migration.merged_operations, call the method questioner.ask_merge with an argument app_label, if it evaluates to true, numbers is a list containing return value of the MigrationAutodetector.parse_number method called with an argument migration.name, biggest_number is maximum numbers element. biggest_number is integer 1. subclass is a instance of a class named Migration, derived from the base class Migration, with 1 field: dependencies set to a list of tuples with 2 elements: app_label and migration.name for every migration in merge_migrations. call the method subsclass with 2 arguments: string "%04i_merge", replace '%04i' with biggest_number incremented by one, that occupies minimum 4 places within a string, and app_label, substitute the result for new_migration. writer is instance of MigrationWriter class, created with new_migration argument. call the method writer.as_string, write the result to fh file. substitute '%s' in a string "\nCreated new merge migration %s" with writer path, write it to self.stdout. help is a string "Updates database schema. Manages both apps with migrations and those without.". get the value from the options dictionary under the key 'interactive', substitute it for self.interactive. get the value from the options dictionary under the key 'traceback', substitute it for self.show_traceback. get the value from the options dictionary under the key 'load_initial_data', substitute it for self.load_initial_data. get the value from the options dictionary under the key 'test_database', or False if the key dont exists, substitute it for self.test_database. get the value under the key 'database' of the options dictionary, substitute it for db. call the method self.show_migration_list with connection as first argument, as second argument use value under the 'app_label' key of options dictionary, if exists, if not use None as the second argument, return the result. call the function MigrationExecutor with connection and self.migration_progress_callback as arguments, substitute the result fro executor. call the executor.loader.detect_conflicts, substitute the result fr conflicts. if conflicts is true, for every app and names in key, value tuple pairs of conflicts dictionary join names into a string separated by commas, in "%s in %s" substitute '%s' with names string and app, respective, join all the previous pairs into a string separated by ';', substitute it for name_str. raise CommandError exception, with "Conflicting migrations detected (%s).\nTo fix them run 'python manage.py makemigrations --merge'", if values under the 'app_label' and 'migration_name' keys of the options dictionary are True, assign values under the 'app_label' and 'migration_name' keys of the options dictionary to the app_label and migration_name, respectively. if app_label is not contained in executor.loader.migrated_apps, with '%s' substituted for app_label, as arguments. if migration_name equals to string 'zero', targets is a list containing tuple with two elements, app_label and None. if not, call the executor.loader.get_migration_by_prefix with app_label and migration_name, substitute the result for migration. if AmbiguityError exception is caught, with '%s' substituted for migration_name and app_label, respectively, as arguments. if KeyError exception is caught, with '%s' substituted for migration_name and app_label, respectively, as arguments. targets is a list containing tuple with two elements, app_label and migration.name. substitute the value under the 'app_label' key of options dictionary for app_label. if app_label is not contained in executor.loader.migrated_apps, if it does append it to targets list. if not, call the method executor.loader.graph.leaf_nodes and substitute its result for targets. call the executor.migration_plan method with targets as the argument, substitute the result for plan. use the result as an argument for the call to the self.stdout.write method. if run_syncdb and executor.loader.unmigrated_apps exist, join the executor.loader.unmigrated_apps into a string separated by string ', ' append it to the end of a string " Synchronize unmigrated apps: ", use it as an argument for the call to the self.style.MIGRATE_LABEL method, use the result of the previous method as an argument for the call to the self.stdout.write method. if target_app_labels_only is true, if set is empty return string '(none)' instead, append the previous to the string " Apply all migrations: ", use the previous string as the argument for the call to the method self.style.MIGRATE_LABEL, use the result as an argument for the call to the method self.stdout.write. if not, if element of targets in first row and second column is None, use the it as an argument for the call to the self.style.MIGRATE_LABEL method, use the result to cal the self.stdout.write method. if not, replace '%s' in string "%s, from %s" with second and first element of the first targets row, respectively, append it to the string " Target specific migration: ", use it as the argument for the call to the self.style.MIGRATE_LABEL method, call the self.stdout.write method with previous return value as an argument. if run_syncdb and executor.loader.unmigrated_apps is true, use the result as an argument for the call to the self.stdout.write. call the self.sync_apps method with connection and executor.loader.unmigrated_apps as arguments, substitute it for created_models. if not, create_models is an empty list. if plan is not true, call the method self.stdout.write with string " No migrations to apply." as an argument. call the MigrationAutodetector function with arguments, return value of the call to the method executor.loader.project_state, and return value of the call to the method ProjectState.from_apps with apps as an argument, assign it to the autodetector. call the method autodetector.changes with the graph set to executor.loader.graph as an argument, substitute it for the changes. if changes is true, call the method self.style.NOTICE with string " Your models have changes that are not yet reflected in a migration, and so won't be applied." as an argument, use the result as an argument for the call to the self.stdout.write method. call the method self.style.NOTICE with string " Run 'manage.py makemigrations' to make new migrations, and then re-run 'manage.py migrate' to apply them." as an argument, use the result as an argument for the call to the self.stdout.write method. if not, call the executor.migrate method with, targets, plan and fake set to the value under the 'fake' key of options dictionary, if action equals to string "apply_start", call the self.stdout.write method, with string " Applying %s..." with '%s' replaced with migration and ending set to '', as arguments. if fake is true, if not, call the self.stdout.write method, with string " Unapplying %s..." with '%s' replaced with migration and ending set to '', as arguments. if fake is true, if not, created_models is a set. pending_references is a empty dictionary. substitute model._meta for opts. evaluate next boolean expression, value of converter function with opts.db_table as argument is contained in tables, or opts.auto_created is True and return value of converter function with opts.auto_created._meta.db_table is contained in tables, invert the evaluated expression and return it. manifest is OrderDict class instance, created with tuple of two elements, app_name and list of elements of model_list for which model_installed function returned true, for every app_name and model_list in all_modules. unpack the manifest.values function return value and feed it to the itertools.chain function, create_models is a set containing chanied list. write the string " Creating tables...\n" to the standard output. for every app_name and model_list in return value of manifest.items function, for every model in model_list, call the self.stdout.write method with string " Processing %s.%s model\n" as argument, with all occurrences of '%s' replaced with, assign the result to the sql and references, respectively. add model to seen_models set. add model to created_models set. for every refto and refs in return value of references.items method. call the method extend with refs as argument, on the result call the pending_references.setdefault method with refto and empty list as arguments. if refto is contained in seen_models, call the self.stdout.write method with string " Creating table %s\n" as argument, with all occurrences of '%s' replaced with model._meta.db_table. for statements is sql, call the cursor.execute method with statement as argument. finally, perform, call the cursor.close method. write the string " Installing custom SQL...\n" to the standard output. for every app_name and mode_list in return value of manifest.items method, for model in model_list, if model is contained in created_models, if custom_sql is empty, call the self.stdout.write method with string " Installing custom SQL for %s.%s model\n" as argument, for every sql in custom_sql, call the cursor.execute method with sql as argument. if exception of class Exception, as e, is caught, call the self.stderr.write method with string " Failed to install custom SQL for %s.%s model: %s\n" as argument, call the traceback.print_exc method. if not, call the self.stderr.write method with string " No custom SQL for %s.%s model\n" as argument, write string " Installing indexes...\n" to the standard output. for every app_name and model_list in return value of manifest.items method, for every model in model_list, if model is contained in created_models, if index_sql is not empty, call the self.stderr.write method with string " Installing index for %s.%s model\n" as argument, for every sql in index_sql, call the method cursor.execute with sql as argument. if exception of the class Exception, as e, is caught, call the self.stderr.write method with string " Failed to install index for %s.%s model: %s\n" as argument, with all occurrences of '%s' replaced with app_name and model._meta.object_name and e, respectively. finally perform, call the cursor.close method. for every app_label in app_labels, substitute loader.graph for graph. if app_names is not empty, invalid_apps is an empty list. for every app_name is app_names, if app_name is not contained in loader.migrated_apps, if invalid_apps in not empty, string joined from invalided_apps list and separated with string ', '. if not, sort loader.migrated_apps, substitute it for app_names. for every app_name in app_names. shown is an empty set. for every node in return value of the graph.leaf_nodes method called with the app_name argument, for every plan_node in return value of the graph.forwards_plan method called with node as argument. if plan_node is not contained in shown and first element of plan_node equals to app_name, substitute second element of plan_node for title. if replaces filed of graph.nodes element at the plan_node index is true, if plan_node is contained in loader.applied_migrations, if not, add plan_node to the shown set. if shown is an empty set, help is a string "Runs this project as a FastCGI application. Requires flup.". call the method warnings.warn with 2 arguments: string "FastCGI support has been deprecated and will be removed in Django 1.9.", if AttributeError exception is caught, call the method re.compile with 2 arguments: raw string """^(?: (?P (?P\d{1,3}(?:\.\d{1,3}){3}) |""" """(?P\[[a-fA-F0-9:]+\]) | (?P[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*) ):)?(?P\d+)$""", re.X DEFAULT_PORT is a string "8000". help is a string "Starts a lightweight Web server for development.". substitute value under the 'use_ipv6' key of the options dictionary for self.use_ipv6. if self.use_ipv6 is true and socket.has_ipv6 is false, get the value under the 'addrport' key of the options dictionary, if it is false, substitute DEFAULT_PORT for self.port. if not, call the method re.match with 2 arguments: naiveip_re and value under the 'addrport' key of the options dictionary, substitute the result for m. if m is None, call the method self.port.isdigit, if it evaluates to false, if _ipv6 is true, substitute value under the 'use_reloader' key of the options dictionary for use_reloader. if use_reloader is true, call the method autoreload.main with 3 arguments: self.inner_run, None and options. if not, substitute value under the 'use_threading' key of the options dictionary for threading. get the value under the 'shutdown_message' key of the options dictionary, if it exists substitute it for shutdown_message, if not, shutdown_message is an empty string. if sys.platform equals string win32', substitute string 'CTRL-BREAK' for quit_command, if not substitute string 'CONTROL-C' for quit_command. write string "Performing system checks...\n\n" to self.stdout stream. if ImproperlyConfigured exception is caught, call the function datetime.now, on the result call the method strftime with an argument string '%B %d, %Y - %X', substitute the result for now. if six.PY2 is true, call the method now.decode with an argument string 'utf-8', substitute the result for now. if socket.error, renamed to e, exception is caught, ERRORS is a dictionary with 3 initial entries: string "You don't have permission to access that port." for errno.EACCES, get the value under the e.errno key of the ERRORS dictionary, substitute it for error_text. if KeyError exception is caught. convert e to a string, substitute it for error_text. replace '%s' in a string "Error: %s" with error_text, write it to self.stderr. if KeyboardInterrupt exception is caught, if shutdown_message is true, exit program with code integer 0. executor is an instance of the class MigrationExecutor created with an argument: value under the DEFAULT_DB_ALIAS key of the connections dictionary. call the method executor.migration_plan wiht return value of te method executor.loader.graph.leaf_nodes as argument, substitute it for plan. if plan is true, call the method self.style.NOTICE with an argument: string: "\nYou have unapplied migrations; your app may not work properly until they are applied.", write it to self.stdout. call the method self.style.NOTICE with an argument string "Run 'python manage.py migrate' to apply them.\n", write it to self.stdout. substitute Command for BaseRunserverCommand. help is a string "Runs a Python interactive interpreter. Tries to use IPython or bpython, if one of them is available.". shells is a list containing 2 elements: string 'ipython' and string 'bpython'. dest as a string 'no_startup' and help as a string 'When using plain Python, ignore the PYTHONSTARTUP environment variable and ~/.pythonrc.py script.'. call the method parser.add_argument with 5 arguments: string '-i', string '--interface', choices set to string self.shells, from IPython.Shell import IPShell into default namespace. shell is an instance of IPShell class, created with an argument argv as an empty list. call the method shell.mainloop. from IPython.frontend.terminal.ipapp import TerminalIPythonApp into default namespace. call the method instance of TerminalIPythonApp class, substitute the result for app. call the method app.initialize with an argument argv as an empty list. call the method app.start. from IPython import start_ipython into default namespace. call the method start_ipython with an argument argv as an empty list. call the function ip. if not, call the method bpython.embed. if shell is true substitute list with element shell for available_shells, if not substitute self.shells for available_shells. for every shell in available_shells, if value under 'plain' key of the options dictionary is true, call the method self.run_shell with an argument shell set to value under the 'interface' key of the options dictionary. imported_objects is an empty dictionary. if not, call the method rlcompleter.Completer with an argument imported_objects, use the complete field of the result as an argument for the call to the method readline.set_completer. call the method readline.parse_and_bind with an argument string "tab:complete". get the value under the 'no_startup' key of the options dictionary, if it evaluates to false, for every pythonrc in tuple containing 2 elements: return value of the function os.environ.get called with a string "PYTHONSTARTUP", and string '~/.pythonrc.py' as tuples second element. if pythonrc is true, open pythonrc, with the file handle renamed to handle perform the following, compile the handle.read in mode 'exec' source is read from file pythonrc, execute the compiled script with imported_objects variables. if NameError exception is caught, call the method code.interact with an argument local set to imported_objects. help is a string "Prints the CREATE TABLE SQL statements for the given app name(s).". help is a string "Prints the CREATE TABLE, custom SQL and CREATE INDEX SQL statements for the given model module name(s).". help is a string "Prints the DROP TABLE SQL statements for the given app name(s).". help is a string, "Prints the custom table modifying SQL statements for the given app name(s).". help is an string "Prints the DROP INDEX SQL statements for the given model module name(s).". help is a string, containing "Returns a list of the SQL statements required to return all tables in the database to the state they were in just after they were installed.". call the sql_flush function with self.style, connections under the key with the value of options dictionary under the 'database' key, help is a string "Prints the CREATE INDEX SQL statements for the given model module name(s).". help is a string "Prints the SQL statements for the named migration." get the values under the keys 'app_label' and 'migration_name' of the options dictionary, substitute the results for app_label and migration_name, respectively. if app_label is not contained in executor.loader.migrated_apps, call the executor.loader.get_migration_by_prefix with app_label and migration_name with arguments, substitute the result fr migration. if AmbiguityError exception is raised, with all '%s' strings replaced with migration_name and app_label, respectively, as an argument. if KeyError exception is raised, replace all the '%s' occurrences with migration_name and app_label, respectively. target is a list containing tuple with two elements app_label and migration.name. get executor.loader.graph.nodes list item at the index of the first element of targets list, get the value under the 'backwards' key of options dictionary, put previous two elements is a tuple, tuple is contained in a plan list. call method executor.collect_sql with plan as the argument, substitute the result for sql_statements. for every statements in sql_statements: help is a string 'Prints the SQL statements for resetting sequences for the given app name(s).'. help is a string "Squashes an existing set of migrations (from first until specified) into a single new one.". get the value under the 'interactive' key of the options dictionary, substitute it for self.interactive. get the values under the 'app_label' and 'migration_name' keys of the options dictionary, substitute them for app_label and migration_name, respectively. executor is an instance of MigrationExecutor, created with value under the DEFAULT_DB_ALIAS key of the connections dictionary. if app_label is not contained in executor.loader.migrated_apps, call the method executor.loader.get_migration_by_prefix with arguments app_label, migration_name, substitute the result for migration. if AmbiguityError exception is caught, where '%s' is replaced with migration_name and app_label. if KeyError exception is caught, where '%s' is replaced with migration_name and app_label. migrations_to_squash is a list created dynamically with elements: return value of the method executor.loader.get_migration called, write it to self.stdout. for every migration in migrations_to_squash, answer is None. while answer is false or answer is not contained in string "yn", perform the following, call the method six.moves.input with an argument string "Do you wish to proceed? [yN] ", substitute the result for answer. if answer is false, substitute 'n' for answer. if not, convert first element of answer to lowercase and substitute it for answer. if answer equals a string 'y', operations is an empty list. for every smigration in migrations_to_squash, call the method operations.extend with an argument smigration.operations. optimizer is an instance of MigrationOptimizer class. call the method optimizer.optimize with 2 arguments operations and migration.app_label, substitute the result for new_operations. write string " No optimizations possible." to self.stdout stream. if not, write it to self.stdout stream. replaces is an empty list. for every migration in migrations_to_squash, if migration.replaces is true, extend replaces list with migration.replaces, if not, subclass is a class named Migration, sub classed from migrations.Migration base class, with fields dependencies set to an empty list, dependencies set to new_operations and replaces set to replaces. call the function subclass with 2 arguments string "0001_squashed_%s", where '%s' is replaced with migration.name and app_label, substitute the result for new_migration. writer is an instance of a class MigrationWriter, created with an argument new_migration. call the method writer.as_string, write the result to file fh. self.style.MIGRATE_HEADING, write the result to self.stdout. write string " You should commit this migration but leave the old ones in place;" to self.stdout. write string " the new migration will be used for new installs. Once you are sure" to self.stdout. write string " all instances of the codebase have applied the migrations you squashed," to self.stdout. help is a tuple containing a string "Creates a Django app directory structure for the given app name in the current directory or optionally in the given directory.". missing_args_message is a string "You must provide an application name.". remove values under the keys 'name' and 'directory' of the options dictionary and substitute it for app_name and target, respectively. call the method self.validate_name with 2 arguments: app_name and string 'app'. call the function import_module with an argument app_name. in not, "as an app name. Please try another name.", where '%r' is replaced with app_name. call the method handle from the base class of Command class, with 4 arguments: string 'app', app_name, target and unpacked dictionary options. help is a tuple containing string "Creates a Django project directory structure for the given " "project name in the current directory or optionally in the given directory.". missing_args_message is a string "You must provide a project name.". remove the elements from the 'name' and 'dictionary' keys of the options dictionary, substitute them for project_name and target, respectively. call the method self.validate_name with arguments project_name and string "project". call the function import_module with an argument project_name. if not, chars is a string 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)'. call the function get_random_string with 2 arguments: integer 50 and chars, substitute it for value under the 'secret_key' of the options dictionary. call the handle method of the base class of the Command class, with 4 arguments: string 'project', project_name, target, help is a string "Deprecated - use 'migrate' instead.". call the method warnings.warn with 2 arguments: string "The syncdb command will be removed in Django 1.9" and RemovedInDjango19Warning. call the function call_command with 2 arguments: string migrate and unpacked dictionary options. call the method apps.get_model with 2 arguments: string 'auth' and string 'Permission'. if LookupError exception is caught. call the function get_user_model, substitute the result for UserModel. if return value of the method UserModel._default_manager.exists is false and value under the 'interactive' key of the options dictionary is true, msg is a tuple containing string "\nYou have installed Django's auth system, and don't have any superusers defined.\nWould you like to create one now? (yes/no): ". call the method input with an argument msg and store the result in confirm. endless loop, if confirm is not equal to string 'yes' or string 'no', query a string 'Please enter either "yes" or "no": ' and store the result in confirm. if confirm equals string 'yes', call the function call_command with 3 arguments: string "createsuperuser", interactive is boolean True, help is a string 'Discover and run tests in the specified modules or the current directory.'. option is a string '--testrunner='. for arg in argv list without the first two elements, if arg starts with options, call the run_from_argv function from the base class of the Command class with argv as a argument,. call the method parser.add_argument with 4 arguments: string 'args', metavar set to string 'test_label', nargs set to string '*', if test_runner_class has an 'option_list' attribute, raise an RuntimeError exception with an argument string "The method to extend accepted command-line arguments by the " "test management command has changed in Django 1.8. Please create an add_arguments class method to achieve this." if test_runner_class has an attribute 'add_arguments', if value under the 'verbosity' key of the options dictionary is greater than zero, call the method logging.getLogger with an argument string 'py.warnings', substitute the result for logger. call the method logging.StreamHandler, substitute the result for handler. call the method logger.addHandler with an argument handler. if value under the 'verbosity' key of the options dictionary is greater than zero, call the method logger.removeHandler with an argument handler. call the method get_runner with 2 arguments: settings and value under the 'testrunner' key of the options dictionary, substitute it for the TestRunner. if value under the 'liveserver' key of the options dictionary is not None, substitute value under the 'liveserver' key of the options dictionary for value under the 'DJANGO_LIVE_TEST_SERVER_ADDRESS' key of the os.environ dictionary. delete the value under the 'liveserver' key of the options dictionary. test_runner is an instance of TestRunner class, called with an argument unpacked dictionary options. call the method test_runner.run_tests with an argument test_labels, substitute it for failures. if failures is true, exit the program with failures converted to boolean as a message. help is a string 'Runs a development server with data from the given fixture(s).'. get the value under the key 'verbosity' of options dictionary, substitute it for verbosity. get the value under the key 'interactive' of options dictionary, substitute it for interactive. serialize set to boolean False, substitute the return value for db_name. call the method call_command with 3 arguments, string 'loaddata', unpacked list fixture_labels and unpacked dictionary containing 1 element: verbosity for 'verbosity'. replace '%r' from string '\nServer stopped.\nNote that the test database, %r, has not been deleted. You can explore it on your own.', with db_name, substitute it for shutdown_message. call the function call_command with 6 arguments, string 'runserver', addrport as the value under the 'addrport' key of options dictionary, concatenate CheckCommand.help to string 'Deprecated. Use "check" command instead. ', substitute it for help. call the method warnings.warn with string '"validate" has been deprecated in favor of "check".' and RemovedInDjango19Warning as arguments. raise an CommandError exception, with an arguent: string "App '%s' has migrations. Only the sqlmigrate and sqlflush commands can be used when an app has migrations.", where '%s' is replaced for app_config.label. if value under the 'ENGINE' key of the connection.settings_dict dictionary equals a string 'django.db.backends.dummy', raise an CommandError exception with an argument string "Django doesn't know which syntax to use for your SQL statements,\n" final_output is an empty list. add model to a set, substitute the result for known_models. pending_references is an empty dictionary. call the method final_output.extend with an argument output. for every refto and refs in return value of the method references.items, call the method pending_references.setdefault with 2 arguments: refto and an empty list, extend the result with refs. if refto is contained in known_models, use the result as an argument for the call to the method final_output.extend. add model to known_models set. call the method pending_references.keys, put the result into a set and substitute it for not_installed_models. if not_installed_models is true, alter_sql is an empty list. for every model in not_installed_models, and pending_references append sql to the string '-- ', put the results in a list, extend alter_sql with the result. if alter_sql, append string '-- The following references should be added but depend on non-existent tables:' to the final_output. extend final_output with alter_sql. if Exception exception is caught, cursor is None. if cursor is true, if not, table_names is an empty list. output is an empty list. to_delete is an empty set. references_to_delete is an empty dictionary. for every model in app_models, substitute model._meta for opts. for every f in opts.local_fields, if f.rel and f.rel.to are not contained in to_delete, call the method to_delete.add with an argument model. for every model in app_models, finally perform, if both cursor and close_connection are true, call the method cursor.close, if only_django, if not, output is an empty list. for every model in app_models, outut is an empty list. output is an empty list. call the function re.compile with an argument raw string "^((?:'[^']*'|[^'])*?)--.*$", substitute the result for comment_re. statements is an empty list. statement is an empty list. split content by newline character, for every line in result, call the method comment_re.sub with an arguments: raw string '\1' and line, strip the whitespaces surrounding the result, return it. if cleaned_line is false, if cleaned_line ends with ';' character, statement is an empty list. substitute model._meta for opts. app_dirs is an empty list. call the method apps.get_app_config with an argument model._met.app_label, substitute path field of the result for app_dir. call the function warnings.warn with 2 arguments: string "Custom SQL location '/models/sql' is deprecated, use '/sql' instead." and RemovedInDjango19Warning. output is an empty list. if opts.managed is true, for every f in opts.local_fields that has an 'post_create_sql' attribute, append f to a list, substitute the resulting list for post_sql_fields. for every f in post_sql_fields, call the method f.post_create_sql with arguments: style and model._meta.db_table, extend the output with the result. once split at the '.' value under the 'ENGINE' key of the connection.settings_dict dictionary, substitute last element of the result for backend_name. sql_files is an empty list. for every app_dir in app_dirs, for every sql_file in sql_files, call the method connection.ops.prepare_sql_script with 2 arguments: return value of the function fp.read, if verbosity is greater or equal to integer 2, replace '%s' in string "Running pre-migrate handlers for application %s" with app_config.label, print it to the standard output. if verbosity is greater or equal to integer 2, replace '%s' in string "Running post-migrate handlers for application %s" with app_config.label, print it to the standard output. call the function re.compile with 2 arguments: string '^([a-z]):' and re.I, substitute the result for _drive_re. call the function re.compile with 2 arguments: string '^([a-z])[:|]' and re.I, substitute the result for _url_drive_re. url_schemes is list of strings 'http', 'https' and 'ftp'. substitute app_or_project for self.app_or_project. call the method self.validate_name with 2 arguments name and app_or_project. if target is None, if OSError renamed to e, exception is caught, if e.errno equals errno.EEXIST, if not, if not, where '%s' is replaced with top_dir. call the function handle_extensions with 2 arguments: value under the 'extensions' key of the options dictionary, and ignored as an empty tuple, convert the result into a tuple and substitute it for extensions. extra_files is an empty list. for every file in value under the 'files' key of the options dictionary. split file by ',' character, apply on its every element a lambda function which takes an argument x, call the method self.stdout.write, with an argument string "Rendering %s template files with extensions: %s\n", where '%s' is replaced with app_or_project and extensions joined into a string, separated by a string ', '. call the method self.stdout.write, with an argument string "Rendering %s template files with filenames: %s\n", where '%s' is replaced with app_or_project and extra_files joined into a string, separated by a string ', '. append string '_name' to app_or_project, substitute it for base_name. append string '_template' to app_or_project, substitute it for base_subdir. append string '_directory' to app_or_project, substitute it for base_directory. if second last element of django.VERSION is not equal to a string 'final', docs_version is a string 'dev'. if not, convert first 2 elements of django.VERSION into a strings, join them together, separated by a '.', substitute the result for docs_version. context is an instance of a class Context, created with 2 arguments: dictionary created by apllying options to unpacked dictionary containing 3 entries: call the method self.handle_template with 2 arguments: value under the 'template' key of the options dictionary and base_subdir. for every root, dirs and files in subdirectory tree starting from the base dir template_dir, slice root starting from the prefix_length index to the end, substitute it for path_rest. call the method path_rest.replace with arguments base_name and name, substitute the result for relative_dir. if relative_dir is true, for dirname in dirs, if dirname starts with character '.' or dirname equals a string '__pycache__', remove dirname key from dirs. for every filename in files, join top_dir, relative_dir and return value of the function filename.replace called with 2 arguments: base_name and name, raise a CommandError exception with an argument: string "%s already exists, overlaying a project or app into an existing directory won't replace conflicting files", where '%s" is replaced with new_path. open old_path file in 'rb' mode, with file descriptor renamed to template_file, call the method template_file.read, substitute it for content. if filename ends with extensions or filename is contained in extra_files, call the method content.decode with an argument string 'utf-8', substitute it for content. template is an instance of Template class, created with an argument content. call the method template.render with an argument context, substitute it for content. call the method content.encode with an argument string 'utf-8', substitute it for content. open new_path file in 'wb' mode, with file descriptor renamed to new_file, write content to new_file file. replace '%s' in string "Creating %s\n" with new_path, write it to the self.stdout stream. call the function shutil.copymode with arguments old_path and new_path. call the method self.make_writeable with an argument new_path. if OSError exception is caught, replace '%s' in string "Notice: Couldn't set permission bits on %s. You're probably using an uncommon filesystem setup. No problem.", write string "Cleaning up temporary files.\n" to self.stdout stream. for every path_to_remove in self.paths_to_remove, if not, call the function shutil.rmtree with 2 arguments: path_to_remove and onerror set to rmtree_errorhandler. if template is None, if not, if template starts with a string 'file://', remove first 7 elements form template. call the method path.normpath with an argument expanded_template, substitute it for expanded_template. call the method self.is_url with an argument template, if it evaluates to true, call the method self.download with an argument template, substitute the result for absolute_path. if not, call the method self.extract with an argument absolute_path, return the result. if name is None, and app_or_project if app_or_project equals to string 'app', if not, it is replaced with 'a' and app_or_project. call the method re.search with 2 arguments: raw string '^[_a-zA-Z]\w*$' and name, if it evaluates to false, call the method re.search with 2 arguments: raw string '^[_a-zA-Z]' and name, if it evaluates to false, message is a string 'make sure the name begins with a letter or underscore'. if not, message is a string 'use only numbers, letters and underscores'. strip url of surrounding '/' characters, substitute it for tmp. split tmp at '/' character, substitute the last element of the result for filename. if url ends with '/' character, append '/' to tmp, substitute it for display_url. if not, substitute url for display_url. replace '%s' in string 'django_%s_template_' with self.app_or_project. call the function tempfile.mkdtemp with arguments: prefix set to prefix and suffix set to string '_download'. call the function cleanup_url with an argument url, assign the result to filename and display_url, respectively. replace '%s' in string "Downloading %s\n", with display_url, write it to self.stdout stream. call the function urlretrieve with arguments url and tempdir and filename joined into a file path, assign the result to the_path, and info, respectively. if IOErro, renamed to e, exception is caught, filename and e. split the_path at the '/' character, substitute last element of the result for used_name. get the value under the 'content-disposition' key of the info dictionary, substitute it for content_disposition. if content_disposition is true, call the method cgi.parse_header with an argument content_disposition, assign the result to _ and params, respectively. get the value under the 'filename' key of the params dictionary, if the key exists substitute it for guessed_filename, if not, substitute used_name for guessed_filename. if not, substitute used_name for guessed_filename. call the method self.splitext with an argument guessed_filename, substitute the second element of the result for ext. get the value under the 'content-type' key of the info dictionary, substitute it for content_type. if ext is false and content_type is true, call the method mimetypes.guess_extension with an argument content_type, substitute result for ext. if ext is true, append ext to guessed_filename. if used_name is not equal to guessed_filename, call the function shutil.move with arguments the_path and guessed_path. call the method posixpath.splitext with an argument the_path. convert base to lowercase, if it ends with string '.tar', take last four elements of base and append ext to it, substitute result for ext. substitute last four elements of base for base. replace '%s' in string 'django_%s_template_' with self.app_or_project, substitute it for prefix. call the method tempfile.mkdtemp with 2 arguments: prefix set to prefix, suffix set to string '_extract', substitute the result for tempdir. substitute '%s' in string "Extracting %s\n" with filename, write it to self.stdout stream. call the method archive.extract with arguments: filename and tempdir. if archive.ArchiveException or IOError, renamed to e, exception are caught, if character ':' is not contained in template, split template once at the first character ':', convert the first element to lowercase and substitute it for scheme. if scheme is countaine in self.url_schemes return boolean True, otherwise return False. if sys.platform starts with string 'java', call the method stat.S_IMODE with an argument st.st_mode, calculate binary OR with the result and stat.S_IWUSR, as operands, from subprocess import PIPE and Popen into default name space. p is a instance of Popen class, created with 6 arguments: args, shell set to boolean False, stdout set to PIPE, stderr set to PIPE, close_fds set to boolean True is os.name is not equal to 'nt', universal_newlines set to boolean True. if OSError, renamed to e, exception is caught, call the force_text function with 3 arguments: e.strerror, DEFAULT_LOCALE_ENCODING and strings_only set to boolean True. call the method six.reraise 3 with arguments: os_err_exc_type, return value of the function os_err_exc_type, called with string as an argument 'Error executing %s: %s', where '%s' is replaced by: first element of args and strerror, respective, and third element of the result of the function sys.exc_info. call the method p.communicate, assign the result to output and errors, respectively. return a tuple containing 3 entries: output, result of the function force_text, called with 3 arguments: errors, ext_list is an empty list, for every ext in extensions, delete all the whitespaces from ext, split it by ',' character, extend ext_list with the result. for every i and ext in enumerated iterable ext_list, if ext doesnt start with '.' character, prepend '.' to the i-th element of the ext_list. if striped x by '.' character is not contained in ignored, for every x in ext_list put x into a set, return the resulting set. if pathext is None, for ext in pathext, if cmd ends with ext, pathext is an list containing an empty string. for every ext in pathext, add ext to f, substitute the result for fext. from math import ceil into default name space. substitute object_list for self.object_list. convert per_page into an integer and substitute it for self.per_page. convert orphans into an integer and substitute it for self.orphans. substitute allow_empty_first_page for self.allow_empty_first_page. convert number into an integer and substitute it for number if number is lesser than integer 1, if not, call the method self.validate_number with an argument number, substitute it for number. if TypeError or AttributeError exceptions are caught, count is a property object with _get_count as a getter method. if not, num_pages is a property object with _get_num_pages as a getter method. page_range is a property object with _get_page_range as a getter method. substitute Paginator for QuerySetPaginator. substitute object_list for self.object_list. substitute number for self.number. substitute paginator for self.paginator. BUILTIN_SERIALIZERS is a dictionary containing 4 inital entries: "django.core.serializers.xml_serializer" for "xml", "django.core.serializers.python" for "python", "django.core.serializers.json" for "json", and "django.core.serializers.pyyaml" for "yaml". _serializers is an empty dictionary. substitute exception for self.exception. if serializers is None and _serializers is false, call the function _load_serializers. call the function importlib.import_module with an argument serializer_module, substitute it for module. ba_serializer is a instance of BadSerializer class, created with an argument exc. create a instance of a class BadSerializerModule from the object base class, with elements Deserializer set to bad_serializer and Serializer set to bad_serializer. if serializers is None, substitute module for the value under the format key of the _serializers dictionary. if not, substitute module for the value under the format key of the serializers dictionary. if _serializers is false, call the function _load_serializers. if format is not contained in _serializers, delete the _serializers dictionary entry at the format key. if _serializers is false, call the function _load_serializers. if format is not contained in _serializers, get the value under the format key of the _serializers dictionary, return the Serializer filed of the result. if _serializers is false, call the function _load_serializers. f _serializers is false, call the function _load_serializers. append k into a list for every k and v in return value of the six.iteritems function with an argument _serializers, f _serializers is false, call the function _load_serializers. if format is not contained in _serializers, get the value under the format key of the _serializers dictionary, return the Deserializer filed of the result. call the get_serializer function with an argument format, call the return value object and substitute it for s. call the s.serialize method with arguments queryset and unpacked dictionary options. call the get_deserializer function with an argument format, substitute the result for d. use the global variable _serializers. serializers is an empty dictionary. for every format in BUILTIN_SERIALIZERS, call the function register_serializer with 3 arguments: format, value under the format key of the BUILTIN_SERIALIZERS dictionary and serializers. call the function register_serializer with 3 arguments: format, value under the format key of the settings.SERIALIZATION_MODULES dictionary and serializers. substitute serializers for _serializers. remove the 'stream' key from the options dictionary and substitute it for self.stream, if the key doesnt exists call the six.String function and substitute the result for self.stream. remove the 'fields' key from the options dictionary and substitute it for self.selected_fields, if the key doesnt exists substitute None for self.selected_fields. remove the 'use_natural_keys' key from the options dictionary and substitute it for self.use_natural_keys, call the function warnings.warn with 2 arguments: string "``use_natural_keys`` is deprecated; use ``use_natural_foreign_keys`` instead." and RemovedInDjango19Warning. if the key doesnt exists substitute self.use_natural_keys for self.use_natural_foreign_keys. remove the 'use_natural_primary_keys' key from the options dictionary and substitute it for self.use_natural_primary_keys, for every obj in queryset, substitute obj._meta.concrete_model for concrete_model. if not, get 'getvalue' attribute of the self.stream object, if it exists and is callable, call the function six.StringIO with an argument stream_or_string, substitute the result for self.stream. if not, substitute m2m_data for self.m2m_data. call the models.Model.save_base method with arguments self.object, using as using and raw set to boolean True. if self.m2m.data and save_m2m are true, for every accessor_name and object_list is return value of the method self.m2m_data.items. set accessor_name of the self.object to object_list. if obj.pk is None, and Model has an 'natural_key' attribute, and Model._default_manager has and 'get_by_natural_key', call the method obj.natural_key, substitute the result for natural_key. call the method Model._default_manager.db_manager with an argument db, on the result call the get_by_natural_key with, an unpacked list natural_key as argument, substitute the pk filed of the resulting object for obj.pk. if Model.DoesNotExist exception is caught, call the method json.__version__.split with an argument '.', if the result is respectively greater than list containing strings '2', '1' and '3', remove the entry under the 'stream' key of the self.json_kwargs dictionary. remove the entry under the 'fields' key of the self.json_kwargs dictionary. substitute a tuple with 2 elements: characters ',' and ': ' for value under the 'separators' key of the self.json_kwargs dictionary. get the value under the 'indent' key of the self.options dictionary, substitute it for indent. if indent is false, if indent is true, call the getvalue method from the base class of the class PythonSerializer, return the result. call the stream_or_string.read function, substitute the result for stream_or_string. call the method stream_or_string.decode with an argument string 'utf-8', substitute the result for stream_or_string. call the function json.loads with an argument stream_or_string, substitute the result for objects. for every obj in PythonDeserializer called with arguments objects and unpacked dictionary options, if GeneratorExit exception is caught, if Exception, renamed to e, exception is caught, call the six.reraise function with 3 arguments: DeserializationError, DeserializationError called with an argument e, call the method o.isoformat substitute the result for r. if o.microsecond is true, remove 3 elements from r starting at the index 23. if r ends with string '+00:00', cut the last 6 elemetns from r, append character 'Z' to it, substitute the result for r. call the function is_aware with an argument o, if it evaluates to true, call the method o.isoformat substitute the result for r. if o.microsecond is true, substitute first 12 elements of r for r. if not, substitute DjangoJSONEncoder for DateTimeAwareJSONEncoder. and self._current for 'fields'. if self.use_natural_primary_keys is false or obj doesnt have a 'natural_key' attribute. if not, if related is true, if not, if not, if not, remove the value under the 'using' key from the options dictionary, assign it to the db, if the entry doesnt exists, substitute DEFAULT_DB_ALIAS for db. remove the value under the 'ignorenonexistent' key from the options dictionary, assign it to the ignore, if the entry doesnt exists, substitute boolean False for ignore. for every d in object_list, call the function _get_model with an argument value under the 'model' key of the d dictionary, substitute the result for Model. if base.DeserializationError exception is caught, if ignore is true, if not, if 'pk' is contained in d, call the method Model._meta.pk.to_python with one argument: value under the 'pk' key of dictionary d, or None if previous doesnt exists, substitute the result for the value under the Model._meta.pk.attname key of data dictionary. m2m_data is an empty dictionary. call the method Model._meta.get_all_field_names, substitute the result for model_fields. for every field_name and field_value in return value of the function six.iteritems called with value under the 'fields' key of dictionary d, if ignore is true and field_name is not contained in model_fields, with unpacked list value as an argument, return the pk field of the result. if not, smart_text function, return the result. if not, if field_value is not None, if not, if not, unpacked list field_value as an argument, substitute the result for value of under the field.attname key of the data dictionary. if not, if not, call the method apps.get_model with an argument model_identifier. if LookupError or TypeError exceptions are caught, from yaml import CSafeLoader as SafeLoader into default name space. yaml import CSafeDumper as SafeDumper into default name space. from yaml import SafeLoader, SafeDumper into default name space. call the method self.represent_scalar with 2 arguments: string 'tag:yaml.org,2002:str' and data converted into a string, return the result. call the method DjangoSafeDumper.add_representer with arguments decimal.Decimal and DjangoSafeDumper.represent_decimal. if not, call the getvalue method of the base class of the PythonSerializer class, return the result. call the method stream_or_string.decode with string 'utf-8' as argument, substitute the result for stream_or_string. call the function StringIO with an argument stream_or_string, substitute the result for stream. if not, substitute stream_or_string for stream. for every obj in return value of the PythonDeserializer created with 2 arguments: return value of the function yaml.load, if exception GeneratorExit is caught, if Exception, renamed to e, exception is caught, call the function six.reraise with 3 arguments: DeserializationError, return value of the DeserializationError called with an argument e, from xml.dom import pulldom into default name space. from xml.sax import handler into default name space. from xml.sax.expatreader import ExpatParser as _ExpatParser into default name space. options dictionary, if the key doesnt exists use settings.DEFAULT_CHARSET instead. call the self.xml.startDocument method. call the method self.xml.startElement with 2 arguments, string "django-objects" and a dictionary containing 1 element: "1.0" for "version". call the method self.xml.endElement with an argument string "django-objects". call the self.xml.endDocument method. if '_meta' is not an attribute of obj, raise an base.SerializationError exception with argument string "Non-model object (%s) encountered during serialization", attrs is a dictionary containing 1 entry: return value of the smart_text function with argument obj._meta for 'model'. if self.use_natural_primary_keys is false and obj doesnt have 'natural_key' argument. substitute return value of the method obj._get_pk_val for obj_pk. if obj_pk is not None, substitute the return value of the smart_text function with an argument obj_pk for the value under the 'pk' key of the attrs dictionary. call the method self.xml.startElement with arguments string 'object' and attrs. call the method self.xml.endElement with an argument string 'object'. if not, if related_att is not None, call the method related.natural_key, substitute the result for related. for every key_value in related, call the method self.xml.startElement with arguments string 'natural' and an empty dictionary. call the function smart_text with argument key_value, use the result as an argument for the call to the self.xml.characters method. call the method self.xml.endElement with an argument string 'natural' if not, call the function smart_text with argument related_att, use the result as an argument for the call to the self.xml.characters method. if not, call the method self.xml.startElement with argument string 'object' and an empty dictionary. for every key_value in natural, call the method self.xml.startElement with argument string 'natural' and an empty dictionary. call the function smart_text with argument key_value, use the result as an argument for the call to the self.xml.characters method. call the method self.xml.startElement with an argument string 'natural'. call the method self.xml.startElement with an argument string 'object'. if not, call the self.xml.addQuickElement method with 2 arguments: string 'object' and attr dictionary containing 1 entry: call the function handle_m2m with an argument relobj. substitute the result for self.event_stream. remove the 'using' key from the options dictionary, substitute the return value for self.db, if the key doesnt exists substitute DEFAULT_DB_ALIAS for self.db. remove the 'ignorenonexistent' key from the options dictionary, substitute the return value for self.db, for every event and node in self.event_stream, if event equals a string "START_ELEMENT" and node.nodeName equals a string 'object', call the method self.event_stream.expandNode with an argument node. call the method self._get_model_from_node with arguments node and string 'model'. call the method node.hasAttribute with string 'pk' as an argument, if it evaluates to true, call the method node.getAttribute with an argument string 'pk', use the result as the argument for the call to the method, Model._meta.pk.to_python with, substitute the result for value under the Model._meta.pk.attname key of the data dictionary. m2m_data is an empty dictionary. call the method Model._meta.get_all_field_names, substitute the result for model_fields. call the method field_node.getAttribute with an argument string 'name', substitute the result for field_name. if field_name is false, if self.ignore is true and field_name is not contained in model_fields, field.attname of the data dictionary. if not, call the method field_node.getElementsByTagName with an argument string 'None', if it evaluates to true, if not, call the method base.DeserializedObject with arguments obj and m2m_data, return the result. call the method node.getElementsByTagName with an argument string 'None', if it evaluates to true, if not, call the method node.getElementsByTagName with the argument string 'natural', substitute the result for keys. if keys is true, call the function getInnerText with argument k, on the result call the method strip, for every k in keys, append the results to field_value list. substitute obj_pk.pk for obj_pk. if not, call the function getInnerText with an argument node, call the strip method on the result, substitute the result for field_value. if not, call the function getInnerText with an argument node, call the strip method on the result, substitute the result for field_value. call the method n.getElementsByTagName with string 'natural' as argument, substitute result for keys. if keys is true, call the function getInnerText with argument k, on the result call the method strip, for every k in keys, append the results to field_value list. with unpacked list field_value as an argument, substitute the field pk of the result for obj_pk. if not, if not, called with n.getAttribute('pk') method. call the m2m_convert function with an argument c, for every c in return value of the method node.getElementsByTagName, call the method node.getAttribute with an argument attr, substitute the result for model_identifier. if model_identifier is false, raise an base.DeserializationError exception with an argument string "<%s> node is missing the required '%s' attribute", call the method apps.get_model with an argument model_identifier, return the result. if LookupError or TypeError exceptions are caught, inner_text is an empty list. for every child in node.childNodes, if child.nodeType equals to child.TEXT_NODE or child.nodeType equals to child.CDATA_SECTION_NODE, otherwise if child.nodeType equals to child.ELEMENT_NODE, call the function getInnerText with an argument child, use the result as an argument for the call to the method inner_text.extend. if not, call the method self.setFeature with 2 arguments: handler.feature_external_ges and boolean False. call the method self.setFeature with 2 arguments: handler.feature_external_pes and boolean False. call the method _ExpatParser.reset with an argumen sefl. substitute sysid for self.sysid. substitute pubid for self.pubid. tpl is an string "DTDForbidden(name='{}', system_id={!r}, public_id={!r})". substitute base for self.base. substitute sysid for self.sysid. substitute pubid for self.pubid. substitute notation_name for self.notation_name. tpl is an string "EntitiesForbidden(name='{}', system_id={!r}, public_id={!r})". substitute base for self.base. substitute sysid for self.sysid. substitute pubid for self.pubid. tpl is an string "ExternalReferenceForbidden(system_id='{}', public_id={})". from wsgiref import simple_server into default name space. from wsgiref.util import FileWrapper __all__ is a tuple containing 2 initial elements: strigs 'WSGIServer' and 'WSGIRequestHandler'. if app_path is None, call the import_string with app_path as an argument, return the result. msg is a tuple containing one initial entry: a string "WSGI application '%(app_path)s' could not be loaded; Error importing module: '%(exception)s'", where '%(app_path)s' is replaced by app_path and '%(exception)s' is replaced by e. call the function six.reraise with 3 arguments: ImproperlyConfigured, ImproperlyConfigured(msg) and third element of return value of the function sys.exc_info. request_queue_size is integer 10. substitute socket.AF_INET6 for self.address_family. call the server_bind method from the base class of the WSGIServer class. msg is a string "[%s] %s\n", where '%s' are replaced with return value of the method self.log_date_time_string and formated args. call the self.style.HTTP_SUCCESS with an argument msg, substitute it for msg. call the self.style.HTTP_INFO with an argument msg, substitute it for msg. call the self.style.HTTP_NOT_MODIFIED with an argument msg, substitute it for msg. call the self.style.HTTP_REDIRECT with an argument msg, substitute it for msg. call the self.style.HTTP_NOT_FOUND with an argument msg, substitute it for msg. call the self.style.HTTP_BAD_REQUEST with an argument msg, substitute it for msg. if not, call the self.style.HTTP_SERVER_ERROR with an argument msg, substitute it for msg. call the sys.stderr.write function with an argument msg. server_address is a tuple containing 2 initial elements: addr and port. if threading is true, call the function type with 3 arguments: string 'WSGIServer', tuple containing 2 elements: socketserver.ThreadingMixIn and WSGIServer, and an empty dictionary, substitute the result for httpd_cls. if not, substitute WSGIServer for httpd_cls. call the httpd_cls function with 4 arguments: server_address, WSGIRequestHandler and ipv6 set to ipv6, substitute the result for httpd. if threading is true, call the method httpd.set_app with an argument wsgi_handler. call the method httpd.serve_forever. __version__ is a string "0.1". __all__ is a list containing a string "runfastcgi". FASTCGI_OPTIONS is a dictionary containing 16 initial entries: 'fcgi' for 'protocol', None for 'host', None for 'port', print FASTCGI_HELP to the standard output. call the method FASTCGI_OPTIONS.copy, substitute the result for options. for every x in argset, if character '=' is contained in x, call the x.split method with arguments: character '=' and integer 1, store the result in k and v, respectively. if not, substitute v for value under the k converted to lower case key of options dictionary. if string 'help' is contained in options, call the method sys.stderr.write with an argument string "ERROR: %s\n", where '%s' is replaced by e. call the method sys.stderr.write with an argument string " Unable to load the flup package. In order to run django\n". call the method sys.stderr.write with an argument string " as a FastCGI application, you will need to get flup from\n". call the method sys.stderr.write with an argument string " http://www.saddi.com/software/flup/ If you've already\n". call the method sys.stderr.write with an argument string " installed flup, then make sure you have it in your PYTHONPATH.\n". append value under the 'protocol' key of the options dictionary to the string 'server.', substitute it for flup_module. if value under the 'method' key of the options dictionary equals to string 'perfork' or 'fork', wsgi_opts is a dictionary with 4 initial entries: value under the key 'maxspare' of options dictionary converted to an integer, for 'maxSpare', value under the key 'minspare' of options dictionary converted to an integer for 'minSpare', value under the key 'maxchildren' of options dictionary converted to an integer, for 'maxChildren', and value under the key 'maxrequests' of options dictionary converted to an integer, for 'maxRequests'. append string '_fork' to flup_module. wsgi_opts is a dictionary with 4 initial entries: value under the key 'maxspare' of options dictionary converted to an integer, for 'maxSpare', value under the key 'minspare' of options dictionary converted to an integer for 'minSpare', and value under the key 'maxchildren' of options dictionary converted to an integer, for 'maxThreads'. if not, call the function fastcgi_help with an argument string "ERROR: Implementation must be one of prefork or thread.", return the result. if value under the 'debug' key of options dictionary is not None, substitute it for value under the 'debug' key of wsgi_opts dictionary. call the function importlib.import_module with 2 arguments: flup_module converted to string and appended to '.' character, and string 'flup', substitute the result for module. substitute module.WSGIServer for WSGIServer. if Exception exception is caught, append flup_module to string "Can't import flup.", print it to the standard output. if value under the 'socket' key of the options dictionary is false and values under the 'host' and 'port' keys of the options dictionary are true, set the value under the 'bindAddress' key of the wsgi_opts dictionary to a tuple containing 2 elements: value under the 'host' key, substitute the value under the 'socket' key of options dictionary for value under the 'bindAddress' key of wsgi_opts dictionary. set value under the 'bindAddress' key of wsgi_opts to None. if not, call the fastcgi_help function with an argument string "Invalid combination of host, port, socket.", return it. if value under the 'daemonize' of options dictionary is None, if the value under the 'bindAddress' key of the wsgi_opts dictionary is not None, set daemonize to boolean True, if not, set it to boolean False. if not, if not, call the fastcgi_help function with an argument string "ERROR: Invalid option for daemonize parameter.", return it. daemon_kwargs is an empty dictionary. if value under the 'outlog' key of options dictionary is true, substitute the value under the 'outlog' key of options dictionary for value under the 'out_log' key of daemon_kwargs dictionary. if value under the 'errlog' key of options dictionary is true, substitute the value under the 'errlog' key of options dictionary for value under the 'err_log' key of daemon_kwargs dictionary. if value under the 'umask' key of options dictionary is true, convert the value under the 'umask' key of options dictionary into an integer of base 8, substitute it for value under the 'umask' key of daemon_kwargs dictionary. if daemonize is true, call the function become_daemon with 2 arguments: our_home_dir set to the value under the 'workdir' key of options dictionary and, unpacked dictionary daemon_kwargs. if value under the 'pidfile' of options dictionary exists, open the file whose name is stored in the value under the 'pidfile' key of options dictionary and mode 'w', with the file descriptor as fp, create the object WSGIServer with 2 arguments: get_internal_wsgi_application return value and unpacked dictionary wsgi_opts, call the method run on it. if __name__ equals a string '__main__'. call the function runfastcgi with an argument all the elements, except the first from the sys.argv list. request_started is a instance of a Signal class. request_finished is a instance of a Signal class. call the method base64.urlsafe_b64encode with an argument s, on the result call the strip function with '=' as the argument, return the result. call the method base64.urlsafe_b64decode with sum of s and pad as argument. create the Singer class with 2 arguments: key appended to string 'django.http.cookies' and salt set to salt, return it. call the json.dumps function with 2 arguments: obj and separators set to tuple containing ',' and ':' characters, if compress is true, if is_compressed is true, prefix the base64d with a '.' character. instantiate the TimestampSigner object with arguments key and salt set to salt, call its method sign with an argument base64, return it. instantiate TimestampSigner object with arguments key and salt set to salt, call its method unsign with arguments: if first element of base64d equals to a '.' character, substitute first element of base64d for base64d. if decompress is true, call the function force_str with an argument sep, substitute the result for self.sep. call the function signed_value with an argument value, substitute the result for signed_value. if self.sep is not contained in signed_value, call the signed_value.rsplit method with arguments self.sep and integer 1, substitute the result for value and sig, respectively. call the function constant_time_compare with 2 arguments: sig and return value of the self.signature method with an argument value, if it evaluates to true, call the method baseconv.base62.encode with result of the time.time function converted to an integer, as an argument, return the result. call the baseconv.base62.decode method with an argument timestamp, substitute the result for timestamp. if max_age is not None, subtract timestamp from the return value of the function time.time, substitute the result for age. if age is greater than max_age, raise an SignatureExpired exception with an argument string 'Signature age %s > %s seconds', where '%s' is replaced by age and max_age, respectively. call the function local, substitute the result for _prefixes. call the function local, substitute the result _urlconf. substitute url_name for self.url_name. substitute app_name for self.app_name. if namespaces is true, append x to self.namespaces list for every x in namespaces, only if x is true. if not, if not, if url_name exists substitute it for view_path, if not substitute .self._func_path for view_path. method lru_cache.lru_cache with an argument maxsize set to None, as a decorator, if lookup_view is a callable object, call the function get_mod_func with an argument lookup_view, store the result in mod_name and func_name, respectively. if func_name is false, if can_fail is true, if not, call the function import_module with an argument mod_name. if can_fail is true, if not, call the function get_mod_func with an argument mod_name, store the result in parentmod and submod, respectively. if submod is true and return value of the function module_has_submodule called with 2 arguments: result of the function: where string '%s' is replaced by lookup_view and mod_name, respectively. if not, if not, get func_name attribute from the mod object, substitute it for view_func. if AttributeError exception is caught. if can fail is true, if not, where string '%s' is replaced by lookup_view and mod_name, respectively. if not, if view_function is not a callable function, method lru_cache.lru_cache with an argument maxsize set to None, as a decorator, if urlconf is None, return an instance of a class RegexURLResolver created with arguments: raw string '^/' and urlconf. method lru_cache.lru_cache with an argument maxsize set to None, as a decorator, ns_resolver is class instance of a class RegexURLResolver, created with 2 arguments: ns_pattern and resolver.url_patterns. return an instance of a class RegexURLResolver created with arguments: raw string '^/' and a list containing an element ns_resolver. call the method callback.rindex with an argument character '.', substitute the result for dot. return callback split into two lists at the dot index, without the element at the dot index. property decorator, call the function get_language, substitute the result for language_code. if not, call the function force_text with arguments self and _regex, substitute the result for regex. call the function re.compile with arguments regex and re.UNICODE, substitute the result for compiled_regex. if re.error, renamed to e, is caught, where '%s' is replace by regex and return value of the function six.text_type with an argument e. substitute the compiled_regex for value under the language_code key of the self._regex_dict dictionary. if callback is an callable object, if not, if default_args exists substitute it for self.default_args, if not, self.default_args is an empty dictionary. if prefix is false, and self doesnt have '_callback_str' attribute, if match is true, call the method match.groupdict, substitute the result for kwargs. if not, call the method kwargs.update with an argument self.default_args. property decorator, substitute urlconf_name for self.urlconf_name. if default_kwargs exists, substitute it for self.default_kwargs, otherwise self.default_kwargs is an empty dictionary. substitute namespace for self.namespace. substitute app_name for self.app_name. replace '%s' in string '<%s list>' with __class__.__name__ field of first element of self.urlconf_name, substitute it for urlconf_repr. if not, create a printable representation of self.urlconf_name object, substitute it for urlconf_repr. lookups is an instance of the MultiValueDict class. namespaces is an empty dictionary. apps is an empty dictionary. call the function get_language, substitute the result for language_code. for every pattern in reversed list self.url_patterns, if pattern has an attribute '_callback_str', call the method self._callback_strs.add with an argument pattern._callback_str. substitute pattern._callback for callback. if callback doesnt have '__name__' attribute, join callback.__module__, character "." and callback.__class__.__name__ together, substitute the result for lookup_str. if not, join together callback.__module__, character "." and callback.__name__, substitute the result for lookup_str. call the method self._callback_strs.add with an argument lookup_str. substitute pattern.regex.pattern for p_pattern. if p_pattern starts with a string '^', remove the first element from p_pattern. if pattern.namespace is true, substitute the tuple containing 2 elements p_pattern and pattern for value under the pattern.namespace key of the namespaces dictionary. if pattern.app_name is true, if not, substitute pattern.regex.pattern for parent_pat. for every name in pattern.reverse_dict, for every matches, pat and defaults in return value of the method pattern.reverse_dict.getlist called with an argument name, call the method normalize with sum of parent_pat and pat as an argument, substitute the result for new_matches. call the method lookups.appendlist with 2 arguments: name and a tuple containing 3 elements: new_matches, sum of p_pattern and pat, and dictionary created by applying defaults mapping on the pattern.default_kwargs dictionary. for every namespace and tuple containing: prefix and sub_pattern, in return value of the method pattern.namespace_dict.items, substitute tuple containing 2 elements: sum of p_pattern and prefix, and sub_pattern for value under the namespace key of the namespace dictionary. for every app_name and namespace_list in pattern.app_dict.items method return value, call the method apps.setdefault with 2 arguments: app_name and an empty list, extend the resulting list with namespaces_list. call the method self._callback_strs.update with an argument pattern._callback_strs. if not, and pattern.default_args. if pattern.name is not None, and pattern.default_args. substitute lookups for the value under language_code key of the self._reverse_dict dictionary. substitute namespaces for the value under language_code key of the self._namespace_dict dictionary. substitute apps for the value under language_code key of the self._app_dict dictionary. property decorator, call the function get_language, substitute the result for language_code. if language_code is not contained in self._reverse_dict property decorator, call the method get_language, substitute the result for language_code. if language_code is not contained in self._namespace_dict, property decorator, call the method get_language, substitute the result for language_code. if language_code is not containsed in self._app_dict tried is an empty list. if match is true, for every pattern in self.url_patterns, call the method pattern.resolve with an argument new_path, substitute the result for sub_match. if Resolver404, renamed to e, exception is caught, call the get method with an argument string 'tried' on the first element of the e.args, substitute the result for sub_tried. if sub_tried is not None, call the method tried.extend with an argument: t added to a list containing element pattern, for every t in sub_tried. if not, if not, if sub_match is true, sub_match_dict is a dictionary created from self.default_kwargs dictionary using mapping function match.groupdict. call the method sub_match_dict.update with an argument sub_match.kwargs. return an instance of a class ResolverMatch created with 6 arguments: sub_match.func, sub_match.args, sub_match_dict, property decorator, if AttributeError exception is caught. property decorator, get attribute "urlpatterns" form the self.urlconf_module, substitute it for patterns, if the attribute doesnt exist, call the function iter with an argument patterns. msg is a string ""The included urlconf '{name}' does not appear to have any patterns in it. replace '%s' in the string 'handler%s' with view_type, use it as an name of the attribute to get from the self.urlconf_module, substitute it for callback, if the attribute doesnt exists, callback is None. if not callback, replace '%s' in the string 'handler%s' with view_type, use it as an name of the attribute to get from the urls, substitute it for callback. call the function get_callable with an argument callback, return the result and an empty dictionary. text_kwargs is a dictionary created from the result of the function force_text with an argument v, mapped through function k, for every k and v in return value of the kwargs.items. substitute lookup_view for original_lookup, if lookup_view is contained in self._callback_strs, call the function get_callable with arguments lookup_view and boolean True, substitute the result for lookup_view. if not, if original_lookup and lookup_view are not callable objects, call the function warnings.warn with 3 arguments: string 'Reversing by dotted path is deprecated (%s).', with '%s' replaced with original_lookup, RemovedInDjango20Warning and stacklevel set to integer 3. call the method self.reverse_dict.getlist with an argument lookup_view, substitute the result for possibilities. call the function urlquote with an argument _prefix, use the result as an argument for the call to the normalize function, substitute the fitst element of the result for prefix_norm and prefix_args, respectively. for every possibility, pattern and defaults in possibilities, for every result and params in possibility, create a list of tuples out of 2 lists: appended params list to prefix_args and text_args, covert the result into a dictionary, substitute it for candidate_subs. if not, if the union of the kwargs and defaults dictionary keys converted into sets is not the same as the union of the defaults and prefix for every k and v in return value of the function defaults.items, if matches is false, substitute text_kwargs for candidate_subs. replace all the occurrences of the '%' string for '%%', append result to the previous result, substitute it for candidate_pat. call the function re.search with 3 arguments: string '^%s%s', with '%s' replaced for prefix_norm and pattern, respectively, candidate_pat formated with candidate_subs and re.UNICODE. candidate_subs is dictionary created from elements in return value of the function urlquote called with argument v, mapped with a function k, for every k and v in return value of the method candidate_subs.items. format candidate_pat with candidate_subs, return the result. get the attribute '__module__' from the getattr, if it exists substitute it for m, if not, m is None. get the attribute '__name__' from the getattr, if it exists substitute it for m, if not, m is None. if m and n are not None, join m and n into a string, separated by '.', substitute the result for lookup_view_s. if not, substitute lookup_view for lookup_view_s. append pattern into a list patterns, for every possibility, pattern and defaults in possibilities. raise an NoReverseMatch exception with an argument string "Reverse for '%s' with arguments '%s' and keyword ", call the __init__ method of the base class of the class LocaleRegexURLResolver, with arguments: None, urlconf_name, default_kwargs, app_name and namespace. property decorator, call the function get_language, substitute the result for language_code. call the function re.compile with 2 arguments, string '^%s/', where '%s' is replaced with language_code and re.UNICODE, substitute the result for regex_compiled. substitute the regex_compiled for value under the language_code key of the self._regex_dict dictionary. if urlconf is None, call the function get_urlconf with an argument urlconf. prefix set to None, current_app set to None. if urlconf is None, call the function get_urlconf with an argument urlconf. call the function get_resolver with an argument urlconf, substitute the result for resolver. if prefix is None, call the function get_script_prefix, substitute the result for prefix. substitute viewname for view. if not, call the method viewname.split, with an argument ':', substitute the result for parts. call the method parts.reverse. substitute first element of parts for view. resolved_path is an empty list. ns_pattern is an empty string. get the value under the ns key of the resolver.app_dict dictionary, substitute it for app_list. if current_app and is true and current_app is contained in app_list, substitute current_app for ns. substitute first element of app_list for ns. if KeyError exception is caught, substitute the value under the ns key of the resolver.namespace_dict dictionary for extra and resolver, respectively. add ns_pattern and extra, substitute the result for ns_pattern. if resolved_path is true, respectively replace '%s' with key and elements of the resolved_path joined into a string, separated by ':'. if not, if ns_pattern is true, call the function get_ns_resolver with arguments ns_pattern and resolver, substitute the result for resolver. use the result as an argument for the call to the function iri_to_uri, return the result. call the function lazy with arguments reverse and str, substitute the results for reverse_lazy. call the function get_callable.cache_clear. call the function get_resolver.cache_clear. call the function get_ns_resolver.cache_clear. if prefix doesnt end with character '/', append '/' to prefix. if AttributeError exception is caught, if urlconf_name is true, if not, if Resolver404 exception is caught, EMPTY_VALUES is a tuple containing 5 initial elements: None, empty string, empty list, empty tuple and an empty dictionary. decorator deconstructible, regex is an empty string. code is a string 'invalid' flags is a integer 0. inverse_match set to None and flags set to None. if regex is not None, substitute regex for self.regex. if code is not None, substitute code for self.code. if inverse_match is not None, substitute inverse_match for self.inverse_match. if flags is not None, substitute flags for self.flags. decorator deconstructible, call the re.compile function with 2 arguments: raw string "^(?:[a-z0-9\.\-]*)://(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+", schemes is a list containing 4 initial elements: 'http', 'https', 'ftp' and 'ftps'. if schemes is not None, substitute schemes for self.schemes. if scheme is not contained in self.schemes, if ValidationError, renamed to e, is caught, call the function urlsplit with an argument value, assign the result to scheme, netloc, path, query and fragment, respectively. call the method netloc.encode with an argument string 'idna', on the return value call the decode method with string 'ascii' as argument, substitute the result for netloc. if UnicodeError exception is caught, call the function urlunsplit with a tuple containing 5 elements: scheme, netloc, path, query and fragment, as an argument, substitute the result for url. call the __call__ method from the base class of the URLValidator class, with an argument url. if not, if not, and code set to string 'invalid'. decorator deconstructible, call a function _ with a string 'Enter a valid value.' as an argument, substitute the result for message. code is a string 'invalid'. call the re.compile function with 2 arguments: raw string "(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*$", "|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"$)" and re.IGNORECASE, substitute the result for user_regex. call the re.compile function with 2 arguments: raw string '(?:[A-Z0-9](?:[A-Z0-9-]{0,247}[A-Z0-9])?\.)+(?:[A-Z]{2,6}|[A-Z0-9-]{2,}(?{1}', attrs and contents, substitute the result for contents. if not, call the function conditional_escape with an argument contents, substitute the result for contents. if extra_classes has an attribute 'split', split extra_classes into words, by whitespaces, substitute the result for extra_classes. if extra_classes is not empty put its elements into a set, substitute it for extra_classes, if not extra_classes is an empty set. add self.form.error_css_class to extra_classes set. add self.form.required_css_class to extra_classes set. property decorator, property decorator, substitute self.form.auto_id for auto_id. if auto_id is true and '%s' is contained in result of the call to the function smart_text with an argument auto_id, call the function smart_text with an argument auto_id, format the result with self.html_name, return it. property decorator, get the value under the 'id' key of the widget.attrs dictionary, if the key exists substitute it for id_, if not, substitute self.auto_id for id_. call the method widget.id_for_label with an argument id_, return the result. __all__ is a tuple containing strings 'BaseFormSet', 'formset_factory' and 'all_valid'. TOTAL_FORM_COUNT is a string 'TOTAL_FORMS'. INITIAL_FORM_COUNT is a string 'INITIAL_FORMS'. MIN_NUM_FORM_COUNT is a string 'MIN_NUM_FORMS'. MAX_NUM_FORM_COUNT is a string 'MAX_NUM_FORMS'. ORDERING_FIELD_NAME is a string 'ORDER'. DELETION_FIELD_NAME is a string 'DELETE'. DEFAULT_MIN_NUM is an integer 0. DEFAULT_MAX_NUM is an integer 1000. value under the TOTAL_FORM_COUNT of the self.base_fields dictionary is an instance of IntegerField class, created with an argument widget set to HiddenInput. value under the INITIAL_FORM_COUNT of the self.base_fields dictionary is an instance of IntegerField class, created with an argument widget set to HiddenInput. value under the MIN_NUM_FORM_COUNT of the self.base_fields dictionary is an instance of IntegerField class, created with 2 arguments: required as boolean False and widget set to HiddenInput. value under the MAX_NUM_FORM_COUNT of the self.base_fields dictionary is an instance of IntegerField class, and unpacked dictionary kwargs. python_2_unicode_compatible decorator, and substitute the result for self.prefix. substitute auto_id for self.auto_id. if data is true, substitute it for self.files, otherwise self.files is an empty dictionary. substitute initial_id for self.auto_id. substitute error_class for self.error_class. property decorator, call the form.is_valid method, if it evaluates to false, 'ManagementForm data is missing or has been tampered with' and code as a string 'missing_management_form'. if not, and self.absolute_max, return the result. if not, substitute initial_forms for total_forms. substitute self.max_num for total_forms. return the value under the INITIAL_FORM_COUNT key of the self.management_form.cleaned_data dictionary. if not, cached_property decorator, substitute self.files for value under the 'files' key of the defaults dictionary. if self.initial is true and 'initial' key is not contained in kwargs, substitute i-th element of self.initial for value under the 'initial' key of the defaults dictionary. if IndexError exception is caught, update defaults dictionary with kwargs. call the method self.form with unpacked dictionary defaults as an argument, substitute it for form. property decorator, property decorator, property decorator, property decorator, where '%s' is replaced with self.__class__.__name__. for form in self.forms append form.cleaned_data to a list, return the resulting list. property decorator, if i is greater than or equal to the result of the method self.initial_form_count, property decorator, if i is greater than or equal to the result of the method self.initial_form_count, if second element of k is None, classmethod decorator, property decorator, call the method form.is_valid, perform bitwise and with the result and forms_valid as operands, substitute the result for forms_valid. if forms_valid is true and call to the method self.non_form_errors, evaluates to false, return boolean True, otherwise return False. is greater than self.max_num, or if value under the TOTAL_FORM_COUNT key of the self.management_form.cleaned_data dictionary, is grater than self.absolute_max, raise an ValidationError with 2 arguments: return value of the function ungettext with 3 arguments: is smaller than self.min_num, raise an ValidationError with 2 arguments: return value of the function ungettext with 3 arguments: if ValidationError, renamed to e, exception is caught, for every form in self call the method form.has_changed if any of the results evaluates to true, return boolean True, if index is not None and index is smaller than return value of the method self.initial_form_count, value under the ORDERING_FIELD_NAME key of the form.fields is an instance of IntegerField class, created with 3 arguments: label set to return value of the function _ called with an string 'Order', initial set to index incremented by 1, and required as boolean False. if not, value under the ORDERING_FIELD_NAME key of the form.fields is an instance of IntegerField class, created with 2 arguments: value under the DELETION_FIELD_NAME key of the form.fields is an instance of BooleanField class, created with 2 arguments: if not, call the method self.empty_form.is_multipart, return the result property decorator, if not, for every form in self call the form.as_table method, join the results in a string, separated by an empty string. join return value of the function six.text_type called with an argument self.management_form and forms into a string, for every form in self call the form.as_p method, join the results in a string, separated by an empty string. join return value of the function six.text_type called with an argument self.management_form and forms into a string, for every form in self call the form.as_ul method, join the results in a string, separated by an empty string. join return value of the function six.text_type called with an argument self.management_form and forms into a string, if min_num is None, substitute DEFAULT_MIN_NUM for min_num, if max_num is None, substitute DEFAULT_MAX_NUM for max_num, sum max_num and DEFAULT_MAX_NUM, substitute the result for absolute_max. attrs is an dictionary with 9 initial entries: form for 'form', extra for 'extra', can_order for 'can_order', can_delete for 'can_delete', min_num for 'min_num', max_num for 'max_num', absolute_max for 'absolute_max', validate_min for 'validate_min' for validate_max for 'validate_max'. create a class class which name is generated by converting 'FormSet' into a string and appending it to form.__name__, for every formset in formsets, call the function formset.is_valid, if it evaluates to false, __all__ is a tuple containing strings: 'ModelForm', 'BaseModelForm', 'model_to_dict', 'fields_for_model', 'save_instance', 'ModelChoiceField', 'ModelMultipleChoiceField', 'ALL_FIELDS', 'BaseModelFormSet', 'modelformset_factory', 'BaseInlineFormSet', and 'inlineformset_factory'. ALL_FIELDS is a string '__all__'. substitute instance._meta for opts. substitute form.cleaned_data for cleaned_data. file_field_list is an empty list. for every f in opts.fields, if fields is not None and f.name is not contained in fields, if exclude is true and f.name is contained in exclude, if not, call the method f.save_form_data with 2 arguments: instance and value under the f.name key of cleaned_data dictionary. for every f in file_field_list, call the method f.save_form_data with 2 arguments: instance and value under the f.name key of cleaned_data dictionary. if construct is true, call the function construct_instance with 4 arguments form, instance, fields, exclude and substitute the result for instance. substitute instance._meta for opts. if form.errors is true, substitute form.cleaned_data for cleaned_data. append opts.virtual_fields to opts.many_to_many, for every f in the result, if f doesnt has an 'save_form_data' attribute, if fields is true and f.name is not contained in fields, if exclude is true and f.name is contained in exclude, if f.name is contained in cleaned_data, call the method f.save_form_data with 2 arguments: instance and value under the f.name key of cleaned_data dictionary. if commit is true, call the method instance.save. call the function save_m2m. if not, substitute save_m2m for form.save_m2m. substitute instance._meta for opts. concatenate opts.concrete_fields, opts.virtual_fields and opts.many_to_many, for every f in the result, if fields is true and f.name is not contained in fields, if exclude is true and f.name is contained in exclude, if instance.pk is None, if not, call the method f.value_from_object with an argument instance, substitute the result for qs. if qs._result_cache is not None, if not, call the method qs.values_list with 2 arguments: string 'pk' and flat set to boolean True, put the results in a list, substitute the result for value under the f.name key of data dictionary. if not, field_list is an empty list. ignored is an empty list. substitute model._meta for opts. concatenate opts.concrete_fields, sortable_virtual_fields and opts.many_to_many, for every f in sorted result, if fields is not None and f.name is not contained in fields, if exclude is true and f.name is contained in exclude, if widgets is true and f.name is contained in widgets, substitute value under the f.name key of the widgets dictionary for value under the 'widget' key of kwargs dictionary. if localized_fields equals ALL_FIELDS, or if localized_fields is true and f.name is contained in localized_fields, if labels is true and f.name is contained in labels, substitute value under the f.name key of the labels dictionary for value under the 'label' key of kwargs dictionary. if help_texts is true and f.name is contained in help_texts, substitute value under the f.name key of the help_texts dictionary for value under the 'help_text' key of kwargs dictionary. if error_messages is true and f.name is contained in error_messages, substitute value under the f.name key of the error_messages dictionary for value under the 'error_messages' key of kwargs dictionary. if formfield_callback is None, call the method f.formfield with an argument, unpacked dictionary kwargs, substitute the result for formfield. if not, call the method formfield_callback with 2 arguments: f and unpacked dictionary kwargs, substitute the result for formfield. if formfield is true, if not, field_dict is an instance of OrderedDict class, created with an argument field_list. if fields is true, for every f in fields, if exclude is false, or if exclude is true and f is not contained in exclude, and only if f is not in ignored, get 'model' attribute from the options object, if it exists substitute it for self.model, if not self.model is None. get 'fields' attribute from the options object, if it exists substitute it for self.fields, if not self.fields is None. get 'exclude' attribute from the options object, if it exists substitute it for self.exclude, if not self.exclude is None. get 'widgets' attribute from the options object, if it exists substitute it for self.widgets, if not self.widgets is None. get 'localized_fields' attribute from the options object, if it exists substitute it for self.localized_fields, if not self.localized_fields is None. get 'labels' attribute from the options object, if it exists substitute it for self.labels, if not self.labels is None. get 'help_texts' attribute from the options object, if it exists substitute it for self.help_texts, if not self.help_texts is None. get 'error_messages' attribute from the options object, if it exists substitute it for self.error_messages, remove entry under the 'formfield_callback' key of the attrs dictionary, if it exists substitute if for formfield_callback, if not formfield_callback is None. call the method __new__ from the base class of the class ModelFormMetaclass, with 4 arguments: mcs, name, bases and attrs, substitute the result for new_class. if bases equals a tuple with an element: class BaseModelForm. instantiate class ModelFormOptions with argument: attribute 'Meta' of the new_class object. if it exists or None, if not, assign the result to opts and new_class._meta. for every opt in list containing 3 elements: strings 'fields', 'exclude' and 'localized_fields', if opts.model is true, if opts.fields is None and opts.exclude is None, raise an ImproperlyConfigured exception with an argument string "Creating a ModelForm without either the 'fields' attribute, "or the 'exclude' attribute is prohibited; form %s needs updating.", where '%s' is replaced with name. if opts.fields equals ALL_FIELDS, opts.fields is None. call the function fields_for_model with 9 arguments: opts.model, opts.fields, opts.exclude, opts.widgets, formfield_callback, opts.localized_fields, opts.labels, opts.help_texts and opts.error_messages, substitute the result for fields. for every k and v in return value of the function six.iteritems called with an argument fields, if n is false, append it to a list, substitute the resulting list for none_model_fields. missing_fields is difference between set containing none_model_fields and set containing result of the method, new_class.declared_fields.keys. if missing_fields is true, update fields dictionary with new_class.declared_fields. if not, substitute new_class.declared_fields for fields. substitute fields for new_class.base_fields. if opts.model is None. if instance is None, call the method opts.model, substitute the result for self.instance. object_data is an empty dictionary. if not, substitute instance for self.instance. call the method model_to_dict with 3 arguments: instance, opts.fields, opts.exclude and substitute the result for object_data. if initial is not None, update object_data dictionary with initial. call the method __init__ from the base class of the class BaseModelForm, with 8 arguments: data, files, auto_id, prefix, object_data, substitute value under the field_name key of the self.fields dictionary for formfield. if formfield has an attribute 'queryset', exclude is an empty list. if not, if not field_value is None. if f.blank is false and form_field.required is false and field_value is contained in form_field.empty_values, if field equals NON_FIELD_ERRORS and opts.error_messages is true and NON_FIELD_ERRORS is contained in opts.error_messages, substitute value under the NON_FIELD_ERRORS key of opts.error_messages dictionary for error_messages. if not, call the method self._get_validation_exclusions, substitute the result for exclude. convert exclude elements to list, substitute it for construct_instance_exclude. call the method self.instance.full_clean with 2 arguments: exclude set to exclude and validate_unique set to boolean False. if ValidationError, renamed to e, exception is caught, call the method self._get_validation_exclusions, substitute the result for exclude. call the method self.instance.validate_unique with an argument exclude set to exclude. if ValidationError, renamed to e, exception is caught, fail_message is a string 'created'. if not, fail_message is a string changed'. attrs is a dictionary with model for 'model'. if fields is not None, substitute fields for value under the 'fields' key of attrs dictionary. if exclude is not None, substitute exclude for value under the 'exclude' key of attrs dictionary. if widgets is not None, substitute widgets for value under the 'widgets' key of attrs dictionary. if localized_fields is not None, substitute localized_fields for value under the 'localized_fields' key of attrs dictionary. if labels is not None, substitute labels for value under the 'labels' key of attrs dictionary. if help_texts is not None, substitute help_texts for value under the 'help_texts' key of attrs dictionary. if error_messages is not None, substitute error_messages for value under the 'error_messages' key of attrs dictionary. parent is a tuple with 1 element, object. if form has an attribute 'Meta', parent is a tuple with 2 arguments: form.Meta and object. Meta is an instance of class with name 'Meta', parent base class and fields attrs. append string 'Form' to model.__name__, substitute the result for class_name. form_class_attrs is a dictionary with 2 entries: Meta for 'Meta' and formfield_callback for 'formfield_callback'. if 'fields' attribute of Meta object is None and 'exclude' attribute of Meta object is None, raise an ImproperlyConfigured with an argument string "Calling modelform_factory without defining 'fields' or 'exclude' explicitly is prohibited." get the type of form object, return an instance of resulting class created with 3 arguments: class_name, tuple with an element form, model is None. prefix set to None, queryset set to None and unpacked dictionary kwargs. substitute queryset for self.queryset. remove entry under 'initial' key of the kwargs dictionary, substitute it for self.initial_extra if it exists, update defaults dictionary with kwargs. call the method initial_form_count from the base class of the class BaseModelFormSet, return the result. substitute self.model._meta.pk for pk_field. call the method self._get_to_python with an argument pk_field, substitute the result for to_python. call the function to_python with an argument pk, substitute the result for pk. call the method self._existing_object with an argument pk, substitute the result for value under the 'instance' key of kwargs. call the method self.get_queryset, substitute i-th element of the result for value under the 'instance' key of kwargs dictionary. substitute it for value under the 'initial' key of kwargs dictionary. if IndexError exception is caught, call the method _construct_form from the base class of the class BaseModelFormSet, with 2 arguments: i and unpacked dictionary kwargs. if not, call the method self.model._default_manager.get_queryset with an argument qs. if qs.ordered is false, call the method qs.order_by with argument self.model._meta.pk.name, substitute the result for qs. substitute qs for self._queryset. call the method form.save with an argument commit as commit, return the result. call the method form.save with an argument commit as commit, return the result. if commit is true, call the function form.save_m2m. substitute save_m2m for self.save_m2m. all_unique_checks is an empty set. all_date_checks is an empty set. substitute self.deleted_forms for forms_to_delete. for every form in self.forms append form to a list, if function form.is_valid evaluates to true, and form is not contained in forms_to_delete, substitute the resulting list for valid_forms. for every form in valid_forms, call the method form._get_validation_exclusions, substitute the result for exclude. call the method form.instance._get_unique_checks with an argument exclude as exclude, substitute the result for unique_checks, and date_checks, respectively. all_unique_checks is union of all_unique_checks set and unique_checks set. all_date_checks is union of all_date_checks set and date_checks set. errors is an empty list. for every uclass, unique_check in all_unique_checks, seen_data is an empty set. for every form in valid_forms, for every field in unique_check, if field is contained in form.cleaned_data. create a generator that for every d in row_data, if d has an '_get_pk_val' attribute, returns the result of the call the method d._get_pk_val, if not return d, put all the generator items into a tuple row_data. if row_data is true and None is not contained in row_data, if row_data is contained in seen_data, add row_data to seen_data set. for every date_check in all_date_checks, seen_data is an empty set. for every form in valid_forms, if form.cleaned_data is true and value under the field key of form.cleaned_data dictionary is not None, and value under the unique_for key of form.cleaned_data dictionary is not None, if lookup equals a string 'date', substitute value under the unique_for key of form.cleaned_data dictionary for date. date_data is a tuple with 3 elements: date.year, date.month and date.day. if not, date_data is a tuple with an entry: attribute lookup from the value under the unique_for key of the form.cleaned_data dictionary. if errors is true, where '%(field)s' is replaced with first element of unique_check, return the result. if not, call the function ugettext with an argument string "Please correct the duplicate data for %(field_name)s which must be unique for, call the function ugettext with an argument string "Please correct the duplicate values below.", return the result. saved_instances is an empty list. substitute self.deleted_forms for forms_to_delete. substitute form.instance for obj. if form is contained in forms_to_delete, if obj.pk is None, if commit is true, call the method obj.delete. if commit is false, if function form.has_changed evaluates to false, if commit is false, if pk.editable is true, or pk.auto_created is true or pk is an instance of AutoField class, or if pk.rel is true, and pk.rel.parent_link is true and function pk_is_not_editable called with an argument pk.rel.to._meta.pk evaluates to true, if function pk_is_not_editable called with an argument pk evaluates to true, or pk.name is not contained in form.fields, if form.is_bound is true, substitute form.instance.pk for pk_value. if not, if index is not None, call the method self.get_queryset, substitute field pk under the result at the index index for pk_value. if not, pk_value is None. if IndexError exception is caught, pk_value is None. call the method pk.rel.to._default_manager.get_queryset, substitute the result for qs. if not, call the method self.model._default_manager.get_queryset with an argument qs. call the method qs.using with an argument form.instance._state.db, substitute the result for qs. if form._meta.widgets is true, get the value under self._pk_field.name key of form._meta.widgets dictionary, if it exists substitute it for widget, if not, widget is an instance of HiddenInput class. if not, widget is an instance of HiddenInput class value under the self._pk_field.name key of form.fields dictionary is an instance of ModelChoiceField class, created with 4 arguments: qs, initial as pk_value, required as boolean False and widget as widget. call the method add_fields from the base class of the class BaseModelFormSet, with 2 arguments: form and index. get 'Meta' attribute from form object, if it exists substitute it for meta, if not meta is None. if meta is None, meta is an instance of a class named 'Meta', derived from the object base class, without any fields. if 'fields' attribute of meta is None, or if it doesnt exists if fields is None and if 'exclude' attribute of meta is None, or if it doesnt exists if exclude is None. raise an ImproperlyConfigured with an argument string "Calling modelformset_factory without defining 'fields' or 'exclude', explicitly is prohibited." call the function modelform_factory with 10 arguments: model, form as form, fields as fields, exclude as exclude, formfield_callback as formfield_callback, widgets as widgets, localized_fields as localized_fields, labels as labels, help_texts as help_texts and error_messages as error_messages, substitute the result for form. call the function formset_factory with 10 arguments: form, formset, extra as extra, min_num as min_num, max_num as max_num, can_order as can_order, can_delete as can_delete, validate_min as validate_min, validate_max as validate_max, substitute the result for form. substitute model for FormSet.model. save_as_new set to boolean False, prefix set to None, queryset set to None and unpacked dictionary kwargs. if instance is None, if not, substitute instance for self.instance. substitute save_as_new for self.save_as_new. if queryset is None, substitute self.model._default_manager for queryset. if not, call the method queryset.none, substitute it for qs. call the method __init__ from the base class of the class BaseInlineFormSet, with 5 arguments: data, files, prefix set to prefix, call the method initial_form_count from the base class of the class BaseInlineFormSet, return the result. call the method _construct_form from the base class of the class BaseInlineFormSet, with 2 arguments: i, classmethod decorator, instantiate RelatedObject class with 3 arguments: cls.fk.rel.to, cls.model and cls.fk, get attribute 'pk' of the pk_value object, if it doesnt exists use pk_value, set to it self.fk.get_attname return value attribute, of the obj object. if commit is true, call the method obj.save. if commit is true and form has an attribute 'save_m2m', call the method form.save_m2m. call the method add_fields from the base class of the class BaseInlineFormSet, with 2 arguments: form and index. if not, kwargs is a dictionary with an entry: attribute 'label' of the object under the name key of the form.fields dictionary for 'label', if it doesnt exists return value of the function capfirst with an argument self.fk.verbose_name for 'label'. if self.fk.rel.field_name is not equal to self.fk.rel.to._meta.pk.name, substitute self.fk.rel.field_name for value under the 'to_field' key of the kwargs dictionary. value under the name key of the form.fields dictionary is an instance of InlineForeignKeyField created with 2 arguments: self.instance and unpacked dictionary kwargs. if form._meta.fields is true, form._meta.fields is a list created out of form._meta.fields elements. call the method get_unique_error_message from the base class of the class BaseInlineFormSet, with an argument unique_check, return the result. substitute model._meta for opts. if fk_name is true, fks_to_parent is a list containing f, for every f in opts.fields if f.name equals fk_name. substitute first element of fks_to_parent for fk. if fk is not an instance of ForeignKey class, or fk.rel.to is not equal to parent_model, and fk.rel.to is not contained in result of the call to the method parent_model._meta.get_parent_list. raise an ValueError with an argument string "fk_name '%s' is not a ForeignKey to '%s.%'.", where '%s' is replaced with, model._meta.app_label, model._meta.object_name, fk_name, respectively. if not, fks_to_parent is a list containing f for every f in opts.fields, only if f is an instance of ForeignKey, substitute first element of fks_to_parent for fk. if can_fail is true, raise an ValueError with an argument string "'%s.%s' has no ForeignKey to '%s.%s'.", where '%s' is replaced with, model._meta.app_label, model._meta.object_name, parent_model._meta.app_label, parent_model._meta.object_name, respectively. if not, raise an ValueError with an argument string "'%s.%s' has more than one ForeignKey to '%s.%s'.", where '%s' is replaced with, call the function _get_foreign_key with 3 arguments: parent_model, model and fk_name=fk_name, substitute the result for fk. if fk.unique is boolean true, max_num is integer 1. kwargs is a dictionary with 17 entries: form for 'form', formfield_callback for 'formfield_callback', formset for 'formset', extra for 'extra', can_delete for 'can_delete', can_order for 'can_order', fields for 'fields', exclude for 'exclude', min_num for 'min_num', max_num for 'max_num', widgets for 'widgets', validate_min for 'validate_min', validate_max for 'validate_max', localized_fields for 'localized_fields', labels for 'labels', help_texts for 'help_texts', and error_messages for 'error_messages'. call the function modelformset_factory with 2 arguments: model and unpacked dictionary kwargs, substitute the result for FormSet. substitute fk for FormSet.fk. substitute HiddenInput for widget. substitute parent_instance for self.parent_instance. remove element from kwargs dictionary under the key 'pk_field', substitute it for self.pk_field if it exists, if not self.pk_field is boolean False. remove element from kwargs dictionary under the key 'to_field', substitute it for self.to_field if it exists, if not, substitute self.parent_instance.pk for value under the 'initial' key of the kwargs dictionary. if not, substitute self.parent_instance.pk for orig. if not, default_error_messages is a dictionary with an entry, result of the call to the function _ with an argument, required set to boolean True, widget set to None, label set to None, initial set to None, help_text set to an empty string, to_field_name set to None, limit_choices_to set to None, unpacked list args and unpacked dictionary kwargs. if required is true and initial is not None, if not, substitute empty_label for self.empty_label. if cache_choices is not None, call the function warnings.warn with 3 arguments: string "cache_choices has been deprecated and will be removed in Django 1.9.", RemovedInDjango19Warning and stacklevel set to integer 2. if not, substitute cache_choices for self.cache_choices. and unpacked dictionary kwargs. substitute queryset for self.queryset. substitute to_field_name for self.to_field_name call the method __deepcopy__ from the base class of the class ChoiceField, with an argument memo, substitute the result for result. substitute result.queryset for result.queryset. queryset is an property object of this class, with _get_queryset getter and _set_queryset setter functions. choices is an property property object of this class, with _get_choices getter and ChoiceField._set_choices setter functions. if not, if ValueError or self.queryset.model.DoesNotExist exception is caught, if initial is not None, substitute initial for initial_value, otherwise initial_value is an empty string. call the method self.prepare_value with an argument initial_value, use it as the argument for the call to the function force_text, substitute SelectMultiple for widget. substitute MultipleHiddenInput for hidden_widget. default_error_messages is an dictionary with 3 entries: return value of the function _ called with an argument, instantiate base class of the class ModelMultipleChoiceField, substitute filed to_python of the result for to_py. return a list containing return values of the function to_py called with an argument val, for every val in value. call the function force_text with an argument val, if the result is not contained in pks, if initial is None, initial is an empty list. for every value in data. if data_set is not equal to initial_set return boolean True, otherwise return boolean False. only if form_class is not None, and if form_class has an attribute '_meta' and form_class._meta.fields is not None, call the function warnings.warn with 3 arguments: string "The django.forms.util module has been renamed. " from UserList import UserList into default namespace. boolean_attrs is an empty list. delete entry under the attr key of the attrs dictionary. delete entry under the attr key of the attrs dictionary. call the function format_html_join twice, first time with 3 elements: an empty string, string ' {0}="{1}"' and sorted return value of the items of the attrs dictionary, and second time with 3 arguments: an empty string, string ' {0}', and sorted list of boolean_attrs elements, concatenate the results and return the resulting list. python_2_unicode_compatible decorator, call the method json.dumps with a dictionary generate with an expression as an argument, return value of the function e.get_json_data, call the function format_html with 2 arguments: string '
    {0}
', and return value of the function, output is an empty list. python_2_unicode_compatible decorator, if error_class is None, if not, append error_class converted into a string to string 'errorlist ', substitute the result for self.error_class. errors is an empty list. call the method self.get_json_data with an argument escape_html, call the function format_html with 3 arguments: string '
    {1}
', self.error_class and return value of the function, call the method timezone.get_current_timezone, substitute the result for current_timezone. if Exception exception is caught, call the function _ with an argument string '%(datetime)s couldn\'t be interpreted in time zone %(current_timezone)s; it ' 'may be ambiguous or it may not exist.', substitute the result for message. params is an dictionary containing 2 initial entries: value for 'datetime' and current_timezone for 'current_timezone'. call the function six.reraise with 3 arguments: class ValidationError, class ValidationError, created with 3 arguments: call the function timezone.get_current_timezone, substitute the result for current_timezone. __all__ is a tuple of strings: 'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'EmailInput', 'URLInput', 'NumberInput', 'PasswordInput', 'HiddenInput', 'MultipleHiddenInput', 'ClearableFileInput', 'FileInput', 'DateInput', 'DateTimeInput', 'TimeInput', 'Textarea', 'CheckboxInput', 'Select', 'NullBooleanSelect', 'SelectMultiple', 'RadioSelect','CheckboxSelectMultiple', 'MultiWidget', 'SplitDateTimeWidget' and 'SplitHiddenDateTimeWidget'. MEDIA_TYPES is a tuple with 2 strings: 'css' and 'js'. python_2_unicode_compatible decorator, if media is true, substitute media.__dict__ for media_attrs. if not, substitute kwargs for media_attrs. for every name in MEDIA_TYPES, append name to string 'add_' use it as the name of the attribute to get from object self, call the result as an function, call the function chain with an argument unpacked list, append name to string 'render_', call the method self._css.keys, sort the result and substitute it for media. return the result of the call to the function chain, with an argument unpacked list, containing the result of the function, if prefix is None, if not, if name is contained in MEDIA_TYPES, if call to the method self._css.get with an argument medium evaluates to false, combined is an instance of Media class. for every name in MEDIA_TYPES, append name to 'add_' use it as the name of the attribute to get from combined object , call the result with an argument: name appended to string '_', as the name of the attribute to get from self object, or if the previous doesnt exist, None. append name to 'add_' use it as the name of the attribute to get from combined object , call the result with an argument: sup_cls is base class of the class cls. substitute sup_cls.media for base. if AttributeError exception is caught, base is an instance of Media class. get the attribute 'Media' of the cls object, if it exists substitute it for definition, if not definition is None. if definition is true, get the attribute 'extend' of the cls object, if it exists substitute it for extend, if not extend is boolean True. if extend is true, substitute base for m. if not, m is an instance of Media class. for every medium in extend, sum m and value under the medium key of the base dictionary, substitute it for m. if not, if not, return property object with _media as getter function. call the method __new__ from the base class of the class MediaDefiningClass, called with 4 arguments: mcs, name, bases and attrs. if 'media' is not contained in attrs, call the method media_property with an argument new_class, substitute the result for new_class.media. python_2_unicode_compatible decorator substitute parent_widget for self.parent_widget. if attrs is not None, if not, call the method copy.copy, substitute the result for obj. call the method self.attrs.copy, substitute the result for obj.attrs. property decorator, unpack dictionary kwargs, map it through self.attrs and convert to dictionary, substitute the result for attrs. if extra_attrs is true, update attrs dictionary with extra_attrs entry. input_type is None. substitute the result for final_attrs dictionary value under the 'value' key. call the function format_html with 2 arguments: string '', input_type is a string 'text'. if attrs is not None, input_type is a string 'number'. input_type is a string 'email'. input_type is a string 'url'. input_type is a string 'password'. substitute render_value for self.render_value. input_type is a string 'hidden'. substitute choices for self.choices. substitute the result for final_attrs. get the value under the 'id' key of final_attrs dictionary, substitute if for id_ if the key doesnt exists, id_ is None. inputs is an empty list. substitute the result input_attrs. if id_, replace '%s' in string '%s_%s' with id_ and i, substitute the result for input_attrs dictionary value under the 'id' key. input_attrs, append the result to inputs list. join inputs elements into a string, separated with newline character, use it as an argument for the call to the function mark_safe, input_type is a string 'file'. call the method render from the base class of the class FileInput, called with 3 arguments: name, None and attrs as attrs. FILE_INPUT_CONTRADICTION is an instance of object class. call the function ugettext_lazy with an argument string 'Currently', substitute the result for initial_text. call the function ugettext_lazy with an argument string 'Change', substitute the result for input_text. call the function ugettext_lazy with an argument string 'Clear', substitute the result for clear_checkbox_label. template_with_initial is a string '%(initial_text)s: %(initial)s %(clear_template)s
%(input_text)s: %(input)s'. template_with_clear is a string '%(clear)s '. url_markup_template is a string '{1}'. substitutions is a dictionary with 4 initial entries: self.initial_text for 'initial_text', self.input_text for 'input_text', an empty string for 'clear_template' and self.clear_checkbox_label for 'clear_checkbox_label'. template is a string '%(input)s'. call the method render from the base class of the class ClearableFileInput, called with 3 arguments: name, value and attrs, substitute self.template_with_initial for template. call the method self.clear_checkbox_name with an argument name, substitute the result for checkbox_name. call the method self.clear_checkbox_id with an argument checkbox_name, substitute the result for checkbox_id. call the function conditional_escape with an argument checkbox_name, substitute the result for value under the 'clear_checkbox_name' key of the substitutions dictionary. call the function conditional_escape with an argument checkbox_id, substitute the result for value under the 'clear_checkbox_id' key of the substitutions dictionary. call the method render from the instance of CheckboxInput class, with 3 arguments: checkbox_name, boolean False, attrs as a dictionary with an entry: checkbox_id for 'id', substitute the result for value under the 'clear' key of the substitutions dictionary. format self.template_with_clear with substitutions, substitute the result for value under the 'clear_template' key of, substitutions dictionary. call the function mark_safe with an argument template, formated with substitutions, return the result. with 3 arguments: data, files and return value of the function self.clear_checkbox_name called with an argument name, evaluates to true, if upload is true, default_attrs is an dictionary with 2 initial entries: string '40' for 'cols' and string '10' for 'rows'. if attrs is true, update default_attrs dictionary with attrs entry. call the function format_html with 3 arguments: string ('\r\n{1}', return value of the function flatatt, format key is an empty string. substitute format for self.format if format is true, if not self.format is None. call the function formats.localize_input with 2 arguments: value and self.format if true, if not, format_key is a string 'DATE_INPUT_FORMATS'. format_key is a string 'DATETIME_INPUT_FORMATS'. format_key is a string 'TIME_INPUT_FORMATS'. substitute boolean_check for self.check_test if check_test is None, otherwise substitute check_test for self.check_test. call the method self.build_attrs with 3 arguments: attrs, type as a string 'checkbox', name as name, substitute the result for final_attrs. substitute string 'checked' for value under the 'checked' key of final_attrs dictionary. return the result of the function format_html called with 2 arguments: string '', convert elements of choices into a list, substitute it for self.choices. output is a list containing an element: result of the function format_html called with 2 arguments: string '', if options is true, if option_value is None, option_value is an empty string. call the function force_text with an argument option_value, substitute the result for option_value. if option_value is contained in selected_choices, call the function mark_safe with an argument string ' selected="selected"', substitute the result for selected_html. call the method selected_choices.remove with an argument option_value. if not, selected_html is an empty string. call the function format_html with 4 arguments: string '', option_value, selected_html, call the function force_text with an argument v, for every v in selected_choices, add results to a set, substitute the resulting set for selected_choices. output is an empty list. call the function chain with arguments self.choices and choices, for every option_value and option_label in the result, called with an argument option_value, append the result to output. for every option in option_label, if not, choices is a tuple with 3 elements: tuple with 2 elements: string '1' and return value of the function ugettext_lazy, and '3' for '3', substitute it for value. if KeyError exception is caught, output is a list containing an entry: result of the function format_html called with 2 arguments: if options is true, python_2_unicode_compatible decorator, input_type is None. call the function force_text with first element of choice as an argument, substitute the result for self.choice_value. call the function force_text with second element of choice as an argument, substitute the result for self.choice_label. substitute index for self.index. call the function format_html with 2 arguments: string ' for="{0}"' and self.id_for_label, substitute the result for label_for. if not, label_for is an empty string. substitute string 'checked' for value under the 'checked' key of final_attrs dictionary. call the function format_html with 2 arguments: string '' and result of the function flatatt, called with an argument final_attrs, return the result. property decorator, input_type is a string 'radio'. input_type is a string 'checkbox'. python_2_unicode_compatible decorator, choice_input_class is None. outer_html is a string '{content}'. inner_html is a string '
  • {choice_value}{sub_widgets}
    • '. substitute choices for self.choices. substitute idx-th element of self.choices for choice. output is an empty list. for every i and choice in enumerated iterable self.choices, substitute choice for choice_value and choice_label, respectively. call the method self.attrs.copy, substitute the result for attrs_plus. if id_ is true, prepend string '_' to i converted to an string, append the result to the value under the 'id' key of the attrs_plus. attrs as attrs_plus and choices as choice_label. substitute self.choice_input_class for sub_ul_renderer.choice_input_class. and sub_widgets set to return value of the function sub_ul_renderer.render, append the result to output. if not, called with an argument w, and sub_widgets as an empty string, append the result to output. call the function format_html with 3 arguments: self.outer_html, substitute RadioChoiceInput for choice_input_class. substitute CheckboxChoiceInput for choice_input_class. renderer is None. _empty_value is None. remove entry under 'render' key of the kwargs dictionary and substitute it for renderer, if the key doesnt exists, renderer is None. if renderer is true, substitute renderer for self.renderer. call the function chain with 2 arguments: self.choices and choices, convert the result into a list and substitute it for choices. if id_ is true, append string '_0' to id_. substitute RadioFieldRenderer for renderer. _empty_value is an empty string. substitute CheckboxFieldRenderer for renderer. _empty_value is an empty list. property decorator, substitute self.is_localized for widget.is_localized. output is an empty list. get the value under the 'id' key of the final_attrs dictionary, substitute it for id_, if it doesnt exists, id_ is None. for every i and widget in enumerated iterable self.widgets, if IndexError exception is caught, widget_value is None. if id_ is true, call the dict function with 2 arguments: final_attrs and id set to string '%s_%s', where '%s' is replaced with id_ and i, and final_attrs, append the result to output. call the method self.format_output with an argument output, use the result as an argument for the call to the function mark_safe, if id_ is true, append string '_0' to id_. media is an instance of Media class. sum media and w.media, substitute the result for media. media is a property object of the current class, with _get_media as getter function. call the method __deepcopy__ from the base class of the class MultiWidget, with an argument memo, substitute the result for obj. call the method copy.deepcopy with an argument self.widgets, substitute the result for obj.widgets. property decorator, widgets is a tuple with 2 elements: instance of DateInput class, created with 2 arguments: attrs as attrs and format as date_format, call the method __init__ from the base class of the class SplitHiddenDateTimeWidget, with 3 arguments: attrs, date_format, and time_format. widget.input_type is a string 'hidden'. from django.http.request import HttpRequest, QueryDict, RawPostDataException, UnreadablePostError and build_request_repr into default name space. from django.http.response import HttpResponse, StreamingHttpResponse, HttpResponseRedirect, HttpResponsePermanentRedirect, __all__ is a list of strings, 'SimpleCookie', 'parse_cookie', 'HttpRequest', 'QueryDict', 'RawPostDataException', call the function http_cookies.SimpleCookie, on the return value call the value_encode method, with the argument character ';', if the tuple result equals to tuple containing character ';' and string '"\\073"', respectively, assign _cookie_encodes_correctly the boolean True value, otherwise assign it False. assign return value of the call to the http_cookies.SimpleCookie function to _tc. call the _tc.load method with the 'foo:bar=1' converted to string as an argument. if http_cookies.CookieError exception is caught, if _cookie_encodes_correctly and _cookie_allows_colon_in_names are boolean True, substitute http_cookies.SimpleCookie for SimpleCookie. if not, substitute http_cookies.Morsel for Morsel. if _cookie_encodes_correctly is boolean False, from the base class of the class SimpleCookie call the value_encode method with val as the argument, store the result in the val and encoded, respectively. in encoded, replace all the occurrences of unicode character "\\054" with ',' character and "\\073" with ';' characters. if encoded contains string "\\" and if encoded doesnt start with the double quote symbol, put the double qoutes around encoded. if _cookie_allows_colon_in_names is False, call the function force_str with raw data as an argument and substitute it for rawdata. from the base class of the SimpleCookie class call the method load with rawdata as argument. if http_cookies.CookieError exception is raised. if cookie is an empty string, c is an instance of the class SimpleCookie. call the load method on the c class instance, with the cookie argument. if http_cookies.CookieError exception is raised, if not, substitute cookie for c. cookiedict is an empty dictionary. __all__ is an tuple with 3 elements: strings 'MultiPartParser', 'MultiPartParserError' and 'InputStreamExhausted'. RAW is a string "raw". FILE is a file". if six.PY2 is true, _BASE64_DECODE_ERROR is TypeError, if not, _BASE64_DECODE_ERROR is binascii.Error. get the value from META dictionary, under the 'HTTP_CONTENT_TYPE' key, if the key doesnt exist, return the value under the 'CONTENT_TYPE' of the META dictionary, if it doesnt exist return an empty string, substitute the result for content_type. if content_type doesnt start with string 'multipart/', call the method boundary with an argument string 'ascii', use the result to call to the parse_header function, assign the result to ctypes and opts. get the value under the 'boundary' key of the opts dictionary, substitute it for boundary. if boundary is false or return value of the method cgi.valid_boundary called with an argument boundary evaluates to false, convert value under the 'HTTP_CONTENT_LENGTH' key of the META dictionary to an integer of base of value under the 'CONTENT_LENGTH' key of META dictionary, if the key doesnt exists use 0 as the base, substitute the result for content_length. content_length is integer 0. if content_length is lesser than integer 0, call the method boundary.encode with an argument string 'ascii', substitute the result for boundary. substitute input_data for self._input_data. for every x in upload_handlers if x.chunk_size is true, append x.chunk_size to a list, substitute the result for possible_sizes. bring integer 2 to the power of 31, subtract the result by 4, put the result into a list, append possible_sizes to it, substitute content_length for self._content_length. substitute _upload_handlers for self.__upload_handlers. instantiate QueryDict class with 2 arguments: an empty string and encoding set to self._encoding, instantiate a class MultiValueDict, return them. for every handler in handlers, and encoding, substitute the result for result. if result is not None, assign the handle to stream. old_field_name is None. if old_field_name is true, call the method self.handle_file_complete with arguments old_field_name, counters. old_field_name is None. get the value under the 'content-disposition' key of the meta_data dictionary, substitute second element of it for disposition. get the value under the 'name' key of the disposition dictionary, strip it of whitespaces, substitute the result for field_name. if KeyError, IndexError and AttributeError exception is caught, get the value under the 'content-transfer-encoding' key of the disposition meta_data, substitute it for transfer_encoding. if transfer_encoding is not None, strip of the whitespaces first element of transfer_encoding, substitute the result for transfer_encoding. call the function force_text with 3 arguments: field_name, encoding and errors as a string 'replace', substitute the result for field_name. if transfer_encoding equals a string 'base64', call the method field_stream.read, substitute the result for raw_data. if _BASE64_DECODE_ERROR exception is caught, if not, call the method self._post.appendlist with 2 arguments: field_name and result of the function force_text called with 3 arguments: get the value under the 'filename' key of the disposition dictionary, substitute it for file_name. if file_name is false, call the function force_text with 3 arguments: file_name, encoding and errors set to string 'replace', substitute the result for file_name. call the function unescape_entities with an argument file_name, use the result as an argument for the call to the self.IE_sanitize, method, substitute the result for file_name. get the value under the 'content-type' of the meta_data dictionary, if it exists assign it to content_type, content_type_extra, if not, content_type is an empty string and content_type_extra is an empty dictionary. strip the content_type of the whitespaces, substitute it for content_type. get the value under the 'charset' key of the content_type_extra dictionary, substitute it for charset. convert to an integer first element of the value under the 'content-length' key of the meta_data dictionary, substitute it for content_length. content_length is None. for every handler in handlers, call the method handler.new_file with 6 arguments: field_name, file_name, content_type, content_length, charset and content_type_extra. if StopFutureHandlers exception is caught. for every chunk in field_stream, if transfer_encoding equals string 'base64', if over_bytes is true, call the method field_stream.read with an argument: over_bytes subtracted from integer 4, substitute the result for over_chunk. increment chunk by over_chunk. call the method base64.b64decode with an argument chunk, substitute the result for chunk. if Exception, renamed to e, exception is caught, call the method six.reraise with 3 arguments: MultiPartParserError, MultiPartParserError created with msg, and third element of the result of the function sys.exc_info. for every i and handler in enumerated iterable handlers, call the method handler.receive_data_chunk with 2 arguments: chunk and i-th element of counters, substitute the result for chunk. increment i-th element of counters by chunk_length. if chunk is None, if SkipFile exception is caught, call the function exhaust with an argument field_stream. if not, substitute field_name for old_field_name. if not, call the function exhaust with an argument stream. if StopUpload, renamed to e, exception is caught, if e.connection_reset is false, call the function exhaust with an argument self._input_data. if not, call the function exhaust with an argument self._input_data. for every handler in handlers, call the method handler.upload_complete, substitute the result for retval. if retval is true, for every i and handler in enumerated iterator self._upload_handlers, call the method handler.file_complete with i-th element of counters as an argument, substitute the result for file_obj. if file_obj is true, call the method filename.rfind with an argument string "\\", increment the result by one, if handler has an attribute 'file', call the method handler.file.close. substitute producer for self._producer. substitute length for self._length. substitute length for self._remaining. if size is None substitute self._remaining for remaining, if not, substitute size for remaining. if remaining is None, while remaining is not equal to integer 0, if remaining is not greater than 0, assert an error with the message string 'remaining bytes to read should never go negative'. create list of first remaining elements of chunk, substitute it for emitting. call the method self.unget with list containing first remaining elements of chunk as an argument. join result of the parts function into a bytes string, substitute it for out. if not, get the next element of the self._producer iterable, substitute it for output. if bytes is false, append current_number to a list for current_number in self._unget_history, if current_number is equal to num_bytes, substitute the length of the resulting list for number_equal. if number_equal is greater than integer 40, raise SuspiciousMultipartForm exception with an argument string, "The multipart parser got stuck, which shouldn't happen with" substitute flo for self.flo. substitute chunk_size for self.chunk_size. if InputStreamExhausted exception is caught, if not, if InputStreamExhausted exception is caught, call the method self._stream.read with an argument integer 1, substitute the result for unused_char. if unused_char is false, call the method self._stream.unget with an argument unused_char. substitute self._rollback for rollback. bytes_read is integer 0. chunks is an empty list. for every bytes in stream, if bytes_read is greater than rollback, if bytes is false, if not, if chunks is false, join chunks into bytes string, substitute it for chunk. or boolean False if not, substitute the result for boundary. if boundary is true, substitute elements of tuple boundary to end and next, respectively. call the method stream.unget with elements of list chunk from the index next to the end. if not, slice chunk list to get the last rollback elements, if the new list is not empty, if not, call the method stream.unget with last rollback elements of chunk as an argument. return last rollback elements of chunk. if index is lesser than integer 0, if not, substitute index for end. substitute greater element between integer 0 and end decremented by one for last. decrement end by one. substitute greater element between integer 0 and end decremented by one for last. decrement end by one. iterator is None. iterator is iterator created out of stream_or_iterable. iterator is an instance of ChunkIter class, created with arguments: stream_or_iterable and integer 16384. if iterator is None, raise an MultiPartParserError with an argument string 'multipartparser.exhaust() was passed a non-iterable or stream parameter'. for every __ in iterator, call the method stream.read with an argument max_header_size, substitute the result for chunk. call the method chunk.find with an argument bytes string '\r\n\r\n', substitute the result for header_end. call the function parse_header with an argument line, substitute the result for main_value_pair and params, respectively. if header_end equals integer negative 1, call the method stream.unget with an argument chunk. substitute first header_end elements of chunk list for header. call the method stream.unget with list containing elements of chunk list from the header_end incremented by integer 4 as a start index to the end as argument. substitute RAW for TYPE. outdict is an empty dictionary. split header string at string '\r\n', for every line in result, if name equals a string 'content-disposition', get the value under the 'filename' key of the params dictionary, if it is true, substitute FILE for TYPE. if TYPE equals to RAW, call the method stream.unget with an argument chunk. return a tuple with 3 elements: TYPE, outdict and stream. append boundary to bytes string '--', substitute the result for self._separator. for every sub_stream in boundarystream, append line to bytes string ';', use it as an argument for the call to the function _parse_header_params, substitute the result for plist. pop the first element from plist, convert it to lowercase, call the method decode on it, with string 'ascii' as an argument, substitute the result for key. pdict is an empty dictionary. for every p in plist, call the method p.find with bytes string '=' as an argument, substitute the result for i. if i is greater or equal to integer 0, take the first i elements of string p, strip the whitespaces from the both sides, convert it to lowercase and apply on it the method, plist is an empty list. while first element of s is equal to bytes string ';', substitute s without the first element for s. call the method s.find with an argument bytes string ';', substitute the result for end. while end is greater than integer 0 and return value of the s.count called with 3 arguments: an empty string, integer 0 and end, is an even number, call the method s.find with 2 arguments: bytes string ';' and end incremented by one, substitute the result for end. if end is lesser than integer 0, substitute first end elements of s for f. substitute elements of s from the end index to end for s. RAISE_ERROR is an instance of object class. compile the regex "^https?://" with an argument re.I, substitute it for absolute_http_url_re. compile the regex "^([a-z0-9.-]+|\[[a-f0-9]*:[a-f0-9:]+\])(:\d+)?$", substitute it for host_validation_re. _encoding is None. _upload_handlers is an empty list. get the value under the 'HTTP_X_FORWARDED_HOST' key of the self.META dictionary, substitute the result for host. substitute the value under the 'HTTP_HOST' key of the self.META dictionary, substitute it for host. if not, substitute the value under the 'SERVER_NAME' key of the self.META dictionary, substitute it for host. convert the value under the 'SERVER_NAME' key of the self.META dictionary to a string, substitute result for server_port. if return value of the self.is_secure method is true and server_port is not equal to string '443', if return value of the self.is_secure is false and server port is not equal to string '80', join host and server_port into a string, separated with ':', substitute the result for host. call the function split_domain_port with an argument host, assign the result to domain and port, respectively. if domain is true and return value of the function validate_host called with 2 arguments: domain and settings.ALLOWED_HOSTS, evaluates to true, if not, msg is a string "Invalid HTTP_HOST header: %r.", replace '%r' with host. if domain is true, append string " You may need to add %r to ALLOWED_HOSTS." to msg, where '%s' is replaced with domain. if not, append string " The domain name provided is not valid according to RFC 1034/1035." to msg. if KeyError exception is caught, if default is true and RAISE_ERROR is false, if not, call the method signing.get_cookie_signer with an argument salt set to sum of key and salt, call the method unsign on the result, with arguments cookie_value and max_age set to max_age. if signing.BadSignature exception is caught, if default is true and RAISE_ERROR is false, if not, if location is None, call the method self.get_full_path, append the result to string '//', substitute it for location. and path with self.path, substitute the result for current_uri. call the function urljoin with arguments current_uri and location, substitute the result for location. return string 'https' if value under the "HTTPS" key of the os.environ dictionary equals string 'on', if not return 'http'. property decorator. get the value under the 'HTTP_X_REQUESTED_WITH' key of the self.META dictionary, if it equals string 'XMLHttpRequest', return boolean True, otherwise return boolean False. property decorator. encoding.setter decorator, delete self._get. add to a list result of the method uploadhandler.load_handler called with arguments handler and self, substitute resulting list for self._upload_handlers. property decorator, upload_handlers.setter decorator. substitute upload_handlers for self._upload_handlers. self.upload_handlers is an instance of ImmutableList, created with 2 arguments: self.upload_handlers, property decorator, if IOError, renamed to e, exception is caught, call the function six.reraise with 3 arguments: UnreadablePostError, UnreadablePostError instantiated with unpacked list e.args, if not, if MultiPartParserError exception is caught, self._files is an instance of class MultiValueDict. if not, for every f in return value of the return value of the method chain.from_iterable called with argument: second element of l for every l in return value of the self._files.lists call the method f.close. if IOError, renamed to e, exception is caught, call the function six.reraise with 3 arguments: UnreadablePostError, UnreadablePostError instantiated with unpacked list e.args, if IOError, substituted to e, exception is caught, call the function six.reraise with 3 arguments: UnreadablePostError, UnreadablePostError instantiated with unpacked list e.args, read one line from self file stream, substitute the result for buf. if buf is false, substitute xreadlines for __iter__. _encoding is None. if encoding is false. call the method query_string.decode, substitute the result for query_string. for every key and value in return value of the parse_qsl with 3 arguments: query_string is it exists or an empty string if not, if not, call the method self.appendlist with 2 arguments: return value of the function force_text with 3 arguments: key, encoding and errors set to string 'replace', and return value of the function force_text with 3 arguments: value, encoding and errors set to string 'replace'. call the method mutable substitute for self._mutable. property decorator, encoding.setter decorator, call the method result.setlist with 2 arguments: return value of the function copy.deepcopy called with 2 arguments: key and memo, for every elt in list_ call the method bytes_to_text with 2 argument: elt and self.encoding, append the result into a list, call the method popitem from the base class of the class QueryDict, return the result. call the method bytes_to_text with 2 arguments: default and self.encoding, substitute the result for default. output is an empty list. if safe is true, call the function force_bytes with 2 arguments: safe and self.encoding, substitute it for safe. encode is an lambda function with arguments k and v, return value is string '%s=%s', where '%s' is replaced with: return value of the function quote called with arguments k and safe, and with return value of the function quote called with arguments v and safe. if not, encode is an lambda function with 2 arguments k and v, return value is the result of the function urlencode, called with an argument: dictionary containing element v for k. for every k and list_ in return value of the method self.lists, for every v in list_ append to a list result of the function encode, called with arguments: k and result of the function force_bytes, get is a tuple containing elements generated by the call to the function pformat with an argument GET_override, if GET_override is not None, or otherwise generated with the call to the function pformat with an argument request.GET. if Exception exception is caught, get is a string ''. post is a string ''. if not, get is a tuple containing elements generated by the call to the function pformat with an argument POST_override, if POST_override is not None, or otherwise generated with the call to the function pformat with an argument request.POST. if Exception exception is caught, post is a string ''. get is a tuple containing elements generated by the call to the function pformat with an argument COOKIES_override, if COOKIES_override is not None, or otherwise generated with the call to the function pformat with an argument request.COOKIES. if Exception exception is caught, cookies is a string ''. get is a tuple containing elements generated by the call to the function pformat with an argument META_override, if META_override is not None, or otherwise generated with the call to the function pformat with an argument request.META. if Exception exception is caught, meta is a string ''. call the function force_str with an argument string '<%s\npath:%s,\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>', if not, convert host to lowercase. call the method host_validation_re.match with an argument host. if last element of host equals character ']', if host ends with '.', remove the last element from host. for every pattern in allowed_hosts: convert pattern to lowercase, substitute it for pattern. if pattern equals '*' or pattern starts with '.' or pattern equals host, and only if: host ends with '.' and host ends with pattern or host is equal to all but first elements of pattern, substitute boolean true for match, otherwise substitute boolean False for match. if match is true, from email.header import Header into default name space. REASON_PHRASES is a dictionary containing 59 initial entries: 'CONTINUE' for 100, 'SWITCHING PROTOCOLS' for 101, status_code is an integer 200. reason_phrase is None. if content_type is false, if status is not None. if reason is not None, substitute reason for self.reason_phrase. substitute serialize_headers for __bytes__. if not, substitute serialize_headers for __str__. if not, if not, if not, if UnicodeError, renamed to e, exception is caught, if mime_encode is true, convert the result into a string and substitute it for value. if not, call the method self._convert_to_charset with arguments: header and string 'ascii', substitute the result for header. substitute the result for value. substitute tuple containing 2 elements: header and value for the value under the header converted to lowercase key of the self._headers dictionary. delete the value under the header converted to lowercase key of the self._headers dictionary. if KeyError exception is caught, convert header to lowercase, use it as the key to get the value from the self._headers dictionary, return the second element of the result. call the method self.__dict__.copy, substitute the result for state. get the value under the 'cookies' key of the state dictionary, add state element to self.__dict__ dictionary. convert deader to lowercase, if it is contained in self._headers return boolean True, if not, return boolean False. substitute has_header for __contains__. convert header to lowercase, use it to as a key to get the value of the self._headers dictionary, if expires is not None, call the method timezone.is_aware with an argument expires, if it evaluates to true, call the method timezone.make_naive with arguments: expires, timezone.utc, substitute the result for expires. call the method expires.utcnow, subtract the result from expires, substitute the result for delta. call the method datetime.timedelta with an argument seconds set to integer 1, increment delta by it. expires is None. multiply delta.days with an integer 86400 add to the result delta.seconds, if the result is greater than integer 0, substitute it for max_age, if not, max_age is integer 0. if not, if max_age is not None, if expires is false, get the value under the key key of the self.cookies dictionary, call the cookie_date function with an argument: if domain is not None, if secure is true, if httponly is true, call the method self.set_cookie with 5 arguments: key, max_age as integer 0, path as path, domain as domain, for every closable in self._closable_objects, call the method closable.close. if Exception exception is caught, call the method signals.request_finished.send with an argument sender set to self._handler_class. substitute content for self.content. substitute serialize for __bytes__. if not, substitute serialize for __str__. property decorator, content.setter decorator, substitute the result for value. if not, and unpacked dictionary kwargs. substitute streaming_content for self.streaming_content. property decorator, where '%s' is replaced with self.__class__.__name__. property decorator, streaming_content.setter decorator, allowed_schemes is an list containing 3 elements: strings 'http', 'https' and 'ftp'. call the function force_text with an argument redirect_to, use the result as an argument for the call to the function urlparse, substitute the result for parsed. if parsed.scheme is true and parsed.scheme is not contained in self.allowed_schemes, raise an DisallowedRedirect exception with an argument string "Unsafe redirect to URL with protocol '%s'", and unpacked dictionary kwargs. call the function iri_to_uri with an argument redirect_to, substitute the result for the value under the 'Location' key of the self dictionary. status_code is an integer 302. status_code is an integer 301. status_code is an integer 304. HttpResponse.content.setter property, status_code is an integer 400. status_code is an integer 404. status_code is an integer 403. status_code is an integer 405. and unpacked dictionary kwargs. join into a string permitted_methods, separated by string ', ', substitute it for value under the 'Allow' key of the self dictionary. status_code is an integer 410. status_code is an integer 500. raise an TypeError exception with an argument string 'In order to allow non-dict objects to be serialized set the safe parameter to False'. if 'content_type' key doesnt exist in kwargs, set its value to 'application/json'. if not, if not, from django.template.base import ALLOWED_VARIABLE_CHARS, BLOCK_TAG_END, BLOCK_TAG_START, COMMENT_TAG_END, COMMENT_TAG_START, TemplateSyntaxError and VariableDoesNotExist. from django.template.base import Context, FilterExpression, Lexer, Node, NodeList, Parser, RequestContext, Origin, StringOrigin, from django.template.base import Library, add_to_builtins, builtins, get_library, get_templatetags_modules, get_text_list, import_library and libraries. __all__ is a tuple containing 4 strings: 'Template', 'Context', 'RequestContext' and 'compile_string'. from inspect import getargspec and getcallargs into default name space. TOKEN_TEXT is integer 0 TOKEN_VAR is integer 1 TOKEN_BLOCK is integer 2 TOKEN_COMMENT is integer 3. TOKEN_MAPPING is a dictionary with 4 initial entries: 'Text' for TOKEN_TEXT, 'Var' for TOKEN_VAR, 'Block' for TOKEN_BLOCK, and 'Comment' for TOKEN_COMMENT. FILTER_SEPARATOR is a string '|'. FILTER_ARGUMENT_SEPARATOR is a string ':'. VARIABLE_ATTRIBUTE_SEPARATOR is a string '.'. BLOCK_TAG_START is a string '{%'. BLOCK_TAG_END is a string '%}'. VARIABLE_TAG_START is a string '{{'. VARIABLE_TAG_END is a string '}}'. COMMENT_TAG_START is a string '{#'. COMMENT_TAG_END is a string '#}'. TRANSLATOR_COMMENT_MARK is a string 'Translators'. SINGLE_BRACE_START is a string '{'. SINGLE_BRACE_END is a string '}'. ALLOWED_VARIABLE_CHARS is a string 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.'. UNKNOWN_SOURCE is a string ''. call the function re.compile with an argument string '(%s.*?%s|%s.*?%s|%s.*?%s)', substitute all occurrences of '%s' with, return value of the function re.escape called with an argument BLOCK_TAG_START, return value of the function re.escape called with an argument BLOCK_TAG_END, return value of the function re.escape called with an argument VARIABLE_TAG_START, return value of the function re.escape called with an argument VARIABLE_TAG_END, return value of the function re.escape called with an argument COMMENT_TAG_START, and return value of the function re.escape called with an argument COMMENT_TAG_END, substitute the result for tag_re. libraries is an empty dictionary. builtins is an empty list. invalid_var_format_string is None. python_2_unicode_compatible decorator, substitute msg for self.msg. substitute params for self.params. substitute source for self.source. call the function force_text with an argument template_string. if UnicodeDecodeError exception is caught, origin is an instance of StringOrigin class created with an argument template_string. call the function compile_string with 2 arguments: template_string and origin, substitute the result for self.nodelist. substitute origin for self.origin. for every subnode in node, call the method context.render_context.push. finally perform, remove the first element from context.render_context. substitute DebugLexer and DebugParser for lexer_class and parser_class. if not, call the method lexer_class with an arguments template_string and origin, substitute the result for lexer. substitute value under the self.token_type key of the TOKEN_MAPPING dictionary for token_name. return a string '<%s token: "%s...">' with '%s', replace '%s' with token_name and 20 self.contents elements with every newline deleted. split is an empty list. if bit starts with '_("' ot bit starts with "_('", append ')' to third element of bit, substitute it for sentinal. trans_bit is a list with an element bit. while bit doesnt end with sential, join trans_bit into a string separated with whitespaces, substitute the result for bit. substitute template_string for self.template_string. substitute origin for self.origin. result is an empty list. split tag_re by self.template_string separator, for every bit in result, if bit is true, in_tag is boolean True if in_tag is False, otherwise is boolean False. if in_tag is true and token_string starts with BLOCK_TAG_START. take elements of token_string from second to second last element and strip the whitespaces surrounding the result, if in_tag and is not contained in self.verbatim, if token_string starts with VARIABLE_TAG_START, token is an instance of Token class, created with 2 arguments: TOKEN_VAR, if first nine elements of block_content is string 'verbatim' or 'verbatim ', append block_content to a string 'end', substitute the result for self.verbatim. token is an instance of Token class, created with 2 arguments: TOKEN_BLOCK and block_content. content is an empty string. call the method token_string.find with an argument TRANSLATOR_COMMENT_MARK, if it evaluates to true, take elements of token_string from second to second last element and strip the whitespaces surrounding the result, substitute the result for content. token is an instance of Token class, created with 2 arguments: TOKEN_COMMENT and content. if not, token is an instance of Token class, created with 2 arguments: TOKEN_TEXT and token_string. substitute self.lineno for token.lineno. call the method token_string.count with an argument '\n', append the result to self.lineno. substitute tokens for self.tokens. for every lib in builtins, call the method self.add_library with an argument lib. if parse_until is None, parse_until is an empty list, if token.token_type equals integer 0, call the method self.extend_nodelist with 3 arguments: nodelist, instance of TextNode class, created with an argument token.contents, if token.contents is false, call the method self.compile_filter with an argument token.contents, substitute the result for filter_expression. if TemplateSyntaxError, replaced with e, exception is caught, call the method self.create_variable_node with an argument filter_expression, substitute the result for var_node. call the method self.extend_nodelist with 3 arguments: nodelist, var_node and token. split token.contents into separate words, substitute the first element of the result for command. if IndexError exception is caught, if command is contained in parse_until, call the method self.enter_command with 2 arguments command and token. substitute the value under the command key of self.tags dictionary for compile_func. if KeyError exception is caught, call the method self.invalid_block_tag with 3 arguments: token, command and parse_until. call the method compile_func with 2 arguments self and token, substitute the result for compiled_result. if TemplateSyntaxError, renamed to e, exception is caught, call the method self.extend_nodelist with 3 arguments: nodelist, compiled_result and token. if parse_until is true, call the method self.unclosed_block_tag with an argument parse_until. if token.token_type equals TOKEN_BLOCK and token.contents equals endtag, call the method self.unclosed_block_tag with an argument list with an element endtag. return an instance of VariableNode class with an argument filter_expression. if node.must_be_first is true and nodelist is true, if nodelist.contains_nontext is true, if AttributeError exception is raised, if parse_until is true, insert token at the beginning of self.tokens. update self.tags dictionary with lib.tags. update self.filters dictionary with lib.filters. if not, substitute subject for self.subject. substitute self.subject for subject. where '%s' is replaced with subject. substitute i for p. increment i by integer 1. take subject elements from p-th to i-th index, substitute it for s. increment i by integer 1. substitute self.subject for subject. if i-th element of subject is '"' character or "'" character, substitute i-th element of subject for c. increment i by integer 1. increment i by one. where '%d' is replaced with i and '%s' is replaced with subject. increment i by one. where '%s' is replaced with subject. if i-th element of subject is '"' character or "'" character, substitute i for p. increment i by integer 1, increment i by integer 1, where '%d' is replaced with i and '%s' is replaced with subject. increment i by integer 1, call the function next_space_index with 2 arguments: subject and i, substitute the result for i. substitute subject elements from p-th to i-th index for res. increment i by integer 1, if not, substitute i for p. call the function next_space_index with 2 arguments subject and i, substitute the result for i. take subject elements from p-th to i-th index, substitute it for s. increment i by integer 1,. constant_string is a raw string "(?:%(i18n_open)s%(strdq)s%(i18n_close)s|%(i18n_open)s%(strsq)s%(i18n_close)s|%(strdq)s|%(strsq)s)", where 'strdq' is replaced with '"[^"\\]*(?:\\.[^"\\]*)*"', 'strsq' is replaced with "'[^'\\]*(?:\\.[^'\\]*)*'", 'i18n_open' is replaced with return value of function re.escape called with an argument string '_(', 'i18n_close' is replaced with return value of function re.escape called with an argument string ')'. remove all occurrences of newline character from constant_string. filter_raw_string is a raw string "^(?P%(constant)s)|^(?P[%(var_chars)s]+|%(num)s)| (?:\s*%(filter_sep)s\s* (?P\w+)(?:%(arg_sep)s(?:(?P%(constant)s)|(?P[%(var_chars)s]+|%(num)s)))?)", where 'constant' is replaced with constant_string, 'num' with raw string '[-+\.]?\d[\d\.e]*', 'var_chars' with string "\w\.", 'filter_sep' with result of the function re.escape called with an argument FILTER_SEPARATOR, anbd 'arg_sep' with result of the function re.escape called with an argument FILTER_ARGUMENT_SEPARATOR. call the function re.compile with 2 arguments: filter_raw_string and result for bitwise OR on 2 operands re.UNICODE and re.VERBOSE, call the method filter_re.finditer with an argument token, substitute the result for matches. var_obj is None. filters is an empty list. upto is integer 0. for every match in matches, call the method match.start, substitute the result for start. if upto is not equal to start. raise an TemplateSyntaxError exception with an argument string "Could not parse some characters: %s|%s|%s", where '%s' is replaced with first upto elements of token string, token string elements from upto to start index, and token string elements from start index to the end. if var_obj is None, call the method match.group with 2 arguments: strings "var" and "constant", substitute the result for var and constant, respectively. if constant is true, instantiate Variable class, with an argument constant, call the resolve method with an empty dictionary as an argument, substitute the result for var_obj. if VariableDoesNotExist exception is not caught, var_obj is None. if not, var_obj is an instance of Variable class, created with an argument var. if not, call the methof match.group with an argument "filter_name", substitute the result for filter_name. call the method match.group with 2 arguments: strings "constant_arg" and "var_arg", substitute the result for constant_arg, and var_arg, respectively. if constant_arg is true, call the method self.args_check with 3 arguments: filter_name, filter_func and args. call the method match.end, substitute the result for upto. where '%s' is replaced with elemnts of token from upto index till the end, and token. substitute filters for self.filters. substitute var_obj for self.var. if VariableDoesNotExist exception is caught, if ignore_failures is true, obj is None, if not, use global variable invalid_var_format_string. if invalid_var_format_string is None, if invalid_var_format_string is true, if not, if not, arg_vals is an empty list, if lookup is false, if not, call the function template_localtime with 2 arguments: obj and context.use_tz, substitute the result for obj. substitute the result for new_obj. if not, call the function mark_safe with an argument new_obj, substitute the result for obj. call the function mark_for_escaping with an argument new_obj, substitute the result for obj. if not, substitute new_obj for obj. convert provided into a list and substitute it for provided. if plen is lesser than difference of alen and dlen, or if plen is greater than alen, args_check is a static method. call the function warnings.warn with 3 arguments: substitute var for self.var. convert var into an floating point number, substitute it for self.literal. if '.' is not contained in var and 'e' is not contained in var converted into lowercase, if var ends with '.', if var starts with '_(' and var ends with ')', remove first 2 and last 2 elements from var. call the function unescape_string_literal with an argument var, use it as an argument for the call to the function mark_safe, call the function var.find with an argument: '_' appended to VARIABLE_ATTRIBUTE_SEPARATOR, if the result is greater than integer -1, where '%s' is replaced with var. call the method var.split with an argument VARIABLE_ATTRIBUTE_SEPARATOR, convert the result to a tuple and substitute it for self.lookups. if else, if not, substitute context for current. substitute element at the bit index of current for current. get the bit attribute of current object, substitute it for current. if TypeError and AttributeError exceptions are caught, convert bit to an integer and use it as index to obtain an element for list current, substitute it for current. where '%s' is replaced with bit and '%r' is replaced with current. if current is callable object, if not, call the function current, substitute the result for current. call the function getcallargs with an argument current, if not, if Exception, renamed to e, exception is caught, if not, child_nodelists is an tuple with an element 'nodelist'. nodes is an empty list. for every attr in self.child_nodelists, if nodelist is true, call the method nodelist.get_nodes_by_type with an argument nodetype, extend nodes with the result. call the method self.render_node with 2 arguments: node and context, substitute the result for bit. if not, substitute node for bit. modes is an empty list. call the method node.get_nodes_by_type with an argument nodetype, extend nodes with it. call the function force_str with 3 arguments: string "", with '%s' replaced with first 25 elements of self.s string, if not, substitute filter_expression for self.filter_expression. return a string "", substitute '%s' with self.filter_expression. call the method self.filter_expression.resolve with an argument context, substitute the result for output. if UnicodeDecodeError exception is caught, call the function re.compile with an argument raw string "(?:(\w+)=)?(.+)", substitute the result for kwarg_re. if match is true and call to the method match.group with an argument integer 1 evaluates to true, kwarg_format is boolean True, otherwise it is boolean False. if kwarg_format is false, if support_legacy is false, if kwarg_format is true, if match is false or call to the method match.group with an argument integer 1 evaluates to boolean false, if not, if takes_context is true, if first element of params equals a string 'context', substitute params without the first element for params. if not, convert params into a list, substitute it for unhandled_params. if kwarg is true, call the method six.iteritems with an argument kwarg, convert the result into a list, substitute first element of the result for param and value. if param is not in params and varkw is None, where '%s' are replaced with name and param. if not, if param is contained in unhandled_params, call the method unhandled_params.remove with an argument param. if not, if not, remove first element of unhandled_params. if IndexError exception is caught, if varargs is None, where '%s' is replaced with name. if defaults is not None, if unhandled_params is true, substitute takes_context for self.takes_context. resolved_args is an list with elements, return value of the method var.resolve with an argument context, for every var in self.args. append resolved_args to a list containing context element, substitute it for resolved_args. resolved_kwargs is dictionary with elements: return value of the method v.resolve called with an argument context, for k, for every k and v in return value of the method self.kwargs.items. return resolved_args and resolved_kwargs. if name is None and compile_function is None, if name is callable object, if not, if not, if name is None and filter_func is None, if name is callable object, call the method self.filter_function with arguments name and unpacked dictionary flags, return the result. if not, for every attr in tuple with 3 arguments: strings 'expects_localtime', 'is_safe' and 'needs_autoescape', if attr is contained in flags, if filter_func has an attribute "_decorated_function", set filter_func._decorated_function objects attr attribute to value. substitute name for filter_func._filter_name. if not, call the method self.get_resolved_arguments with an argument context, substitute the result for resolved_args and resolved_kwargs. substitute its __name__ field for function name, if it doesnt exists substitute func.__name__ for function_name. call the function generic_tag_compiler, params set to params, varargs set to varargs, varkw set to varkw, defaults set to defaults, if not, substitute target_var for self.target_var. call the method self.get_resolved_arguments with an argument context, substitute the result for resolved_args and resolved_kwargs. if not, call the method self.get_resolved_arguments with context as an argument, substitute the result for resolved_args and resolved_kwargs. substitute file_name for t. evaluates to true, call the function select_template with an argument file_name, substitute the result for t. if not, call the function get_template with an argument file_name, substitute the result for t. call the function context_class with 2 arguments: _dict and unpacked dictionary containing 4 entries: context.autoescape for 'autoescape', context.autoescape for 'current_app', context.use_l10n for 'use_l10n', and context.use_tz for 'use_tz', substitute the result for new_context. call the function context.get with 2 argument 'csrf_token' and None, substitute the result for csrf_token. if csrf_token is not None, substitute csrf_token for value under the 'csrf_token' key of new_context dictionary. substitute __name__ field of the result for function_name, in not, substitute func.__name__ for function_name. call the function partial with 8 arguments: generic_tag_compiler, params set to params, varargs set to varargs, varkw set to varkw, call the function module_has_submodule with 2 arguments: package and module, return inverted boolean result. call the function import_module with an argument taglib_module, substitute the result for mod. call the function is_library_missing with an argument taglib_module, if it evaluates to true, if not, if AttributeError exception is caught, where '%s' is replaced with taglib_module. templatetags_modules is an empty list. use global variable templatetags_modules. if templatetags_modules is false, _templatetags_modules is an empty list. templatetags_modules_candidates is an list with an argument string 'django.templatetags'. for every app_config in result of the method apps.get_app_configs, append the resulting list to templatetags_modules_candidates. for every templatetag_module in templatetags_modules_candidates, call the function import_module with an argument templatetag_module. substitute _templatetags_modules for templatetags_modules. get the value under the library_name key of the libraries dictionary, if it exists, substitute it for lib, if not, lib is None. if lib is false, call the function get_templatetags_modules, substitute the result for templatetags_modules. tried_modules is an empty list. for every module in templatetags_modules, taglib_module is an string '%s.%s', where '%s' is replaced to module and library_name. call the function import_library with an argument taglib_module, substitute the result for lib. if lib is true, substitute lib for value under the library_name key of libraries dictionary. if lib is false, call the function add_to_builtins with an argument string 'django.template.defaulttags'. call the function add_to_builtins with an argument string 'django.template.defaultfilters'. call the function add_to_builtins with an argument string 'django.template.loader_tags'. from copy import copy into default name space. _standard_context_processors is None. _builtin_context_processors is a tuple containing a string 'django.core.context_processors.csrf'. call the method self._reset_dicts with an argument dict_. call the function copy with an argument base class of the class BaseContext, substitute the result for duplicate. hard copy list self.dicts to duplicate.dicts. call the method new_context._reset_dicts values. flat is an empty dictionary, update flat dictionary with d. call the flatten method of the self and other objects, if they are equal, return boolean True, if not return boolean False. use_l10n set to None and use_tz set to None. substitute autoescape for self.autoescape. substitute current_app for self.current_app. substitute use_l10n for self.use_l10n. substitute use_tz for self.use_tz. self.render_context is a instance of RenderContext class. call the the method __copy__ from the base class of the class Context, substitute the result for duplicate. call the function copy with an argument self.render_context, substitute the result for duplicate.render_context. if other_dict doesnt have an '__getitem__' attribute, use global variable _standard_context_processors. if _standard_context_processors is None, processors is an empty list. collect is an empty list. extend collect list with _builtin_context_processors. convert processors elements into a tuple, substitute it for _standard_context_processors. use_l10n set to None and use_tz set to None. call the method Context.__init__ with 5 arguments: self, dict_, current_app as current_app, use_l10n as use_l10n, use_tz as use_tz. if processors is None, processors is an empty tuple. if not, convert processors into a tuple and substitute it for processors. updates is an empty dictionary. call the function get_standard_processors, append processors to the result, for every processor is the result, result is an empty list, upto is integer 0. call the method tag_re.finditer with an argument self.template_string, for every match in result, call the method match.span, substitute the result for start an end, respectively. if start is greater than upto, call the method self.create_token with 3 arguments: self.template_string list elements from upto index to start index, tuple with 2 elements: upto and start and boolean False, append the result to result. substitute start for upto. call the method self.create_token with 3 arguments: self.template_string list elements from start index to end index, tuple with 2 elements: start and end and boolean False, append the result to result. substitute end for upto. substitute elements of self.template_string list from upto index to the end for last_lit. if last_bit is true, call the method create_token from the base class of the class DebugLexer, with 2 arguments: template_string and in_tag, substitute the result for token. assign self.origin, source to token.source. call the method self.source_error with 2 arguments: token.source and msg, return the result. e is an instance of TemplateSyntaxError class, created with an argument msg. substitute source for e.django_template_source. return an instance of DebugVariableNode, created with an argument contents. substitute token.source for node.source. call the method extend_nodelist with 3 arguments: nodelist, node and token, from the base class of the class DebugParser. remove the first element from self.command_stack, assign the result to command and source, respectively. if e doesnt have an 'django_template_source' attribute, substitute token.source for e.django_template_source. if e doesnt have an 'django_template_source' attribute, substitute token.source for e.django_template_source. if Exception, renamed to e, exception is caught, if e doesnt have an 'django_template_source' attribute, substitute node.source for e.django_template_source. call the method self.filter_expression.resolve with an argument context, substitute the result for output. call the function template_localtime with 2 arguments: output and use_tz set to context.use_tz, substitute the result for output. call the function localize with 2 arguments: output and use_l10n set to context.use_l10n, substitute the result for output. call the function force_text with an argument output, substitute the result for output. if UnicodeDecodeError exception is caught, if Exception, renamed to e, exception is caught, if e doesnt have an 'django_template_source' attribute, if not, import module random as random_module. from decimal import Decimal, InvalidOperation, Context and ROUND_HALF_UP into default name space. replace all occurrences of '\\' with '\\\\' in value, replace all occurrences of '"' with '\\"' in the previous result, decorator function register.filter with an argument string "escapejs". multiply 10 to the power of 200, with itself, substitute the result for pos_inf. multiply 10 to the power of 200, with 10 to the power of 200, negative, substitute the result for neg_inf. divide 10 to the power of 400 by 10 to the power of 400, substitute the result for nan. special_floats is an list with 3 elements, pos_inf, neg_inf and nan, all converted to strings. call the function force_text with an argument text, substitute the result for input_val. d is an instance of Decimal class created with an argument input_val. if UnicodeEncodeError exception is caught, if InvalidOperation exception is caught, if every input_val in special_floats, d is an instance of class Decimal, created with result of the function force_text, convert arg to an integer, substitute it for p. convert d into a integer, subtract d from it, substitute the result for m. if m is false and p is lesser than integer 0, call the method formats.number_format with 2 arguments, d converted to a integer and then to string, and integer 0, use the result as an argument for the call to the function mark_safe, return the result. if p equals integer 0, exp is an instance of Decimal, created with an argument integer 1. if not, instantiate class Decimal with string '1.0' as argument, divide it by product of instance of Decimal class created with integer 10, call the method d.as_tuple, substitute the result for tupl. sum absolute p with units an integer 1, substitute the result for prec. call the method d.quantize with 3 arguments: exp, ROUND_HALF_UP and instance of Context class created with prec as prec, call the method as_tuple on the result, substitute the result for sign, digits and exponent, respectively. append result of method six.text_type called with an argument digit to an list, for every digit in reversed order of digits, insert '.' to digits at negative exponent index. if sign is true, reverse element order of dicts, join them in a string, substitute the result for number. call the method formats.number_format with 2 arguments: number and absolute value of p, use the result as an argument for the call to the mark_safe function, return the result. if InvalidOperation exception is caught, for every i and line in enumerated iterable lines, concatenate string '%0', width and string "d. %s", format the previous string with i incremented by 1 and line, substitute the result for i-th element of lines. if not, for every i and line in enumerated iterable lines, concatenate string '%0', width and string "d. %s", format the previous string with i incremented by 1, call the function re.sub with 3 arguments: string "([a-z])'([A-Z])", lambda function with an argument m and return value, result of the m.group method called with an argument integer 0 converted into lowercase and result of the method value.title, substitute the result for t. call the function re.sub with 3 arguments: string "\d([A-Z])", lambda function with an argument m and return value, substitute arg converted into a integer for length. substitute arg converted into an integer for length. substitute arg converted into an integer for length. substitute arg converted into an integer for length. if safe is not None, substitute safe for value under the 'safe' key of kwargs dictionary. call the function _urlize with 3 arguments: value, nofollow set to boolean True, autoescape set to autoescape, call the function _urlize with 4 arguments: value, trim_url_limit as limit converted into an integer, nofollow as boolean True, if safe is true and arg is not equal to string ';', if autoescape is true, if TypeError or VariableDoesNotExist exceptions are caught, if TypeError or VariableDoesNotExist exceptions are caught, if IndexError exception is caught, if autoescape is true, substitute the result for data. if AttributeError exception is caught, if IndexError exception is caught, split arg by ':', for every x in result, if not, if autoescape is true, substitute conditional_escape for escaper. if not, escaper is an identity lambda function. substitute list_ for first_item and second_item, respectively. if second_item is an empty list, convert second item to an iterable, new_second_item is an empty list. for every sublist in second_item, call the function convert_old_style_list with an argument sublist, substitute the result for item and old_style_list. if old_style_list is false, extend new_second_item with item. if old_style_list is true, substitute new_second_item with second_item. return list with 2 elements: first_item and second_item, and old_style_list. indent contain tabs number of tab character. output is an empty list. i is integer 0. while i is smaller than list_length, substitute i-th element of list for title. sublist is an empty string. sublist_item is None. substitute title for sublist_item. title is an empty string. substitute (i+1)-th element of list_ for next_item. substitute next_item for sublist_item. increment i by integer 1. if sublist_item is true, call the function _helper with 2 arguments: sublist_item and tabs incremented by 1, substitute the result for sublist. sublist is an string '\n%s
      \n%s\n%s
    \n%s', where every '%s' is replaced with indent, sublist, indent and indent, respectively. result of the function force_text called with an argument title, and with sublist, append the string to output. increment i by 1. if Exception exception is caught, convert arg to an integer. if arg is smaller than integer 1, if IndexError exception is caught, if arg is None, if AttributeError exception is caught, if AttributeError exception is caught, if arg is None if AttributeError exception is caught, if AttributeError exception is caught, if arg is true, if arg is None call the function ugettext with string 'yes,no,maybe' as an argument, substitute the result for arg. convert bytes to floating point number, substitute it for bytes. call the function ungettext with 3 arguments: string "%(size)d byte", string "%(size)d bytes" and 0, '%(size)d' is replaced with 0, called with 2 arguments: value rounded to 1 decimal point and integer 1. move integer 1 left for 10 bits, substitute the result for KB. move integer 1 left for 20 bits, substitute the result for MB. move integer 1 left for 30 bits, substitute the result for GB. move integer 1 left for 40 bits, substitute the result for TB. move integer 1 left for 50 bits, substitute the result for PB. if bytes is smaller than KB, call the function ugettext with 3 arguments, string "%(size)d byte", string "%(size)d bytes" and bytes, call the function ugettext with an argument string "%s KB", substitute '%s' with the result of the call to the function, call the function ugettext with an argument string "%s MB", substitute '%s' with the result of the call to the function, call the function ugettext with an argument string "%s GB", substitute '%s' with the result of the call to the function, call the function ugettext with an argument string "%s TB", substitute '%s' with the result of the call to the function, filesize_number_format with result of division of bytes by TB as an argument, substitute the result for value. if not, call the function ugettext with an argument string "%s PB", substitute '%s' with the result of the call to the function, if ',' is not contained in arg, append arg to ',', substitute the result for arg. if Exception, renamed to e, exception is caught, return an string "Error in formatting: %s", replace '%s' with result of the function force_text, from itertools import groupby and cycle as itertools_cycle into default name space. from django.template.base import Node, NodeList, Template, Context, Library, TemplateSyntaxError, VariableDoesNotExist, substitute context.autoescape for old_setting. substitute old_setting for context.autoescape. if not, get the value under the 'csrf_token' key of the context dictionary, if it exists substitute the result for csrf_token, if not csrf_token is None. if csrf_token is true, if csrf_token equals string 'NOTPROVIDED', if not, call the function format_html with 2 arguments: string "", and csrf_token, return the result. if not, call the function warnings.warn with an argument string "A {% csrf_token %} was used in a template, but the context did not provide the value. This is usually caused by not using RequestContext.". substitute cyclevars for self.cyclevars. substitute variable_name for self.variable_name. substitute silent for self.silent. get the value under the self key of the context.render_context dictionary, substitute it for cycle_iter. output is an list with initial elements generated with call to the function pformat with an argument val, for every val in context. call the method context.push with an argument var set to output, with the result perform, substitute variables for self.vars. for every var in self.vars, child_nodelists is an tuple with 2 elements: strings 'nodelist_loop' and 'nodelist_empty'. substitute loopvars and sequence for self.loopvars and self.sequence, respectively. substitute is_reversed for self.is_reversed. substitute nodelist_loop for self.nodelist_loop. if nodelist_empty is None, if not, substitute nodelist_empty for self.nodelist_empty. if self.is_reversed is true, substitute reversed_text is an string ' reversed', if not, reversed_text is an empty string. if string 'forloop' is contained in context, substitute value under the the 'forloop' key of the context dictionary for parentloop. if not, parentloop is an empty dictionary. call the method context.push, with the result perform, if VariableDoesNotExist exception is caught, values is an empty list. if values is None, if values is None, if values has an attribute '__len__', convert values into a list, substitute it for value. if len_values is smaller than integer 1, nodelist is an empty list. reverse elements order of values. if num_loopvars is greater than integer 1, unpack is an boolean True, otherwise is an boolean False. loop_dict and value under the 'forloop' key of the context dictionary are dictionaries with an entry: parentloop for 'parentloop'. for every i and item in enumerated iterable values, substitute i for value under the 'counter0' key of the loop_dict dictionary. substitute i incremented by 1 for value under the 'counter' key of the loop_dict dictionary. subtract i from len_values, substitute the result for value under the 'revcounter' key of the loop_dict dictionary. subtract i from len_values, decrement the result by integer 1, substitute it for value under the 'revcounter' key of the loop_dict dictionary. if i is equal to integer 0, value under the 'first' key of the loop_dict dictionary is boolean True, otherwise it is False. if i is equal to len_values decremented by 1, value under the 'last' key of the loop_dict dictionary is boolean True, otherwise it is False. if unpack is true, len_item is integer 1. if not, if num_loopvars is not equal to len_item, call the function warnings.warn with 2 arguments: string "Need {0} values to unpack in for loop; got {1}. This will raise an zip self.loopvars and item is a list to tuples, convert the result to an dictionary, substitute it for unpacked_vars. if not, call the method context.update with an argument unpacked_vars. if not, if Exception, renamed to e, exception is caught, if e doesnt have an 'django_template_source' attribute, substitute node.source for e.django_template_source. if not, if pop_context is true, remove the first element of context. child_nodelists is a tuple with 2 initial elements: strings 'nodelist_true' and 'nodelist_false'. substitute varlist for self.varlist. call the method self._get_context_stack_frame with an argument context, substitute the result for state_frame. nodelist_true_output is None. compare_to is an list with elements generated by calling the var.resolve method with 2 arguments: context and boolean True, for every var in self._varlist. if not, call the method self.nodelist_true.render with an argument context, assign the result to compare_to and nodelist_true_output. if VariableDoesNotExist exception is caught, compare_to is None. if compare_to is not equal to value under the self key of state_frame. substitute compare_to for value under the state_frame dictionary under the self key. return nodelist_true_output, if true, if not call the method self.nodelist_true.render with an argument context and return the result. if string 'forloop' is contained in context, if not, child_nodelists is a tuple with 2 elements strings 'nodelist_true' and 'nodelist_false'. substitute var1 and var2 for self.var1 and self.var2, respectively. substitute negate for self.negate. if self.negate is true and val1 is not equal to val2, or if, self.negate is false and val1 equals val2, substitute conditions_nodelists for self.conditions_nodelists. for every node in nodelist, property decorator, return an instance of a NodeList class, created with arguments node, for every node in nodelist, for every condition and nodelist in self.conditions_nodelists, if condition is not None, call the method condition.eval with an argument context, substitute the result for match. if VariableDoesNotExist exception is caught, match is None. if not, if match is true, substitute var_name for self.var_name. if obj_list is None, if filepath starts with root, substitute filepath for self.filepath. substitute parsed for self.parsed. call the function self.filepath.resolve with an argument context, substitute the result for filepath. call the function include_is_allowed with an argument filepath, if it evaluates to false, return string "[Didn't have permission to include file]". if not, open filepath file in read mode, with file descriptor as fp, perform, read file fp, substitute the read data for output. if IOError exception is caught, output is an empty string. t is an instance of Template class, created with 2 arguments output and name set to filepath. if TemplateSyntaxError, renamed to e, exception is caught, return an string "[Included template had syntax error: %s]", where '%s' is replaced with e. if not, substitute format_string for self.format_string. call the function date with 2 arguments: result of the call to the function datetime.now with an argument tz set to tzinfo, call the method self.nodelist.render with an argument context, strip the result of the surrounding whitespaces, mapping is an dictionary with 8 initial entries: BLOCK_TAG_START for 'openblock', BLOCK_TAG_END for 'closeblock', substitute tagtype for self.tagtype. substitute view_name for self.view_name. substitute asvar for self.asvar. result of the call to the method v.resolve with an argument context, for result of the function smart_text called with 2 arguments k and string 'ascii'. call the method self.view_name.resolve with an argument context, substitute the result for view_name. url is an empty string. substitute the result for url. if NoReverseMatch exception is caught, call the function sys.exc_info with an argument exc_info. current_app as context.current_app, substitute the result for url. if NoReverseMatch exception is caught, call the function six.reraise with unpacked list exc_info as an argument. if not, if not, substitute content for self.content. substitute val_expr for self.val_expr. substitute max_expr for self.max_expr. substitute max_width for self.max_width. substitute asvar for self.asvar. call the method self.max_expr.resolve with an argument context, substitute the result for max_value. call the method self.max_width.resolve with an argument context, convert the result to an integer and substitute it for max_width. if VariableDoesNotExist exception is caught, convert max_value into an floating point number, substitute it for max_value. divide value by max_value, multiply the result with max_width, substitute it for ratio. round up radio, convert it to an integer and the convert it to a string and substitute the result for result. if ZeroDivisionError exception is caught, if not, if extra_context is true, substitute it for self.extra_context, if not self.extra_context is an empty dictionary. if name is true, for every key and val in return value of the function six.iteritems called with an arguments self.extra_context. call the method context.push with an argument unpacked dictionary values, with the result as an argument, if arg is not string 'on' or 'off', return an instance of AutoEscapeControlNode with 2 arguments: boolean exception arg equals to string 'on', and nodelist. if as_form is true, append the results into a list, substitute it for value. node is an instance CycleNode class, created with values,name and silent set to silent. if not, append the results into a list, substitute it for value. node is an instance of CycleNode class, created wiht an argument values. split into two parts token.contents by None, substitute the parts for _ and rest, respectively. if every filter_name in strings 'escape' or 'safe', return a class instance FilterNode, called with an arguments filter_expr and nodelist. if index is negative inter 3, if is_reversed, substitute it for in_index, if not, in_index is negative integer 2. joined into a string, separated by whitespaces, substitute the result for loopvars. for every var in loopvars, if var is false or whitespaces are contained in var, if token.contents equals string 'empty', if not, nodelist_empty is None. return an instance of ForNode class, created with 5 arguments: loopvars, sequence, is_reversed, nodelist_loop and nodelist_empty. if token.contents equals a string 'else', if not, nodelist_false is an instance of NodeList class. return an instance of IfEqualNode class, created with 5 arguments: val1, val2, nodelist_true, nodelist_false and negate. substitute text for self.text. substitute TemplateSyntaxError for error_class. conditions_nodelists is a list containing tuple with 2 elements condition and nodelist. if token.contents equals string 'else', if token.contents doesn not equals a string 'endif', raise an AssertionError exception, return an instance of IfNode class, created with an argument conditions_nodelists. if token.contents equals string 'else', if not, nodelist_false is an instance of NodeList. substitute the list of results for values. return an instance of a class IfChangedNode, created with 3 arguments: nodelist_true, nodelist_false and unpacked list values. if not, return an instance of a SsiNode class, created with 2 arguments: filepath and parsed. call the function get_library with an argument taglib, substitute the result for lib. if InvalidTemplateLibrary, renamed to e, exception is caught, where '%s' is replaced with taglib and e. if not, temp_lib is an instance of Library class. if name is contained in lib.tags, substitute value under the name key of the lib.tags dictionary for value under the name key of the temp_lib.tags dictionary. if name is contained in lib.filters. substitute value under the name key of the lib.filters dictionary for value under the name key of the temp_lib.filters dictionary. substitute value under the name key of the lib.filters dictionary for value under the name key of the temp_lib.filters dictionary. if not, if not, call the function get_library with an argument taglib, substitute the result for lib. if InvalidTemplateLibrary, renamed to e, exception is caught, return an instance of a NowNode class, created with an argument format_string. parser.compile_filter, substitute the result for expression. return an instance of a RegroupNode class, created with 3 arguments target, expression and var_name. asvar is None. call the method kwarg_re.match with an argument bit, substitute it for match. if match is true, if name is true, if not, call the method nodelist.render with an argument, an instance of Context class, use the result as an argument for the creation of, asvar is None. if as_ is not equal to string 'as', if not, if extra_context is false, where '%r' is replaced with first element of bits. if remaining_bits is true, return an instance of a class WithNode, created with 4 arguments: None, None, nodelist and extra_context as extra_context. template_source_loaders is None. call the method self.load_template with 2 arguments: template_name and template_dirs, return the result. call the method self.load_template_source with arguments template_name and template_dirs, assign the result to source and display_name. call the function make_origin with 4 arguments: display_name, self.load_template_source, template_name and template_dirs, call the function get_template_from_string with 3 arguments: source, origin and template_name, substitute the result for template. if TemplateDoesNotExist exception is caught, return an instance of LoaderOrigin class, created with 4 arguments: display_name, loader, name and dirs. if not, substitute first element of loader for loader and loader without the first element for args. if not, call the function import_string with an argument loader, substitute the result for TemplateLoader. if TemplateLoader has an attribute 'load_template_source', if not, raise an ImproperlyConfigured exception with an argument string "Error importing template source loader %s - can't pass arguments to call the function warnings.warn with an argument string "Your TEMPLATE_LOADERS setting includes %r, but your Python installation if not, if not, raise an ImproperlyConfigured with an argument string 'Loader does not define a "load_template" callable template source loader'. use global variable template_source_loaders. if template_source_loaders is None, loaders is an empty list. call the function find_template_loader with an argument loader_name, substitute the result for loader. if loader is not None, put loaders elements in a tuple, substitute it for template_source_loaders. for every loader in template_source_loaders, call the function loader with 2 arguments name and dirs, substitute the result for source and display_name, respectively. call the function make_origin with 4 arguments: display_name, loader, name and dirs, return a tuple containing 2 elements: source and previous result. if TemplateDoesNotExist exception is caught, call the function find_template with 2 arguments: template_name and dirs, substitute the result for template and origin. if template has an attribute 'render', call the function get_template_from_string with 3 arguments: template, origin and template_name, substitute the result for template. return an instance of Template class, created with 2 arguments: source, origin and name, return the result. call the function select_template with 2 arguments: template_name, dirs, substitute the result for t. if not, call the function get_template with 2 arguments: template_name and dirs, substitute the result for t. if context_instance is false, if dictionary is false, call the method context_instance.push with an argument dictionary, with the result perform, if template_name_list is false, not_found is an empty list. for every template_name in template_name_list, call the function get_template with 2 arguments template_name and dirs, return the result. if TemplateDoesNotExist, renamed to e, exception is caught, BLOCK_CONTEXT_KEY is a strign 'block_context'. convert elements of defaultdict to list, substitute it for self.blocks. call the function six.iteritems with an argument blocks, for every name and block in result, get the value under the name key of self.blocks dictionary, insert to it block at the beginning. if IndexError exception is caught, if IndexError exception is caught, get value under the BLOCK_CONTEXT_KEY key of context.render_context dictionary, substitute it for block_context. call the context.push method, with the result, perform, if block_context is None, if not, call the method block_context.pop with an argument self.name, assign the result to push and block. if block is None, convert self to a tuple, call the result with 2 arguments: block.name and block.nodelist, substitute the result for block. substitute context for block.context. substitute block for value under the 'block' key of context dictionary. call the method block.nodelist.render with an argument context, substitute the result for result. if push is not None, call the method block_context.push with 2 arguments: self.name and push. substitute self.context.render_context for render_context. if BLOCK_CONTEXT_KEY is contained in render_context and call to the method get_block with an argument self.name from the object, substitute parent_name for self.parent_name. substitute template_dirs for self.template_dirs. self.blocks is a dictionary with elements: n for n.name, for every n in return value of the method nodelist.get_nodes_by_type, return an string '', where '%s' is replaced with self.parent_name.token. call the method self.parent_name.resolve with an argument context. if parent is false, append string " Got this from the '%s' variable." to error_msg, where '%s is replaced with self.parent_name.token. if parent has an attribute 'render', call the function get_template with an argument parent, return the result. call the method self.get_parent with an argument context, substitute the result for compiled_parent. if BLOCK_CONTEXT_KEY is not contained in context.render_context, value under the BLOCK_CONTEXT_KEY key of context.render_context dictionary is BlockContext class instance. get the value under the BLOCK_CONTEXT_KEY key of the context.render_context dictionary, substitute it for block_context. call the method block_context.add_blocks with an argument self.block. for every node in compiled_parent.nodelist, blocks is a dictionary with elements: n for n.name, for every n in return value of the method, compiled_parent.nodelist.get_nodes_by_type, called with an argument BlockNode. call the method block_context.add_blocks with an argument blocks. call the method compiled_parent._render with an argument context, return the result. substitute template for self.template. remove kwargs dictionary entry under the 'extra_context' key, if it exists substitute it for self.extra_context, if not self.extra_context is an empty dictionary. remove kwargs dictionary entry under the 'isolated_context' key, if it exists substitute it for self.isolated_context, call the method self.template.resolve with an argument context, substitute the result for template. get 'render' attribute of template object, if it is callable, call the method get_template with an argument template, substitute the result for template. values is an dictionary with entries: return value of the method var.resolve with an argument context for name, call the method context.new with an argument values, use it as an argument for the call to the method template.render, return the result. call the method context.push with unpacked dictionary values as an argument, with the result perform, if Exception exception is caught, if AttributeError exception is caught, acceptable_endblocks is a tuple with 2 elements: string 'endblock' and 'endblock %s', where '%s' replaced with block_name. if endblock.contents is not contained in acceptable_endblocks, call the method parser.invalid_block_tag with 3 arguments: endblock, 'endblock' and acceptable_endblocks. return an instance of a BlockNode class, created with 2 arguments: block_name and nodelist. call the method nodelist.get_nodes_by_type with an argument ExtendsNode, if it evaluates to true, where '%s' is replaced with first element of bits. return an instance of ExtendsNode with 2 arguments nodelist and parent_name. where '%r' is replaced with first element of bits. options is an empty dictionary. while remaining_bits is true, remove first element from remaining_bits, substitute the result for option. if option is contained in options, where '%r' is replaced with options. if option equals a string 'with', if not, if not, isolated_context is boolean False. get the value under the 'width' key of the options dictionary, if it exists, substitute it for namemap, if not namemap is an empty dictionary. return an instance of IncludeNode class, created with 3 arguments: return value of the method parser.compile_filter, if six.PY2 is true, call the function sys.getfilesystemencoding, if it evaluates to true, substitute the result for fs_encoding, if not, call the function sys.getdefaultencoding and substitute the result for fs_encoding. app_template_dirs is an empty list. if six.PY2 is true, call the function template_dir.decode with an argument fs_encoding, substitute the result for template_dir. call the function calculate_app_template_dirs, substitute the result for app_template_dirs. if template_dirs is false, substitute app_template_dirs for template_dirs. for every template_dir in template_dirs, if UnicodeDecodeError exception is caught, call the method self.get_template_sources with 2 arguments template_name and template_dirs, for every filepath in the result, open the file named filepath in read mode, with file descriptor renamed to fp perform, previous result and filepath. if IOError exception is caught, substitute loaders for self._loaders. property decorator. cached_loaders is an empty list. for every loader in self._loaders, substitute cached_loaders for self._cached_loaders. if template_dirs is true, join template_dirs elements into a string, separated by '|', use it as an argument for the call to the function force_bytes, use the result as the argument for the call to the function hashlib.sha1, call the hexdigest method on the result, join template_name and previous final result into a string, separated with '-', return it. if not, if KeyError exception is caught, result is None. call the function loader with arguments name and dirs, assign the result to template and display_name, respectively. if TemplateDoesNotExist exception is caught, if not, result is an tuple with 2 elements: template and return value of the function make_origin called with 4 arguments: display_name, loader, name and dirs. if result is true, if not, if template_tuple is contained in TemplateDoesNotExist, call the method self.find_template with 2 argumetns: template_name and template_dirs, assign the result to template, origin, respectively. if template doesnt have a 'render' attribute, call the function get_template_from_string with 3 arguments: template, origin and template_name, substitute the result for template. if TemplateDoesNotExist exception is caught, from pkg_resources import resource_string into default name space. resource_string is None. if resource_string is not None, is_usable is boolean True, otherwise is_usable is boolean False. if resource_string is not None, concatenate string 'templates/' and template_name, substitute the result for pkg_name. if Exception exception is caught, if six.PY2 is true, call the method resource.decode with an argument settings.FILE_CHARSET, substitute the result for resource. return a tuple with 2 elements: resource and string 'egg:%s:%s', where '%s' is replaced with app_config.name and pkg_name, respective. if template_dirs is false, for every template_dir in template_dirs, if UnicodeDecodeError exception is caught, tried is an empty list. call the method self.get_template_sources with 2 arguments template_name and template_dirs, for every filepath in the result, open the file named filepath in read mode, with file descriptor renamed to fp perform, previous result and filepath. if IOError exception is caught, if tried is true, err_msg is a string "Tried %s", where '%s' is replaced with tried. if not, error_msg is a string "Your TEMPLATE_DIRS setting is empty. Change it to point to at least one template directory.". rendering_attrs is a list containing 3 strings: 'template_name', 'context_data' and '_post_render_callbacks'. call the __getstate__ method from the base class of the class SimpleTemplateResponse, substitute the result for obj_dict. for every attr in self.rendering_attrs, if attr is contained in obj_dict, delete entry under the attr key of obj_dict dictionary. call the method loader.select_template with an argument template, return the result. call the method loader.get_template with an argument template, return the result. if not, if not, property decorator, call the method template.render with an argument context, substitute the result for content. if not, for every post_callback in self._post_render_callbacks, call the function post_callback with an argument retval, substitute the result for newretval. if newretval is not None, substitute newretval for retval. property decorator, property decorator, return the content field of the base class of the class SimpleTemplateResponse. content.setter decorator, append list with 2 strings: '_request' and '_current_app' to SimpleTemplateResponse.rendering_attrs, substitute the result for rendering_attrs. substitute current_app for self._current_app. call the __init__ method from the base class of the class TemplateResponse, with 4 arguments: template, context, content_type, status. id is None. first and second are None. substitute bp for lbp. if Exception exception is caught, substitute bp for lbp. if Exception exception is caught, OPERATORS is an dictionary with 12 initial entries: result of the function inflix called with 2 arguments, integer 6, id is a string "literal". lbp is integer 0. lbp is an integer 0. EndToken is an instance of EndToken class. mapped_tokens is an empty list. i is integer 0. while i is smaller than l, substitute i-th element of tokens for token. if token equals a string "not" and i incremented by 1 is lesser than l, and element of tokens at i incremented by 1 index equals a string "in", token is a string "not in". increment i by integer 1. increment i by integer 1. substitute mapped_tokens for self.tokens. substitute OPERATORS dictionary element under token key for op. if KeyError and TypeError exceptions are caught, if not, if not, call the method self.expression, substitute the result for retval. if self.current_token is not EndToken, call the method t.nud with an argument self, substitute the result for left. while rbp is smaller than self.current_token.lbp, call the method t.led with 2 arguments left and self. from lib2to3 import fixer_base into default name space. from lib2to3.fixer_util import find_indentation, Name, syms and touch_import into default name space. from lib2to3.pgen2 import token into default name space. from lib2to3.pytree import Leaf and Node into default name space. substitute value under the "unifunc" key of the results dictionary for unifunc. strfunc is an instance of a class Name, created with 2 arguments: string "__str__" and prefix as unifunc.prefix. call the method unifunc.replace with an argument strfunc. call the method node.clone, substitute the result for klass. call the method find_indentation with an argument node, append the result to newline, substitute the result for klass.prefix. decorator is an instance of class Node, created with 2 arguments: instance of Leaf class created with 2 arguments: token.AT and "@', and instance of Name class created with an argument string 'python_2_unicode_compatible'. decorated is an instance of class Node, created with 3 arguments: syms.decorated, list with 2 arguments: decorator and klass, and prefix as node.prefix. call the method node.replace with an argument decorated. call the function touch_import with 3 arguments: string 'django.utils.encoding', string 'python_2_unicode_compatible' and decorated. substitute WindowsError for WindowsError. if NameError exception is caught, if six.PY2 is true, call the function sys.getfilesystemencoding if it evaluates to true, substitute its result for fs_encoding, substitute abspath for abspathu. if not, call the function force_text with an argument base, substitute the result for base. paths is a list containing results of the function force_text called with an argument p, for every p in paths. join base an unpacked list paths into a string, get the absolute path in unicode representation of the result, substitute the result for final_path. get the unicode representation of the absolute path of base, substitute it for base_path. if return value of the function normcase called with an argument final_path doesnt starts with result of the function normcase, if exctype is not WindowsError or string 'Access is denied' is not contained in value converted into a string, call the function os.stat with an argument path, perform bitwise and on 2 operands st_mode field of the result and stat.S_IREAD, call the function tempfile.mkdtemp, substitute the result for tmpdir. make a system symbolic link between original_path and symlink_path. if OSError, NotImplementedError or AttributeError exceptions are caught, if not, finally perform, instantiate Archive class with an argument path, with it renamed to archive, perform, call the method archive.extract with an argument to_path. static method, cls is None. substitute file for filename. if not, substitute file.name for filename. if AttributeError exception is caught. substitute the result for base and tail_ext. get the value under the tail_ext key of the extension_map dictionary, substitute it for cls. if cls is false, get the value under the ext key of the extension_map dictionary, substitute it for cls. if cls is false, call the method self._archive.extract with an argument to_path. if not, common_prefix is None. if prefix is false, substitute prefix for common_prefix. call the method tarfile.open with an argument file, substitute the result for self._archive. members is a list with elements member for every member in the result of the function self._archive.getmembers, only if member.name is not equal to string 'pax_global_header'. call the method self.has_leading_dir with an argument list, with elements x.name for every x in members, substitute the result for leading. for every member in members, substitute member.name for name. if leading is true, if member is a directory, if not, call the method self._archive.extractfile with an argument member, substitute the result for extracted. if KeyError or AttributeError, renamed to exc, exceptions are caught, print a string "In the tar file %s the member %s is invalid: %s", where '%s' is substituted with: name, member.name and exc, respectively. if not, open filename file in write mode, with the file descriptor renamed to outfile, perform, call the method shutil.copyfileobj with 2 arguments: extracted and outfile. finally, if extracted is true, call the method extracted.close. call the method zipfile.ZipFile with an argument self, substitute the result for self._archive. call the method self._archive.namelist, substitute the result for namelist. call the method self.has_leading_dir with an argument namelist, substitute the result for leading. for every name in namelist, if leading is true, if filename ends with '/' or with '\\', if not, open filename file in write mode, with the file descriptor renamed to outfile, perform, extension_map is a dictioanry with 6 initial elntries: TarArchive for '.tar', TarArchive for '.tar.bz2', TarArchive for '.tar.gz', termios is None. call the method pyinotify.INotifyWrapper.create, on the return value call the inotify_init method, substitute the result for fd. if fd is greater or equal to integer 0. FILE_MODIFIED is integer 1. I18N_MODIFIED is integer 2 _mtimes is an empty dictionary. _win is a tuple containing 1 initial boolean: True is sys.platform equals to string "win32", False otherwise. _error_files is an empty list. _cached_modules is an empty set. _cached_filenames is an empty list. declare that we use global variables cached_modules and _cached_filenames in this function. module_values is a set created from the elements of sys.modules.values method return value. if _cached_modules equals to module_values, if only_new is true, if not, subtract _cached_modules from module_values, assign the result to new_modules. create the list of paths from which filename module was included for every filename in new_modules, only is filename has '__file__' attribute, substitute the resulting list for new_filenames. for every basedir in basedirs, for every dirpath, dirnames and locale_filenames in directory tree starting at the basedir directory. for every filenam in locale_filenames, if filename ends with string '.mo', if only_new is True, substitute new_filenames for filelist. if not, sum _cached_filenames, new_filenames and _error_files, store the result in filelist. filenames is an empty list. for every filename is filelist, if filename is empty, if filename ends with string ".pyc" or it ends with ".pyo", truncate the last element of filename. truncate last 9 elements of filename and append it string ".py". add elements from new_modules set to _cached_modules set. append new_filenames to _cached_filenames. gettext._translations is an empty dictionary. trans_real._translations is an empty dictionary. trans_real._default is None. call the threading.local method, assign the result to trans_real._active. modified_code is None. EventHandler.modified_code is I18N_MODIFIED. if not, EventHandler.modified_code is FILE_MODIFIED. call the pyinotify.WatchManager method, assign the result to wm. call the method pyinotify.Notifier with wm and EventHandler() as arguments, assign the result to notifier. if sender is true and sender attribute 'handles_files' is also True, perform the bitwise or operation on the next 6 operands pyinotify.IN_MODIFY pyinotify.IN_DELETE, pyinotify.IN_ATTRIB, call the method wm.add_watch with path and mask as arguments. call the method request_finished.connect with argument update_watch. call the method update_watch. call the method notifier.check_events with argument timeout set to None. call the method notifier.read_events. call the method notifier.process_events. call the method notifier.stop. return EventHandler.modified_code. use the global variables _mtimes and _win in this function. for every filename in gen_filenames(), call the os.stat function with argument filename, store the return value in stat. substitute stat.st_mtime for mtime. if _win is true, decrement mtime by stat.st_ctime. if filename is not contained in _mtimes, substitute mtime for the value under the filename key of _mtimes dictionary. if mtime is different than the value of dictionary _mtimes under the key filename, _mtimes is an empty dictionary. remove the first occurrence of the filename value in the _error_files list. if filename ends with string '.mo' return I18N_MODIFIED, otherwise return FILE_MODIFIED. if ImportError, IndentationError, NameError, SyntaxError, TypeError or AttributeErrorexception is caught, call the sys.exc_info function, assign the result to et, ev and tb, respectively. if 'filename' attribute of ev is None, call the traceback.extract_tb method with argument tb, substitute the first element of last row of the result to filename. if not, substitute ev.filename for filename. if filename is not contained in _error_files, if termios is true, substitute sys.stdin for fd. evaluate the fd.isatty method, if the result is true, call the method termios.tcgetattr with argument fd, substitute the result for attr_list. if fourth element of attr_list and termios.ECHO are both true, perform binary or for operands: fourth element of_attr_list and termios.ECHO, store the result in fourth element of attr_list. if signal has an attribute 'SIGTTOU', call the signal.signal method with signal.SIGTTOU and signal.SIG_IGN as arguments, store the result in old_handler. if not, old_handler is None. call the method termios.tcsetattr with fd, termios.TCSANOW and attr_list, as arguments. if old_handler is not None, call the method signal.signal with signal.SIGTTOU and old_handler, as arguments. call the function ensure_echo_on. if USE_INOTIFY is true, substitute inotify_code_changed for fn. if not, substitute code_changed for fn. while RUN_RELOADER is true. assign the return value of the function fn to change. if change equals to FILE_MODIFIED, call the function sys.exit with argument integer 3. call the function reset_translations. call the function time.sleep with an argument integer 1. in string '-W%s' replace '%s' with o for every o in sys.warnoptions, put the result into a list, append the list to a list containing sys.executable, append sys.argv to the end of the resulting list, substitute the result for args. if sys.platform equals to string "win32", if exit_code is not equal to integer 3. call the function reloader_thread. if KeyboardInterrupt exception is caught, if not, call the function restart_with_reloader, substitute the return value for exit_code. if exit_code is lesser than integer 0, if not, call the function sys.exit with argument exit_code. if KeyboardInterrupt exception is caught, from _systemrestart import SystemRestart into default name space. call the function thread.start_new_thread with main_func and args as arguments. if return value of the code_changed function is true, call the function time.sleep with argument integer 1. if sys.platform starts with string 'java', substitute jython_reloader for reloader. if not, substitute python_reloader for reloader. call the function check_errors with argument main_func, substitute the result for wrapped_main_func. BASE2_ALPHABET is a string '01'. BASE16_ALPHABET is a string '0123456789ABCDEF'. BASE56_ALPHABET is a string '23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'. BASE36_ALPHABET is a string '0123456789abcdefghijklmnopqrstuvwxyz'. BASE62_ALPHABET is string '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'. append string '-_' to the BASE62_ALPHABET, substitute it for BASE64_ALPHABET. decimal_digits is a string '0123456789'. substitute sign for self.sign. substitute digits for self.digits. if neg is true, if neg is true, convert number to string, if first element equals to sign, convert number to a string, truncate first element. neg is integer 1. if not, neg is integer 0. x is integer 0. for every digit in number coverted to a string, if x equals to integer 0, substitute first element of to_digits for res. if not, res is an empty string. while x is greater than zero, increment res by element of to_digit at the digit index. return neg and res. call the BaseConverter function with BASE2_ALPHABET as argument, store the result in base2. call the BaseConverter function with BASE16_ALPHABET as argument, store the result in base16. call the BaseConverter function with BASE36_ALPHABET as argument, store the result in base36. call the BaseConverter function with BASE56_ALPHABET as argument, store the result in base56. call the BaseConverter function with BASE62_ALPHABET as argument, store the result in base62. call the BaseConverter function with BASE64_ALPHABET and sign set to '$' as arguments, store the result in base64. compile regular expression based on the string '\s*,\s*' and assign the result to cc_delim_re. split string s once, with '=' sign as a delimiter, assign the resulting list to the t. if not, if not, assign the result to cc. cc is a dictionary populated with items by calling function dictitem with el as argument, for every el in cc. if not, cc is an empty dictionary. if cc contains item 'max-age' and kwargs contains item 'max_age', convert to integer value of dictionary cc under the key 'max-age', if it is smaller than the value of dictionary kwargs under the key 'max_age', substitute kwargs value under the key 'max-age' by it. if cc contains item 'private' and kwargs contains item 'public', delete dictionary item 'private' from cc. delete dictionary item 'public' from cc. replace all occurrences of symbol '_' in string k with symbol '-', use new string as key to find a value in dictionary cc, replace this value with v. call the function dictvalue with el as argument for every el in values of dictionary cc, cc is a dictionary populated with items by calling function _to_tuple with el as an argument, for every el in split string cc_delim_re, with delimiter being the value of dictionary response under the key 'Cache-Control'. if cc contains item 'max-age', convert to integer the value of dictionary cc under the key 'max-age', and return it if cache_timeout equals to None, if cache_timeout is lesser than integer 0, substitute integer 0 for cache_timeout. if not, doctring if not, vary_headers is an empty list. existing_headers is a set of lowercase headers for every header in vary_headers. put every header in newheaders in a list, only if newheader converted to lowercase does not exist in existing_headers, existing_headers is a set containing lowercase strings header for every header in vary_headers. check if lowercase header_query exists is existing_headers, return the boolean result. call the function force_text, with the function get_current_timezone_name and errors set to string 'ignore' as arguments, replace the result for tz_name. call the method tz_name.encode with the arguments 'ascii' and 'ignore', call the method decode on the result with 'ascii' as argument, ctx is an hashlib object, for calculating hash function with md5 algorithm. for every header in headerlist, call iri_to_uri with return value of the request.build_absolute_uri method, us the result as the argument for the call to the force_bytes function, use the result as the argument for the call to the hashlib.mdb function, store the result in url. substitute the '%s' in string 'views.decorators.cache.cache_page.%s.%s.%s.%s' with key_prefix, method, call method request.build_absolute_uri, use the result as an argument for function call of iri_to_uri, use the result as an argument for function call of force_bytes, use the result as an argument for calling the method hashlib.md5, put the result in url. substitute the '%s' in string 'views.decorators.cache.cache_header.%s.%s' with key_prefix and result of the function call, if key_prefix is None, if cache is None, get the value of dictionary cache under the key cache_key, if key is not available return None, substitute it for headerlist. if header list is not None, if not, if key_prefix is None, if cache_timeout is None, if cache is None, headerlist is an empty list. convert string header to uppercase and replace all occurrences of '-' with '_', substitute it for header. if header equals a string 'ACCEPT_LANGUAGE' and is_accept_language_redundant is boolean True, call method sort on the headerlist. call the method cache.set, with cache_key, headerlist, cache_timeout as arguments. if not, call the method cache.set with cache_key, an empty list and cache_timeout as arguments. split string s once, with '=' as delimiter, substitute the result for t. __all__ is an list with an element 'luhn'. LUHN_ODD_LOOKUP is a tuple with 10 elements: integers 0, 2, 4, 6, 8, 1, 3, 5, 7 and 9. convert candidate to a string. for every c in reversed order of candidate, convert c into an integer, sum all the results and substitute the result for evens. for every c in candidate without the last element and in reversed order, convert c into an integer, use the result as an key to get the value from the LUHN_ODD_LOOKUP dictionary, sum all the results and substitute the result for odds. sum evens and odds, if the result is divisible by integer 10, return boolean True, if not return boolean False. random is an instance of random.SystemRandom class. if NotImplementedError exception is caught, call the function warnings.warn with an argument, if secret is None, call the function force_bytes with an argument key_salt, substitute the result for key_salt. call the function force_bytes with an argument secret, substitute the result for secret. call the method hashlib.sha1 with an argument secret appended to key_salt, call the method digest on the result, return the result. call the method hmac.new with 3 arguments: key, msg set to result of the function force_bytes with an argument value, if using_sysrandom is false, format string "%s%s%s" with 3 elements: result of the function random.getstate, result of the call the the function time.time, and settings.SECRET_KEY, call on it method encode with an argument string 'utf-8', use the result as an argument for the call to the method hashlib.sha256, call the method digest on the result, use the result as an argument for the call to the function random.seed. call the function random.choice with an argument allowed_chars, for every i in range of integers from 0 to lengths, join the results into a string, return it. if hmac has an attribute "compare_digest", call the function hmac.compare_digest with 2 arguments: result of the function force_bytes called with an argument val1, and result of the function force_bytes called with an argument val2, return the result. if not, result is an integer 0. zip val1 and va2 into list of tuples, for every x and y in the result, perform bitwise exclusive OR on 2 operands x and y, perform bitwise OR with 2 operands: previous result and result, substitute the result for result. if not, zip val1 and va2 into list of tuples, for every x and y in the result, perform bitwise exclusive OR on 2 operands integer representation of x and integer representation of y, call the function binascii.hexlify with an argument x, convert the result to base 16 integer, return the result. format string hex_format_string with x, call the method encode on the result with an argument string 'ascii', use the result as an argument for the call to the function binascii.unhexlify, return the result. if hashlib had an instance "pbkdf2_hmac", if digest is None, substitute hashlib.sha256 for digest. if dklen is false, dklen is None. call the function force_bytes with an argument password, substitute the result for password. call the function force_bytes with an argument salt, substitute the result for salt. call the function hashlib.pbkdf2_hmac with 5 arguments: field name of the result of the function digest, password, salt, iterations and dklen, return the result. if not, if iterations is lesser than integer 0, raise an error. if digest is false, substitute hashlib.sha256 for digest. call the function force_bytes with an argument password, substitute the result for password. call the function force_bytes with an argument salt, substitute the result for salt. call the function digest, substitute the filed digest_size of the result for hlen. if dklen is false, substitute hlen for dklen. bring intger 2 to integer 32, decrement the result by 1, multiply it with hlen, if dklen is greater than the previous result, divide negative dklen with hlen, substitute floored result for l. decrement l by integer 1, multiply it with hlen, subtract the result from dklen, substitute the result for r. hex_format_string is a string "%%0%ix" formated with hlen multiplied with integer 2. call the function digest twice, substitute the results for inner, outer, respectively. call the function digest with an argument password, call the method digest on the result, substitute the result or password. append the result to password. call the method password.translate with an argument hmac.trans_36, update inner dictionary with the result. call the method password.translate with an argument hmac.trans_5C, update outer dictionary with the result. call the method struct.pack with 2 arguments: bytes string '>I' and i, append the result to salt, substitute the result or u. result is an integer 0. for every j in range of integers from 0 to iterations converted to an integer, call the function inner.copy, substitute the result for dig1, call the function outer.copy, substitute the result for dig2. call the method dig1.update with an argument u. call the method dig1.digest, use the result as an argument for the call to the function dig2.update. call the method dig2.digest, substitute the result for u. call the function _bin_to_long with an argument u perform bitwise exclusive OR with 2 operands, previous result an result, substitute the result for result. call the function _long_to_bin with 2 arguments: result and hex_format_string, return the result. call the function F with an argument x, for every x in sequence of integers from 1 to l, not included, define the function become_daemon with 4 arguments: our_home_dir set to '.', out_log set to a string '/dev/null', close the process with an argument 0. if OSError, renamed to e, exception is caught, call the method sys.stderr.write with an argument string "fork #1 failed: (%d) %s\n", formated with e.errno and e.strerror. close the process with an argument 1. call the function os.umask with an argument umask. if OSError, renamed to e, exception is caught, call the method sys.stderr.write with an argument string "fork #2 failed: (%d) %s\n", formated with e.errno and e.strerror. open '/dev/null' file in read mode, substitute the result for si. open out_log flie in append mode with buffering size of input buffer, substitute the result for so. open err_log flie in append mode with buffering size of input buffer, substitute the result for se. call the method os.dup2 with 2 arguments: result of the method si.fileno and result of the method sys.stdin.fileno. call the method os.dup2 with 2 arguments: result of the method so.fileno and result of the method sys.stdout.fileno. call the method os.dup2 with 2 arguments: result of the method se.fileno and result of the method sys.stderr.fileno. substitute so and se for sys.stdout and sys.stderr. if not, call the method os.umask with an argument umask. call the method sys.stdin.close. call the method sys.stdout.close. call the method sys.stderr.close. if err_log is true, open err_log file in append mode with buffering size of the input buffer, substitute the result for sys.stderr. if not, sys.stderr is an instance of NullDevice class. if out_log is true, open out_log file in append mode with buffering size of the input buffer, substitute the result for sys.stdout. if not, sys.stdout is an instance of NullDevice class. call the function warnings.warn with 3 arguments: string '`MergeDict` is deprecated, use `dict.update()` instead.', RemovedInDjango19Warning and integer 2. substitute dicts for self.dicts. if KeyError exception is caught, if KeyError exception is caught, seen is an empty set. call the function six.iteritems with an argument dict_, for every item in the result, substitute first element of item for k. if k is contained in seen, add k to seen. substitute _iteritems for items. substitute _iterkeys for keys. substitute _itervalues for values. if not, substitute _iteritems for iteritems. substitute _iterkeys for iterkeys. substitute _itervalues for itervalues. substitute has_key for __contains__. substitute _iterkeys for __iter__. join printable representation of d into a string separated with ', ', for every d in self.dicts, substitute the result for dictreprs. return a string '%s(%s)' formated with self.__class__.__name__ and dictreprs. and unpacked dictionary kwargs. instance.keyOrder is an empty list. call the function warnings.warn with 3 arguments: string "SortedDict is deprecated and will be removed in Django 1.9.", if not, substitute __setitem__ filed of the base class of the class SortedDict for super_set. call the method popitem from the base class of the class SortedDict, substitute the result for result. remove first element of result from self.keyOrder dictionary. substitute _iteritems for items. substitute _iterkeys for keys. substitute _itervalues for values. if not, substitute _iteritems for iteritems. substitute _iterkeys for iterkeys. substitute _itervalues for itervalues. call the method six.iteritems with an argument dict_, for every k and v in the result, self.dict is an instance of OrderedDict class, created with arguments: tuples with 2 argument x and None, for every x in iterables, delete entry under item key of self.dict dictionary. if KeyError exception is caught, convert keys of dictionary self.dict into a iterable, return it. if KeyError exception is caught, if IndexError exception is caught, if memo is None, memo is an empty dictionary. call the method dict.__setitem__ with 3 arguments: result, result of the function copy.deepcopy, called with 2 arguments: key, call the method self.__dict__.copy, substitute the result for obj_dict. update self.__dict__ dictionary with obj_dict. if KeyError exception is caught, if val equals an empty list. if KeyError exception is caught, if default is None, if default_list is None, default_list is an empty list. substitute _iteritems for items. substitute _iterlists for lists. substitute _itervalues for values. if not, substitute _iteritems for iteritems. substitute _iterlists for iterlists. substitute _itervalues for itervalues. call the method copy.copy with an argument self, return the result. if not, substitute value under 'warning' key of kwargs dictionary for warning. delete element under 'warning' key of kwargs dictionary. if not, warning is a string 'ImmutableList object is immutable.'. substitute warning for self.warning. if not, substitute complain for __delitem__. substitute complain for __delslice__. substitute complain for __iadd__. substitute complain for __imul__. substitute complain for __setitem__. substitute complain for __setslice__. substitute complain for extend. substitute complain for insert. substitute complain for pop. substitute complain for remove. substitute complain for sort. substitute complain for reverse. substitute prefix for self.prefix. if not, if use_func is true, compile regex from a string '(?\d{4})-(?P\d{1,2})-(?P\d{1,2})$', substitute it for date_re. compile regex from raw string '(?P\d{1,2}):(?P\d{1,2})(?::(?P\d{1,2})(?:\.(?P\d{1,6})\d{0,6})?)?', substitute it for time_re. compile regex from raw string '(?P\d{4})-(?P\d{1,2})-(?P\d{1,2})[T ](?P\d{1,2}):(?P\d{1,2})' match regex date_re with value, substitute the result for match. if match is true, call the method match.groupdict, use the result as an argument for the call to the function six.iteritems, for every k and v in the previous result, add a key into a dictionary: v converted to an integer for k, substitute the resulting dictionary for kw. call the method datetime.date with an argument unpacked dictionary kw, return the result. match regex time_re with value, substitute the result for match. if match is true, call the method match.groupdict, substitute the result for kw. if value under the 'microsecond' key of the kw dictionary is true, left justify value under the 'microsecond' key of the kw dictionary, in the field of width 6, fill the rest with '0', substitute the result for value under the 'microsecond' key of the kw dictionary. update a dictionary with an entry v converted to an integer for k, for every k and v in result of the function six.iteritems, called with an argument kw, only if v is not None, substitute the result for kw. call the method datetime.time with an argument unpacked dictionary kw, return the result. match regex datetime_re with value, substitute the result for match. if match is true, call the method match.groupdict, substitute the result for kw. if value under the 'microsecond' key of the kw dictionary is true, left justify value under the 'microsecond' key of the kw dictionary, in the field of width 6, fill the rest with '0', substitute the result for value under the 'microsecond' key of the kw dictionary. remove entry under the 'tzinfo' key of the kw dictionary, substitute it for tzinfo. if tzinfo equals a string 'Z', substitute utc for tzinfo. substitute the result for offset_mins, otherwise offset_mins is integer 0. convert elements of tzinfo from indexes 1 to 3 to an integer, multiply it by integer 60 and increment it by offset_mins, substitute the result for offset. if first element of tzinfo equals '-', multiply offset by integer -1. call the function get_fixed_timezone with an argument offset, substitute the result for tzinfo. update a dictionary with an entry v converted to an integer for k, for every k and v in result of the function six.iteritems, called with an argument kw, only if v is not None, substitute the result for kw. substitute tzinfo for value under the 'tzinfo' key of the kw dictionary. call the method datetime.datetime with an argument unpacked dictionary kw, return the result. WEEKDAYS is an dictionary with 7 entries: result of the call to the function _ with an argument string 'Monday' for 0, result of the call to the function _ with an argument string 'Tuesday' for 1, result of the call to the function _ with an argument string 'Wednesday' for 2, result of the call to the function _ with an argument string 'Thursday' for 3, result of the call to the function _ with an argument string 'Friday' for 4, result of the call to the function _ with an argument string 'Saturday' for 5, and result of the call to the function _ with an argument string 'Sunday' for 6. WEEKDAYS_ABBR is an dictionary with 7 entries: result of the call to the function _ with an argument string 'Mon' for 0, result of the call to the function _ with an argument string 'Tue' for 1, result of the call to the function _ with an argument string 'Wed' for 2, result of the call to the function _ with an argument string 'Thu' for 3, result of the call to the function _ with an argument string 'Fri' for 4, result of the call to the function _ with an argument string 'Sat' for 5, and result of the call to the function _ with an argument string 'Sun' for 6. WEEKDAYS_REV is an dictionary with 7 entries: 0 for 'monday', 1 for 'tuesday', 2 for 'wednesday', 3 for 'thursday', 4 for 'friday', 5 for 'saturday' and 6 for 'sunday'. MONTHS is an dictionary with 12 entries: result of the call to the function _ with an argument string 'January' for 1, result of the call to the function _ with an argument string 'February' for 2, result of the call to the function _ with an argument string 'March' for 3, result of the call to the function _ with an argument string 'April' for 4, result of the call to the function _ with an argument string 'May' for 5, result of the call to the function _ with an argument string 'June' for 6, result of the call to the function _ with an argument string 'July' for 7, result of the call to the function _ with an argument string 'August' for 8, result of the call to the function _ with an argument string 'September' for 9, result of the call to the function _ with an argument string 'October' for 10, result of the call to the function _ with an argument string 'November' for 11, and result of the call to the function _ with an argument string 'December' for 12. MONTHS_3 is an dictionary with 12 entries: result of the call to the function _ with an argument string 'jan' for 1, result of the call to the function _ with an argument string 'feb' for 2, result of the call to the function _ with an argument string 'mar' for 3, result of the call to the function _ with an argument string 'apr' for 4, result of the call to the function _ with an argument string 'may' for 5, result of the call to the function _ with an argument string 'jun' for 6, result of the call to the function _ with an argument string 'jul' for 7, result of the call to the function _ with an argument string 'aug' for 8, result of the call to the function _ with an argument string 'sep' for 9, result of the call to the function _ with an argument string 'oct' for 10, result of the call to the function _ with an argument string 'nov' for 11, result of the call to the function _ with an argument string 'dec' for 12. MONTHS_3_REV is an dictionary with 12 entries: 1 for 'jan', 2 for 'feb', 3 for 'mar', 4 for 'apr', 5 for 'may', 6 for 'jun', 7 for 'jul', 8 for 'aug', 9 for 'sep', 10 for 'oct', 11 for 'nov' and 12 for 'dec'. MONTHS_AP is an dictionary with 12 entries: result of the function pgettext_lazy with 2 arguments: 'abbrev. month' and 'Jan.' for 1, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Feb.' for 2, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'March' for 3, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'April' for 4, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'May' for 5, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'June' for 6, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'July' for 7, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Aug.' for 8, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Sept.' for 9, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Oct.' for 10, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Nov.' for 11, result of the function pgettext_lazy with 2 arguments: strings 'abbrev. month' and 'Dec.' for 12, MONTHS_ALT is an dictionary with 12 entries: result of the function pgettext_lazy with 2 arguments: 'alt. month' and 'January' for 1, from datetime import date as real_date and datetime as real_datetime into default name space. decorator classmethod, call the function cls with 8 arguments: date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond, call the function data with 3 arguments: d.year, d.month and d.day, return the result. kw is a list with 3 elements: d.year, d.month and d.day. extend list kw with a list with 5 elements: d.hour, d.minute, d.second, d.microsecond and d.tzinfo. compile the regex from the raw string "((^|[^%])(%%)*%[sy])", substitute the result for _illegal_formatting. sites is an empty list. i is integer 0. endless loop, call the method text.find with 2 arguments: substr and i, substitute the result for j. if j equals to integer -1, add j and integer 1, substitute the result for i. if dt.year is greater than or equal to integer 1900, call the method strftime with an argument fmt, from the base class of the type of dt class. call the method _illegal_formatting.search with an argument fmt, substitute the result for illegal_formatting. if illegal_formatting is true, integer 0, appended to a string "strftime of dates before 1900 does not handle". substitute dt.year for year. subtract year from integer 2000, substitute the result for delta. floor the division of delta by integer 100 and delta by integer 400, sum the two results, multiply integer 6 by it, substitute the result for off. sum year and off, substitute the result for year. subtract year from integer 2000, divide the result by integer 28, floor the result, multiply it with 28 and increment by year, substitute the result for year. call the method dt.timetuple, substitute the result for timetuple. call the function time.strftime with 2 arguments: fmt and and timetuple without the first element, added to a tuple with an element year, substitute the result for s1. call the function _findall with 2 arguments: s1 and year converted into a string, substitute the result for sites1. call the function time.strftime with 2 arguments: fmt and and timetuple without the first element, added to a tuple with an element sum of year an integer 28, substitute the result for s2. call the function _findall with 2 arguments: s2 and sum of year and integer 28, converted into a string, substitute the result for sites2. sites is an empty list. if site is contained in sites1, if site is contained in sites2, substitute s1 for s. syear is a string "%04d" formated with dt.year. for every site in sites, concatenate first site elements of s, syear and elements of s from the site incremented by integer 4 index, substitute the result for s. call the method __new__ with an argument cls from the base class of the klass function. return a tuple with 3 elements: if path is true, path, in not, a string '%s.%s' formated with obj.__class__.__module__, and obj.__class__.__name__, first element of obj._constructor_args and second element of obj._constructor_args. klass.__new__ is a static method of the function __new__. substitute deconstruct for klass.deconstruct. from functools import wraps, update_wrapper and WRAPPER_ASSIGNMENTS into default name space. if instance is not None, call the method __get__ with 2 arguments: instance and owner, from the base class of the classonlymethod class, return the result. decorator decorator. decorator decorator. call the function update_wrapper with 2 arguments: _wrapper and dummy. call the function update_wrapper with 3 arguments: _dec, decorator and assigned as result of the function available_attrs, called with an argument decorator. if decorator has an attribute 'process_view', _dec.__name__ is a string 'method_decorator(%s)' formated with decorator.__name__. if not, _dec.__name__ is a string 'method_decorator(%s)' formated with decorator.__class__.__name__. call the function make_middleware_decorator with an argument middleware_class, return the result. call the function make_middleware_decorator with an argument middleware_class, call the result, return the new result. if not, if fh has an attribute a, for every a in WRAPPER_ASSIGNMENTS, put a into a tuple, return the resulting tuple. call the function middleware_class with 2 arguments: unpacked list m_args and unpacked dictionary m_kwargs, decorator function wraps with 2 arguments: view_func and assigned set to result of the function available_attrs, if middleware has an attribute 'process_request', if result is not None, if middleware has an attribute 'process_view', if result is not None, if Exception, renamed to e, exception is caught, if middleware has an attribute 'process_exception', if result is not None, if middleware has an attribute 'process_response', if middleware has an attribute 'process_response', if not, if middleware has an attribute 'process_response', substitute RemovedInDjango19Warning for RemovedInNextVersionWarning. substitute class_name for self.class_name. substitute old_method_name for self.old_method_name. substitute new_method_name for new_method_name. substitute deprecation_warning for self.deprecation_warning. renamed_methods is an tuple. call the method __new__ with 4 arguments: cls, name, bases and attrs, from the base class of the class RenameMethodsBase. call the method inspect.getmro with an argument new_class, for every base in the result, substitute base.__name__ for class_name. for every renamed_method in cls.renamed_methods, substitute first element of renamed_method for old_method_name. get the value under the old_method_name key of the base.__dict__ dictionary, substitute it for old_method. substitute second element of renamed_method for new_method_name. get the value under the new_method_name key of the base.__dict__ dictionary, substitute it for new_method. substitute third element of renamed_method for deprecation_warning. call the function warn_about_renamed_method with 2 arguments: class_name and unpacked list renamed_method, substitute the result for wrapper. if new_method is false and old_method is true, call the function warnings.warn with 3 arguments: string "`%s.%s` method should be renamed `%s`.", formated with 3 elements: class_name, old_method_name and new_method_name, deprecation_warning and integer 2. set new_method_name attribute of the base object to old_method. set old_method_name attribute of the base object to the result of the function wrapper called with an argument old_method. if old_method is false and new_method is true, set old_method_name attribute of the base object to the result of the function wrapper called with an argument new_method. compile regex from string '^[a-z_][a-z0-9_]*$' in case insensitive mode, substitute it for IDENTIFIER. match string s with regex IDENTIFIER, substitute the result for m. if m is false, substitute level for rv. if level is not contained in logging._levelNames, substitute value under level key of logging._levelNames dictionary for rv. if not, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, if type of result is ConvertingDict, ConvertingList or ConvertingTuple, compile a regex from raw string '^(?P[a-z]+)://(?P.*)$', substitute it for CONVERT_PATTERN. compile a regex from raw string '^\s*(\w+)\s*', substitute it for WORD_PATTERN. compile a regex from raw string '^\.\s*(\w+)\s*', substitute it for DOT_PATTERN. compile a regex from raw string '^\[\s*(\w+)\s*\]\s*', substitute it for INDEX_PATTERN. compile a regex from raw string '^\d+$', substitute it for DIGIT_PATTERN. value_converters is a dictionary with 2 entries: 'ext_convert' for 'ext' and 'cfg_convert' for 'cfg'. substitute __import__ for importer. self.config is an instance of ConvertingDict, called with an argument config. split s into parts by '.', substitute the result for name. remove first element from name, substitute the result for used. call the method self.importer with an argument used, substitute the result for found. for every frag in name. append '.' to frag, append the result to used. get frag attribute from found object, substitute it for found. if AttributeError exception is caught, call the method self.importer with an argument used. get frag attribute from found object, substitute it for found. call the method sys.exc_info, substitute the result without the first element for e and tb. substitute e and tb for v.__cause__ and v.__traceback__. match rest string with self.WORD_PATTERN regex, substitute the result for m. if m is None, if not, call the method m.end, slice list rest from previous result as starting index to the end, substitute the result for rest. substitute it for d. while rest is true, match rest string with self.DOT_PATTERN regex, substitute the result for m. if m is true, call the method m.groups, use the first element of the result as key for obtaining value from d dictionary, if not, match rest string with self.INDEX_PATTERN regex, substitute the result for m. if m is true, call the method m.groups, substitute the first element of the result for idx. match rest string with self.DIGIT_PATTERN regex, if it evaluates to false, substitute value under idx key of dictionary d for d. if not, convert idx to an integer, substitute it or n. substitute value under n key of dictionary d for d. substitute value under idx key of dictionary d for d. if m is true, call the method m.end, slice list rest from previous result as starting index to the end, substitute the result for rest. if not, if m is true, call the method m.groupdict, substitute the result for d. substitute value under the 'prefix' key of dictionary d, substitute it for prefix. remove self.value_converters dictionary element under prefix key, if it exists substitute it for converter, if not, converter is None. if converter is true, substitute value under the 'suffix' key of dictionary d, substitute it for suffix. get converter attribute from self object, substitute it for converter. remove config dictionary element under '()' key, substitute it for c. if c doesnt have an attribute '__call__' and types has an 'ClassType' attribute and type of c is not equal to types.ClassType, remove config dictionary element under '.' key, if it exists substitute it for props, if not, props is None. kwargs is a dictionary with elements: config dictionary element under k key for k, for every k in result of function valid_ident, if props is true, substitute self.config for config. if string 'version' is not contained in config, if config dictionary value under 'version' key is not equal to integer 1, get config dictionary element under 'incremental' key, if it exists substitute it for incremental, if not, incremental is boolean False. EMPTY_DICT is an empty dictionary. call the method logging._acquireLock. if incremental is true, get config dictionary element under 'handlers' key, if it exists substitute it for handlers, if not, handlers is EMPTY_DICT. if first two elements of sys.version_info equal to integers 2 ant 7, respectively, for every name in handlers, if name is not contained in logging._handlers, if not, substitute value under name key of logging._handlers dictionary for handler. substitute value under name key of handlers dictionary for handler_config. get handler_config dictionary element under 'level' key, if it exists substitute it for level, if not, level is None. if level is true, call the function _checkLevel with an argument level, use the result as an argument for the call to the function handler.setLevel. if StandardError, renamed to e, exception is caught, get config dictionary element under 'loggers' key, if it exists substitute it for loggers, if not, loggers is EMPTY_DICT. for every name in loggers, if StandardError, renamed to e, exception is caught, get config dictionary element under 'root' key, if it exists substitute it for root, if not, root is None. if root is true, if StandardError, renamed to e, exception is caught, if not, remove config dictionary element under 'disable_existing_loggers' key, if it exists substitute it for disable_existing, if not, disable_existing is boolean True. call the method logging._handler.clear. delete logging._handlerList list. get config dictionary element under 'formatters' key, if it exists substitute it for formatters, if not, formatters is EMPTY_DICT. for every name in formatters, call the method self.configure_filter with an argument value under name key of formatters dictionary, substitute the result for formatters dictionary value under name key. if StandardError, renamed to e, exception is caught, get config dictionary element under 'filters' key, if it exists substitute it for filters, if not, filters is EMPTY_DICT. for every name in filters, call the method self.configure_filter with an argument value under name key of filters dictionary, substitute the result for filters dictionary value under name key. if StandardError, renamed to e, exception is caught, get config dictionary element under 'handlers' key, if it exists substitute it for handlers, if not, handlers is EMPTY_DICT. sort elements of handlers, for every name in result, call the method self.configure_handler with an argument value under name key of handlers dictionary, substitute the result for handler. substitute name for handler.name. substitute handler for value under name key of handlers dictionary. if StandardError, renamed to e, exception is caught, substitute logging.root for root. convert root.manager.loggerDict into a list, substitute it for existing. sort elements of list existing. child_loggers is an empty list. get config dictionary element under 'loggers' key, if it exists substitute it for loggers, if not, loggers is EMPTY_DICT. for every name in loggers, if name is contained in existing, get the index of first occurrence of name in existing, substitute it for i. append '.' to name, substitute the result for prefixed. increment i by integer 1, substitute the result for i. while i is lesser than num_existing and first pflen elements of i-th element of existing equals prefixed, increment i by integer 1, substitute the result for i. remove name from existing. call the method self.configure_logger with 2 arguments: name and value under loggers dictionary key name. if StandardError, renamed to e, exception is caught, for every log in existing, get the value under log key of root.manager.loggerDict dictionary, substitute it for logger. if log is contained in child_loggers, substitute logging.NOTSET for logger.level. logger.handlers is an empty list. get config dictionary element under 'root' key, if it exists substitute it for root, if not, root is None. if root is true, call the method self.configure_root with an argument root. if StandardError, renamed to e, exception is caught, finally perform, call the method logging._releaseLock. if string '()' is contained in config, substitute config dictionary value under '()' key for factory. call the method self.configure_custom with an argument config, substitute the result for result. if TypeError, renamed to te, exception is caught, if string "'format'" is not contained in e converted into a string, remove config dictionary entry under 'format' key, substitute it for value under 'fmt' key of config dictionary. substitute factory for value under '()' key of config dictionary. call the method self.configure_custom with an argument config, substitute the result for result. if not, get config dictionary element under 'format' key, if it exists substitute it for fmt, if not, fmt is None. get config dictionary element under 'datefmt' key, if it exists substitute it for dfmt, if not, dfmt is None. call the method logging.Formatter with 2 arguments: fmt and dfmt, substitute the result for result. if string '()' is contained in config, call the method self.configure_custom with an argument config, substitute the result for result. if not, remove config dictionary element under 'name' key, if it exists substitute it for name, if not, name is an empty string. call the method logging.Filter with an argument name, substitute the result for result. for every f in filters, get the value under f key of dictionary under 'filters' key of self.config dictionary, use the result as an argument for the call to the method filterer.addFilter. if StandardError, renamed to e, exception is caught, remove config dictionary element under 'formatter' key, if it exists substitute it for formatter, if not, formatter is None. if formatter is true, get the value under formatter key of dictionary under 'formatters' key of self.config dictionary, substitute the result for formatter. if StandardError, renamed to e, exception is caught, remove config dictionary element under 'level' key, if it exists substitute it for level, if not, level is None. remove config dictionary element under 'filter' key, if it exists substitute it for filters, if not, filters is None. if string '()' is contained in config, remove config dictionary element under '()' key, substitute it for c. if c doesnt have an attribute '__call__', and types has an attribute 'ClassType', and type of c is not equal to types.ClassType, substitute c for factory. if not, substitute the result for klass. if klass is a subclass of logging.handlers.MemoryHandler base class and string 'target' is contained in config, get value under 'target' key of config dictionary, use it as a key to get the value from the dictionary, under the 'handlers' key of self.config dictionary, substitute the result for value under 'target' key of config dictioanry. if StandardError, renamed to e, exception is caught, formated with value under 'target' key of config dictionary and e. otherwise if klass is a subclass of logging.handlers.SMTPHandler and string 'mailhost' is contained in config, call the method self.as_tuple with an argument value under 'mailhost' key of config dictionary, substitute the result for value under 'mailhost' key of config dictionary. otherwise if klass is subclass of logging.handlers.SysLogHandler class, and string 'address' is contained in config, call the method self.as_tuple with an argument value under 'address' key of config dictionary, substitute the result for value under 'address' key of config dictionary. substitute klass for factory. kwargs is a dictionary created with tuples with 2 elements: k and value under k key of config dictionary, call the function factory with an argument unpacked dictionary kwargs, substitute the result for result. if TypeError, renamed to te, exception is caught, if "'stream'" is not contained in te converted into a string, call the function factory with an argument unpacked dictionary kwargs, substitute the result for result. if formatter is true, call the method result.setFormatter with an argument formatter. if level is not None, call function _checkLevel with an argument level, use the result as an argument for the method result.setLevel. if filters is true, call the method self.add_filters with 2 arguments: result and filters. for every h in handlers, call the method logger.addHandler with an argument: h-th element of value under 'handlers' key of self.config dictionary. if StandardError, renamed to e, exception is caught, get value under the 'level' key of the config dictioanry, if it exists substitute it for level, if not level is None. if level is not None, call the function _checkLevel with an argument level, use the result as an argument for the call to the method logger.setLevel. if incremental is true, for every h in elements of logger.handlers list, call the method logger.removeHandler with an argument h. get value under the 'handlers' key of the config dictioanry, if it exists substitute it for handlers, if not handlers is None. if handlers is true, call the method self.add_handlers with 2 arguments: logger and handlers. get value under the 'filters' key of the config dictioanry, if it exists substitute it for filters, if not filters is None. if filters is true, call the method self.add_filters with 2 arguments: logger and filters. call the method logging.getLogger with an argument name, substitute the result for logger. call the method self.common_logger_config with 3 arguments: logger, config and incremental. get value under the 'propagate' key of the config dictioanry, if it exists substitute it for propagate, if not propagate is None. if propagate is not None, substitute propagate for logger.propagate. call the method logging.getLogger, substitute the result for root. call the method self.common_logger_config with 3 arguments: root, config and incremental. substitute DictConfigurator for dictConfigClass. call the method dictConfigClass with an argument config, call the method configure on the result. from decimal import Decimal into default name space. call the method UnicodeDecodeError.__str__, with self as the argument, substitute the result for original. if field PY2 of the module six is boolean True, if string '__str__' is not contained in __dict__ field of klass, "to %s because it doesn't define __str__().", replace %s with string value of klass.__name__. substitute __str__ filed of klass for __unicode__ field of klass. return the result of the call to the function force_text, with s, encoding, string_only and errors as arguments. _PROTECTED_TYPES is a tuple containing next elements, six.integer_types, type of None, type of float, Decimal, detetime.datetime, if the boolean return vale of the call to the function is_protected_type(s) and string_onlys are boolean True, call the function six.text_type with s, encoding and errors as the arguments, substitute the result for s. if not, call the function six.text_type with s as an argument, substitute the result for s. call the function six.text_type with s as an argument, substitute result for s. if not, call the function six.text_type with return value of the function bytes(s), encoding and errors as the arguments, substitute the result for s. if not, call the method s.decode with encoding and errors as the arguments, substitute the result for s. if an exception of the type UnicodeDecodeError, renamed to e, is caught, if not, for every arg in s, call the function force_text with arg, encoding, strings_only and errors as arguments, evaluate the function force_bytes, with the arguments s, encoding, strings_only and errors, return the result. if encoding equals to string 'utf-8'. if not, evaluate the method s.decode with string 'utf-8' and errors as the arguments, on the result call the method encode with the arguments encoding and errors, return the result. if strings_only and boolean return value of the call to the function is_protected_type for argument s are boolean True, return six.text_type(s).encode(encoding, errors). if not, if the UnicodeEncodeError exception is caught, for every arg in s, evaluate the function force_bytes for the arguments arg, encoding, strings_only and errors, put the results in a list, join the list elements in a string separated by whitespace separator, return the string as the bytes string. evaluate the method six.text_type(s), on the result call the method encode with the arguments encoding and errors, return the result. if not, substitute smart_text for smart_str. substitute force_text for force_str. if not, substitute smart_bytes for smart_str. substitute force_bytes for force_str. substitute smart_text for smart_unicode. substitute force_text for force_unicode. if iri is not initialized, call the function quote with return value of the evaluated function force_bytes(iri), evaluate the function getdefaultlocale from the module locale, if second element of return value exists assign it to encoding, otherwise assign string 'ascii' to encoding. call the method lookup with the encoding as the argument. if the Exception exception is caught, substitute string 'ascii' for encoding. evaluate the function get_system_encoding(), substitute the return vale for DEFAULT_LOCALE_ENCODING. months is a tuple with 12 elements: strings 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov' and 'Dec'. days is a tuple with 7 elements: strings 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' and 'Sun'. call the method datetime_safe.new_datetime with an argument date, substitute the result for date. call the method date.weekday, use the result as an key to obtain the value from the days dictionary, substitute it for dow. decrement date.month by integer 1, use the result as an key to obtain the value from the months dictionary, substitute it for month. call the function date.strftime with an argument string '%s, %%d %s %%Y %%H:%%M:%%S ' formated with dow and month, substitute the result for time_str. if six.PY2 is true, call the method time_str.decode with an argument string 'utf-8', substitute the result for time_str. call the function is_aware with an argument date, if it evaluates to true, call the method date.tzinfo.utcoffset with an argument date, substitute the result for offset. multiply offset.days, integer 24 and integer 60, sum the result with floored result of dividing offset.seconds by integer 60, substitute the result for timezone. divide timezone by integer 60, substitute the quotient of the division for hour and reminder for minute. format string '%+03d%02d' with hour and minute, append it to time_str, return the result. if not, append string '-0000' to time_str, return the result. call the function datetime_safe.new_datetime with an argument date, substitute the result for date. call the function date.strftime with an argument string '%Y-%m-%dT%H:%M:%S', substitute the result for time_str. if six.PY2, call the method time_str.decode with an argument string 'utf-8', substitute the result for time_str. call the function is_aware with an argument date, if it evaluates to true, call the method date.tzinfo.utcoffset with an argument date, substitute the result for offset. multiply offset.days, integer 24 and integer 60, sum the result with floored result of division of offset.seconds, and integer 60, substitute the result for timezone. divide timezone by integer 60, substitute the quotient of the division for hour and reminder for minute. format string '%+03d:%02d' with hour and minute, append it to time_str, return the result. if not, d is an empty string. if date is not None, call the function datetime_safe.new_datetime with an argument date, on the result call the method strftime with an argument, define the method __init__ with 15 elements: self, title, link, description, language set to None, author_email set to None, called with 2 arguments: s and string_only as boolean True. if categories is true, categories is a list containing the results of the function force_text, called with an argument c, for every c in categories. if ttl is not None, call the function force_text with an argument ttl, substitute the result for ttl. self.feed is an dictionary with 13 initial entries, result of the function to_unicode called with an argument title for 'title', define the method add_item with 17 arguments: self, title, link, description, author_email set to None, author_name set to None, called with 2 arguments: s and string_only as boolean True. if categories is true, categories is a list containing the results of the function to_unicode, called with an argument c, for every c in categories. if ttl is not None, call the function force_text with an argument ttl, substitute the result for ttl. item is a dictionary with 15 initial entries: result of the function to_unicode called with an argument title for 'title', result of the function iri_to_uri called with an argument link for 'link', result of the function to_unicode called with an argument description for 'description', result of the function to_unicode called with an argument author_email for 'author_email', result of the function to_unicode called with an argument author_name for 'author_name', result of the function iri_to_uri called with an author_link link for 'author_link', pubdate for 'pubdate', updateddate for 'updateddate', result of the function to_unicode called with an comments author_name for 'comments', result of the function to_unicode called with an argument unique_id) for 'unique_id)', unique_id_is_permalink for 'unique_id_is_permalink', enclosure for 'enclosure', if true, categories is value for 'categories' key, if not, empty tuple is value for 'categories' key, result of the function to_unicode called with an argument item_copyright for 'item_copyright', ttl for 'ttl'. update dictionary item with an argument kwargs. s is an instance of StringIO class. latest_date is None. date_keys is a tuple with 2 arguments: strings 'updateddate' and 'pubdate'. for every date_key in date_keys, get the value under the date_key key of the item dictionary, substitute it for item_date. if item_date is true, if latest_date is None or item_date is greater than latest_date, substitute item_date for latest_date. if latest_date is true, return it, if not, call the method datetime.datetime.now and return the result. call the function iri_to_uri with an argument url, substitute the result for self.url. mime_type is a string 'application/rss+xml; charset=utf-8'. handler is an instance of SimplerXMLGenerator class, created with 2 arguments: outfile and encoding. call the method handler.startDocument. call the method handler.startElement with 2 arguments: string "rss" and result of the method self.rss_attributes. call the method handler.startElement with 2 arguments: string "channel" and result of the method self.root_attributes. call the method handler.endElement with an argument string 'rss'. return a dictionary with 2 elements: self._version for "version" and "http://www.w3.org/2005/Atom" for "xmlns:atom". call the method handler.startElement with 2 arguments: string "item" and result of the method self.item_attributes with an argument item. call the method self.add_item_elements with 2 arguments: handler and item. call the method handler.endElement with an argument string 'item'. call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'link' and value under the 'link' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'description' and value under the 'description' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'language' and value under the 'language' key of the self.feed dictionary. for every cat in value under the 'categories' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string "category" and cat. call the method handler.addQuickElement with 2 arguments: string 'copyright' and value under the 'feed_copyright' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'lastBuildDate' and result of the function rfc2822_date, call the method handler.addQuickElement with 2 arguments: string 'ttl' and value under the 'ttl' key of the self.feed dictionary. call the method handler.endElement with an argument string 'channel'. _version is a string "0.91". call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the item dictionary. call the method handler.addQuickElement with 2 arguments: string 'link' and value under the 'link' key of the item dictionary. if value under the 'description' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'description' and value under the 'description' key of item dictionary. _version is a string "2.0". call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the item dictionary. call the method handler.addQuickElement with 2 arguments: string 'link' and value under the 'link' key of the item dictionary. if value under the 'description' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'description' and value under the 'description' key of the item dictionary. if values under "author_name" and "author_email" keys of the item dictionary are both true, call the method handler.addQuickElement with an argument string "author", "%s (%s)", call the method handler.addQuickElement with 2 arguments: string 'author' and value under the 'author_email' key of the item dictionary. call the method handler.addQuickElement with 3 arguments: string 'dc:creator', value under the 'author_name' key of the item dictionary and dictionary with an entry: "http://purl.org/dc/elements/1.1/" for "xmlns:dc". if value under the 'pubdate' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'pubDate' and result of the function rfc2822_date, called with value under the 'pubdate' key of the item dictionary. if value under the 'comments' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'comments' and value under the 'comments' key of the item dictionary. if value under the 'unique_id' key of the item dictionary is not None, guid_attrs is an empty dictionary. covert to string value under the 'unique_id_is_permalink' key of the item dictionary, convert it to lowercase, substitute the result for value under the 'isPermaLink' key of the guid_attrs dictionary. call the method handler.addQuickElement with 3 arguments: string 'guid', value under the 'unique_id' key of the item dictionary, and guid_attrs. if value under the 'ttl' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'ttl' and value under the 'ttl' key of the item dictionary. if value under the 'enclosure' key of the item dictionary is not None, call the method handler.addQuickElement with 3 arguments: string 'title', an empty string and a dictionary with 3 entries: field url of the value under the 'enclosure' key of the item dictionary for 'url', field length of the value under the 'enclosure' key of the item dictionary for 'length', and field mime_type of the value under the 'enclosure' key of the item dictionary for 'type'. for every cat in value under the 'categories' key of the item dictionary, call the method handler.addQuickElement with 2 arguments: string 'category' and cat. mime_type is a string 'application/atom+xml; charset=utf-8'. ns is a string "http://www.w3.org/2005/Atom". handler is an instance of SimplerXMLGenerator class, created with 2 arguments: outfile and encoding. call the method handler.startDocument. call the method handler.startElement with 2 arguments: string 'feed' and result of the method self.root_attributes. call the method handler.endElement with an argument string 'feed'. and self.ns for "xmlns". if not, return a dictionary with an entry: self.ns for "xmlns". call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the self.feed dictionary. call the method handler.addQuickElement with 3 arguments: string 'link', an empty string and a dictionary with 2 entries: 'self' for 'rel' and value under the 'feed_url' key of self.feed dictionary for 'href'. call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'updated' and result of the function rfc3339_date, call the method handler.startElement with 2 arguments: string 'author' and an empty dictionary. call the method handler.addQuickElement with 2 arguments: string 'name' and value under the 'author_name' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'email' and value under the 'author_email' key of the self.feed dictionary. call the method handler.addQuickElement with 2 arguments: string 'uri' and value under the 'author_link' key of the self.feed dictionary. call the method handler.endElement with an argument string 'author'. call the method handler.addQuickElement with 2 arguments: string 'subtitle' and value under the 'subtitle' key of the self.feed dictionary. for every cat in value under the 'categories' key of the self.feed dictionary. call the method handler.addQuickElement with 3 arguments: string 'category', an empty string and a dictionary with an entry: call the method handler.addQuickElement with 2 arguments: string 'rights' and value under the 'feed_copyright' key of the self.feed dictionary. call the method handler.startElement with 2 arguments: string 'entry' and result of the function self.item_attributes, called with an argument item. call the method self.add_item_elements with 2 arguments: handler and item. call the method handler.endElement with an argument string 'entry'. call the method handler.addQuickElement with 2 arguments: string 'title' and value under the 'title' key of the item dictionary. call the method handler.addQuickElement with 3 arguments: string 'link', an empty string and a dictionary with 2 entries: value under the 'link' key of item dictionary for 'href' and "alternate" for "rel". if value under the 'pubdate' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'published' and result of the function rfc3339_date, called with an argument value under the 'pubdate' key of the item dictionary. if value under the 'updateddate' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'updated' and result of the function rfc3339_date, called with an argument value under the 'updateddate' key of the item dictionary. if value under the 'author_name' key of the item dictionary is not None, call the method handler.endElement with 2 arguments: string 'author' and an empty dictionary. call the method handler.addQuickElement with 2 arguments: string 'name' and value under the 'author_name' key of the item dictionary. if value under the 'author_email' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'email' and value under the 'author_email' key of the item dictionary. if value under the 'author_link' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'uri' and value under the 'author_link' key of the item dictionary. call the method handler.endElement with an argument string 'author'. if value under the 'unique_id' key of the item dictionary is not None, substitute value under 'unique_id' key of item dictionary for unique_id. if not, call the function get_tag_uri with 2 arguments: values under 'link' and 'pubdate' keys of item dictionary, substitute the result for unique_id. call the method handler.addQuickElement with 2 arguments: string 'id' and unique_id. if value under the 'description' key of the item dictionary is not None, call the method handler.addQuickElement with 3 arguments: string 'summary', value under the 'description' key of item dictionary, and dictionary with an entry: 'html' for 'type'. if value under the 'enclosure' key of the item dictionary is not None, call the method handler.addQuickElement with 3 arguments: string 'link', an empty string and a dictionary with 4 entries: "enclosure" for 'rel', field url of value under the "enclosure" key of item dictionary for 'href', field length of value under the "enclosure" key of item dictionary for 'length', and field mime_type of value under the "enclosure" key of item dictionary for 'type'. for every cat in value under 'categories' key of item dictionary, call the method handler.addQuickElement with 3 arguments: string 'link', an empty string and a dictionary with an entry: cat for 'term'. if value under the 'item_copyright' key of the item dictionary is not None, call the method handler.addQuickElement with 2 arguments: string 'rights' and value under the 'item_copyright' key of the item dictionary. substitute Rss201rev2Feed for DefaultFeed. _format_cache is an empty dictionary. _format_modules_cache is an empty dictionary. ISO_INPUT_FORMATS is a dictionary with 3 entries: tuple with an element string '%Y-%m-%d' for 'DATE_INPUT_FORMATS', use global variables _format_cache and _format_modules_cache. _format_cache is an empty dictionary. _format_modules_cache is an empty dictionary. call the function check_for_language with an argument lang, if it evaluates to false, if format_module_path is None. format_locations is an empty list. if format_module_path is true, format_module_path is a list containing an element format_module_path. call the function to_locale with an argument lang, substitute the result for locale. locales is a list with an element locale. if '_' is contained in locale, for every location in format_locations, for every loc in locales, if lang is None, call the function get_language, substitute the result for lang. call the method _format_modules_cache.setdefault with 2 arguments: lang and list created out of the results of the function, iter_format_modules called with 2 arguments: lang and settings.FORMAT_MODULE_PATH, substitute the result for modules. if reverse is true, reverse the order of modules elements, put them into a list, return it. call the function force_str with an argument format_type, substitute the result for format_type. if lang is None, call the function get_language, substitute the result for lang. cache_key is a tuple with 2 argumetns: format_type and lang. substitute value under the cache_key key of the _format_cache dictionary for cached. if cached is not None, if not, if KeyError exception is caught, call the function get_format_modules with an argument lang, for every module in the result, get format_type attribute of module object, substitute the result for val. get the value under the if iso_input not in val key of the ISO_INPUT_FORMATS dictionary, if it doesnt exists return an empty tuple, for every iso_input in the result, if iso_input is not contained in val, convert val to an list, substitute it for val. substitute val for the value under the cache_key key of the _format_cache dictionary. if AttributeError exception is caught, value under the cache_key key of the _format_cache dictionary is None. call the function lazy with 4 arguments: get_format, six.text_type, list and tuple, substitute the result for get_format_lazy. call the function dateformat.format with 2 arguments: value and result of the function get_format called with 2 arguments: call the function dateformat.time_format with 2 arguments: value and result of the function get_format called with 2 arguments: call the function get_language, substitute the result for lang. if not, lang is None. call the method numberformat.format with 6 arguments: value, result of the function get_format called with 3 arguments: call the function number_format with 2 arguments: value and use_l10 as use_l10n, return the result. call the function date_format with 2 arguments: value, string 'DATETIME_FORMAT' and use_l10n as use_l10n, return the result. call the function date_format with 2 arguments: value and use_l10n as use_l10n, return the result. call the function time_format with 3 arguments: value, string 'TIME_FORMAT' and use_l10n as use_l10n, return the result. if not, call the function force_str with an argument: default if it is true, or if not, first element of the result of the function, call the function force_str with an argument: default if it is true, or if not, first element of the result of the function, call the function force_str with an argument: default if it is true, or if not, first element of the result of the function, parts is an empty list. call the function get_format with an argument string 'DECIMAL_SEPARATOR', substitute the result for decimal_separator. call the function get_format with an argument string 'THOUSAND_SEPARATOR', substitute the result for thousand_sep. call the function unicodedata.normalize with 2 arguments: string 'NFKD' and thousand_sep, put the result and thousand_sep into a set, call the function warnings.warn with 3 arguments: mem_args is a list containing of first num_args elements of args list. if mem_args is contained in cache, substitute result for value under the mem_args key of the cache dictionary. if instance is None, decorator total_ordering, __dispatch is None. substitute kw for self.__kw. classmethod decorator, cls.__dispatch is an empty dictionary. for every resultclass in resultclasses, value under the resultclass key of the cls.__dispatch dictionary is an empty dictionary. call the method resultclass.mro, reverse the order of elements, for every type_ in the result. for every k and v in result of the call to the method type_.__dict__.items, call the method cls.__promise__ with 3 arguments: resultclass, k and v, substitute the result for meth. if cls has an attribute k, set k attribute of cls object to meth. if bytes is contained in resultclasses, cls._delegate_bytes is boolean True, otherwise it is boolean False. if six.text_type is contained in resultclasses, cls._delegate_text is boolean True, otherwise it is boolean False. if cls._delegate_bytes and cls._delegate_text are both false, raise an error, with an argument string "Cannot call lazy() with both bytes and text return types.". if cls._delegate_text is true, substitute cls.__text_cast for cls.__str__. if not, substitute cls.__text_cast for cls.__text_cast. substitute cls.__bytes_cast for cls.__bytes__. if not, substitute cls.__bytes_cast for cls.__str__. class method decorator, get the type of res, call the method mro on the result, for every t in the result, get the value under the funcname key of the t-th elment of self.__dispatch dictionary, call the result with 3 arguments: res, if klass is not contained in cls.__dispatch, value under the klass key of the cls.__dispatch dictionary is an empty dictionary. substitute method for value under the funcname key of the dictionary under the klass key of the cls.__dispatch dictionary. if not, call the method other.__cast, substitute the result for other. call the method other.__cast, substitute the result for other. call the method other.__cast, substitute the result for other. call the method self.__cast, return the hash value of the result. if self._delegate_bytes and six.PY2 are both true, if not, _wrapped is None. call the function new_method_proxy with an argument getattr, substitute the result for __getattr__. if name equals string "_wrapped", if not, if name equals string "_wrapped", classmethod decorator, call the method cls.__new__ with 2 arguments: cls and unpacked list args. if proto is greater than or equal to integer 2, if not, call the method copy.deepcopy with 2 arguments: self._wrapped and memo, return the result. call the function new_method_proxy with an argument bytes, substitute the result for __bytes__. call the function new_method_proxy with an argument str, substitute the result for __str__. call the function new_method_proxy with an argument bool, substitute the result for __bool__. if not, call the function new_method_proxy with an argument str, substitute the result for __str__. call the function new_method_proxy with an argument unicode, substitute the result for __unicode__. call the function new_method_proxy with an argument bool, substitute the result for __nonzero__. call the function new_method_proxy with an argument dir, substitute the result for __dir__. cal the method operator.attrgetter with an argument string "__class__", use the result as an argument for the call to the function, new_method_proxy, __class__ is an property object created with previous result as an argument. call the function new_method_proxy with an argument operator.eq, substitute the result for __eq__. call the function new_method_proxy with an argument operator.ne, substitute the result for __ne__. call the function new_method_proxy with an argument hash, substitute the result for __hash__. call the function new_method_proxy with an argument operator.getitem, substitute the result for __getitem__. call the function new_method_proxy with an argument operator.setitem, substitute the result for __setitem__. call the function new_method_proxy with an argument operator.delitem, substitute the result for __delitem__. call the function new_method_proxy with an argument operator.contains, substitute the result for __contains__. substitute super for _super. substitute self._setupfunc for repr_attr. if not, substitute self._wrapped for repr_attr. return a string '<%s: %r>', format it with __name__ field of the self class and repr_attr. result is an instance of SimpleLazyObject class, created with an argument self._setupfunc. call the method copy.deepcopy with 2 arguments: self._wrapped and memo, return the result. if fget is not None, decorator function wraps with an argument fget. if fset is not None, decorator function wraps with an argument fset. if fdel is not None, decorator function wraps with an argument fdel. return an property object with getter function fget, setter function fset, destructor fdel and documentation string doc. results is a tuple with 2 elements, 2 empty lists. for every item in values, if sys.version_info is greater than or equal to a tuple with 3 elements: integers 2, 7 and 2, respectively, if not, and lambda function with 2 arguments: self and other, resulting boolean False if self is lesser than other or self is equal to other, tuple with 2 elements: string '__le__', and lambda function with 2 arguments: self and other, resulting boolean True if self is lesser than other or self is equal to other, tuple with 2 elements: string '__ge__', and lambda function with 2 arguments: self and other, resulting boolean False if self is lesser than other, for '__lt__', list with 3 tuples: tuple with 2 elements: string '__ge__', and lambda function with 2 arguments: self and other, resulting boolean False if self is lesser than or equal to other, or self is equal to other, tuple with 2 elements: string '__lt__', and lambda function with 2 arguments: self and other, resulting boolean True if self is lesser than or equal to other, or self is not equal to other, tuple with 2 elements: string '__gt__', and lambda function with 2 arguments: self and other, resulting boolean False if self is lesser than or equal to other, for '__le__', list with 3 tuples: tuple with 2 elements: string '__lt__', and lambda function with 2 arguments: self and other, resulting boolean False if self is greater than other or self is equal to other, tuple with 2 elements: string '__ge__', and lambda function with 2 arguments: self and other, resulting boolean True if self is greater than other or self is equal to other, tuple with 2 elements: string '__le__', and lambda function with 2 arguments: self and other, resulting boolean False if self is greater than other, for '__gt__', and list with 3 tuples: tuple with 2 elements: string '__le__', and lambda function with 2 arguments: self and other, resulting boolean True if self is not greater than or is not equal to other, or self is equal to other, tuple with 2 elements: string '__gt__', and lambda function with 2 arguments: self and other, resulting boolean True if self is greater than or not equal to other, or self is not equal to other, tuple with 2 elements: string '__lt__', and lambda function with 2 arguments: self and other, resulting boolean False if self is greater than or equal to other, for '__ge__', convert cls to a dictionary, convert the result into a set and convert convert into a set, roots is a set of differences of the two previous sets. if roots is false, get maximal element from roots and substitute it for root. get the value under the root key of the convert dictionary, for every opname and opfunc in the result, if opname is not contained in roots, substitute opname for opfunc.__name__. get opname attribute from int object, substitute its field __doc__ for opfunc.__doc__. set opname attribute of cls object to opfunc. from .html_parser import HTMLParser and HTMLParseError into default name space. TRAILING_PUNCTUATION is a list with 7 elements: '.', ',', ':', ';', '.)', '"' and '\''. WRAPPING_PUNCTUATION is a list with 6 elements: tuple with 2 elements: '(' and ')', tuple with 2 elements: '<' and '>', tuple with 2 elements: '[' and ']', tuple with 2 elements: '<' and '>', tuple with 2 elements: '"' and '"', and tuple with 2 elements: '\'' and '\''. DOTS is a list with 6 elements: strings '·', '*', '\u2022', '•', '•' and '•'. call the function re.compile with raw string '&(?!(\w+|#\d+);)', substitute the result for unencoded_ampersands_re. call the function re.compile with raw string '(\s+)', substitute the result for word_split_re. call the function re.compile with 2 arguments: raw string '^https?://\[?\w' and re.IGNORECASE, substitute the result for simple_url_re. call the function re.compile with 2 arguments: raw string '^www\.|^(?!http)\w[^@]+\.(com|edu|gov|int|mil|net|org)($|/.*)$', and re.IGNORECASE, substitute the result for simple_url_re. call the function re.compile with raw string '&(?!(\w+|#\d+);)', substitute the result for simple_email_re. call the function re.compile with raw string '(]*?)target=[^\s>]+', substitute the result for link_target_attribute_re. call the function re.compile with 2 arguments: raw string '(?:
    |<\/i>|<\/b>|<\/em>|<\/strong>|<\/?smallcaps>|<\/?uppercase>)' and re.IGNORECASE, substitute the result for html_gunk_re. call the function re.compile with 2 arguments: raw string '((?:

    (?:%s).*?[a-zA-Z].*?

    \s*)+)', formated with string created by joining elements of result of the function re.escape with an argument x, with separator '|', for every x in DOTS, and re.DOTALL, substitute the result for hard_coded_bullets_re. call the function re.compile with raw string '(?:

    (?: |\s|
    )*?

    \s*)+\Z', substitute the result for trailing_empty_content_re. call the function force_text with an argument text, replace every occurrence of '&' in the result with '&', every occurrence of '<' with '<', every occurrence of '>' with '>', every occurrence of '"' with '"', and every occurrence of "'" with ''', call the function mark_safe with the previous result as an argument, return the result. call the function allow_lazy with 2 arguments: escape, six.text_type, substitute the result for escape. _js_escapes is a dictionary with 11 initial entries: '\\u005C' for integer representation of string '\\', '\\u0027' for integer representation of string '\', '\\u0022' for integer representation of string '"', '\\u003E' for integer representation of string '>', '\\u003C' for integer representation of string '<', '\\u0026' for integer representation of string '%', '\\u003D' for integer representation of string '=', '\\u002D' for integer representation of string '-', '\\u003B' for integer representation of string ';', '\\u2028' for integer representation of string '\u2028' and '\\u2029' for integer representation of string '\u2029'. for eery z in range of integers from 0 to 31, update _js_escapes dictionary with '\\u%04X' formated with z, use the result as an argument for the call to the mark_safe function, return the result. call the function allow_lazy with 2 arguments: escapejs, six.text_type, substitute the result for escapejs. if text has an '__html__' attribute, if not, map elements from args through the function conditional_escape, substitute the result for args_safe. kwargs_safe is a dictionary created for every k and v in result of the function six.iteritems called with an argument kwargs, with value result of the conditional_escape function called with an argument v for key k. call the method format_string.format with 2 arguments: unpacked list args_safe and unpacked dictionary kwargs_safe, if autoescape is true, call the function escape with an argument p, replace every occurrence of '\n' in the result for '
    ', format the string '

    %s

    ' with the result, for every p in paras, substitute list of results for paras. if not, replace every occurrence of '\n' in p for '
    ', call the function allow_lazy with 2 arguments: linebreaks, six.text_type, substitute the result for linebreaks. if fist and second element of sys.version_info equals to integer 3 and 2, respectively, if not, s is an instance of MLStripper class. if HTMLParseError exception is caught, close file descriptor s. if HTMLParseError or UnboundLocalError exceptions are caught, sum the result of the method s.get_data and s.rawdata, return the result. if not, call the function allow_lazy with an argument strip_tags, substitute the result for strip_tags. join elements of tags into a string, separated with '|', format string '(%s)' with it, substitute the result for tags_re. call the function re.compile with 2 arguments: raw string '<%s(/?>|(\s+[^>]*>))' formated with tags_re and re.U, substitute the result for starttag_re. call the function re.compile with an argument string '' formated with tags_re, substitute the result for endtag_re. call the function starttag_re.sub with 2 arguments: an empty string and html, substitute the result for html. call the function endtag_re.sub with 2 arguments: an empty string and html, substitute the result for html. call the function allow_lazy with 2 arguments: remove_tags, six.text_type, substitute the result for remove_tags. called with an argument value, return the result. call the function allow_lazy with 2 arguments: strip_spaces_between_tags, six.text_type, substitute the result for strip_spaces_between_tags. called with an argument value, return the result. call the function allow_lazy with 2 arguments: strip_entities, six.text_type, substitute the result for strip_entities. call the function urlsplit with an argument url, assign the result to scheme, netloc, path, query and fragment, respectively. call the method netloc.encode with an argument string 'idna', call the method decode on the result with an argument 'ascii', substitute the result for netloc. if UnicodeError exception is caught, if not, call the function urlunsplit with an argument tuple with 4 elements: scheme, netloc, path, query and fragment, substitute the result for url. call the function force_str with an argument url, use the result as an argument for the call to the function unquote, substitute the result for url. call the function quote with 2 arguments: url and safe as bytes string '!*\'();:@&=+$,/?#[]~', substitute the result for url. return a string '%s...' formated with elements of x up to the index equal to the maximum value between integer 0 and 3 subtracted from limit. call the function force_text with an argument text, split by it word_split_re, substitute it for words. for every i and word in enumerated iterable words, if '.' is contained in words or '@' is contained in word or ':' is contained in word, substitute empty string, word an empty string for lead, middle and trail, respectively. for every punctuation in TRAILING_PUNCTUATION, if middle ends with punctuation, sum punctuation and trail, substitute the result for trail. for every opening and closing in WRAPPING_PUNCTUATION, if middle starts with opening, sum lead and opening, substitute the result for lead. if middle ends with closing and count of occurrence of closing in middle equals count of occurrence of opening in middle incremented by one, sum trail and closing, substitute the result for lead. url is None. if nofollow is true nofollow_attr is a string ' rel="nofollow"', otherwise nofollow_attr is an empty string. call the method simple_url_re.match with an argument middle, if it evaluates to true, call the function smart_urlquote with an argument middle, substitute the result for url. call the function smart_urlquote with an argument string 'http://%s' formated with an argument middle, substitute the result for url. evaluates to true, split middle into two parts from the right by '@' character, assign the resulting parts to local and domain. call the method domain.encode with an argument string 'idna', call the method decode on the result with an argument string 'ascii', substitute the result for domain. if UnicodeError exception is caught, url is a string 'mailto:%s@%s' formated with local and domain. nofollow_attr is an empty string. if url is true, call the function trim_url with an argument middle, substitute the result for trimmed. if autoescape is true and safe_input is false, call the function escape with an argument lead, substitute the result for lead, call the function escape with an argument trail, substitute the result for trail. call the function escape with an argument url, substitute the result for url, call the function escape with an argument trimmed, substitute the result for trimmed. middle is a string '    %s' formated with url, nofollow_attr and trimmed. format string '%s' with lead, middle and trail, use it as an argument for the call to the function mark_safe, substitute the result for i-th element of words. if not, if safe_input is true, call the function mark_safe with an argument word, substitute the result for i-th element of words. call the function escape with an argument word, substitute the result for i-th element of words. call the function mark_safe with an argument word, substitute the result for i-th element of words. call the function escape with an argument word, substitute the result for i-th element of words. call the function allow_lazy with 2 arguments: urlize, six.text_type, substitute the result for urlize. substitute version_info from module sys for surrent_version. set use_workaround to boolean True if current_version tuple elements are smaller than the tuple (2,7,3), respectively, or if current_version is greater than (3,0), but smaller than (3,2,3), otherwise set use_workaround to boolean False. substitute HTMLParseError from the module _html_parser for HTMLParseError. if use_workaround is boolean False, if tuple current_version elements are greater or equal to (3, 4), respectively, and dictionary of arbitrary length **kwargs as arguments. call the initialization method for the base class, _html_parser.HTMLParser.__init__ with self, convert_charrefs set to convert_charrefs and dictionary **kwargs as the arguments. if not, substitute HTMLParser from the module _html_parser for HTMLParser. if not, compile a regular expression pattern string '([a-zA-Z][-.a-zA-Z0-9:_]*)(?:\s|/(?!>))*' into a regular expression object and assign it to tagfind. set field interesting for this class instance to interesting_cdata from module _html_parser. if AttributeError exception is caught, substitute _html_parser.interesting_normal for self.interesting. call the method self.check_for_whole_start_tag with i as an argument, substitute result for the endpos. if endpos is lesser than zero, substitute self.rawdata for rawdata. slice the list from the i-th to the endpos-th element, substitute it for self.__starttag_text. attrs is a empty list. match the rawdata from the position i+1, with tagfind pattern, assign the result to the match. if match evaluates to False throw an exception with the string message 'unexpected call to parse_starttag()'. find the ending position of the regular expression match of the object match, substitute the result for k. as long k is smaller than endpos, match the rawdata from the position k, with attrfind pattern, assign the result to the m. if m is not False, None is considered False, find the first, second and third subgroup of the m regular expression match, assign the result to the attrname, rest and attrvalue, respectively. if rest is not False, None is considered False, set attrvalue to None. otherwise, if first and the last character of attrvalue are '\' charter or first and last character of attrvalue are '"' character, remove first and last character from the attrvalue, substitute it for attrvalue. if attrvalue is not an empty string, call the method unescape with attrvalue as the argument on the self class instance, substitute the result for attrvalue. find the ending position of the regular expression match of the object match, substitute the result for k. slice the rawdata string from the k-th to the endpos-th index, remove the whitespaces from the start and the end of the string, substitute it for end. if end is not a '>' or '/>' character, evaluate the self.getpos() and assign the result to the lineno and offset respectfully. increment the lineno by the count of the newlines in self.__starttag_text. substitute the result for offset. if not, slice the rawdata from k to endpos, then take the first 20 elements of the previous slice, with it replace %r in the string "junk characters in start tag: %r", call the method self.error with the resulting string as an argument. if string end ends with string '/>', if not, substitute self.rawdata for rawdata. take two characters from the i-th element of rawdata, if they are not equal to the string '\d{2})'. __D2 is a raw string '(?P[ \d]\d)'. __M is a raw string '(?P\w{3})'. __Y is a raw string '(?P\d{4})'. __Y2 is a raw string '(?P\d{2})'. __T is a raw string '(?P\d{2}):(?P\d{2}):(?P\d{2})'. call the function re.compile with an argument raw string '^\w{3}, %s %s %s %s GMT$' formated with __D, __M, __Y and __T, substitute the result for RFC1123_DATE. call the function re.compile with an argument raw string '^\w{6,9}, %s-%s-%s %s GMT$' formated with __D, __M, __Y2 and __T, substitute the result for RFC850_DATE. call the function re.compile with an argument raw string '^\w{3} %s %s %s %s$' formated with __M, __D2, __T and __Y, call the function quote with 2 arguments: result of the function force_str called with an argument url, and result of the function force_str called with an argument safe, use the result as an argument for the call to the function force_text, return the result. call the function allow_lazy with 2 arguments: urlquote and six.text_type, substitute the result for urlquote. call the function quote_plus with 2 arguments: result of the function force_str called with an argument url, and result of the function force_str called with an argument safe, use the result as an argument for the call to the function force_text, return the result. call the function allow_lazy with 2 arguments: urlquote_plus and six.text_type, substitute the result for urlquote_plus. call the function force_str with an argument quoted_url, use the result as an argument for the call to the function unquote, use the result as an argument for the call to the function force_text, return the result. call the function allow_lazy with 2 arguments: urlunquote and six.text_type, substitute the result for urlunquote. call the function force_str with an argument quoted_url, use the result as an argument for the call to the function unquote_plus, use the result as an argument for the call to the function force_text, return the result. call the function allow_lazy with 2 arguments: urlunquote_plus and six.text_type, substitute the result for urlunquote_plus. call the method query.lists, substitute the result for query. call the method query.items, substitute the result for query. call the function formatdate with an argument epoch_seconds, substitute the result for rfcdate. return a string '%s-%s-%s GMT', formated with: first 7 elements of rfcdate, elements of rfcdate from 8-th to the 11-th index, for every regex in tuple with 3 elements: RFC1123_DATE, RFC850_DATE and ASCTIME_DATE, call the method regex.match with an argument date, substitute the result for m. if m is not None, if not, call the method m.group with an argument string 'year', convert the result into a string, substitute it for year. if year is lesser than integer 100, if year is lesser than integer 70, increment year by integer 2000. if not, increment year by integer 1900. call the method m.group with an argument string 'mon', convert the result to lowercase, use it as an argument for the call to the, method MONTHS.index, increment the result by integer 1, substitute it for month. call the method m.group with an argument string 'fay', convert the result into a string, substitute it for day. call the method m.group with an argument string 'hour', convert the result into a string, substitute it for hour. call the method m.group with an argument string 'min', convert the result into a string, substitute it for min. call the method m.group with an argument string 'sec', convert the result into a string, substitute it for sec. call the method MONTHS.index with 6 arguments: year, month, day, hour, min and sec, substitute the result for result. call the method result.utctimetuple, use the result as an argument for the call to the method calendar.timegm, return the result. if Exception exception is caught. call the function parse_http_date with an argument date, return the result. if Exception exception is caught. digits is a string "0123456789abcdefghijklmnopqrstuvwxyz". factor is integer 0. if i is smaller than integer 0, if six.PY2 is true, if i is greater than sys.maxint, increment factor by one. bring integer 36 to the power of factor, if i is smaller than the result, decrement factor by one. base36 is an empty list. while factor is greater or equal to integer 0, bring integer 36 to the power of factor, substitute the result for j. i is the reminder of the division of i by j. decrement factor by one. call the method base64.urlsafe_b64encode with an argument s, strip the result of the bytes string '\n=' from the right, return it. call the method s.encode with an argument string 'utf-8', substitute the result for s. pad the rest of the field with bytes string '=', use the result as an argument for the call to the method base64.urlsafe_b64decode, return the result. if LookupError or BinasciiError, renamed to e, exceptions are caught. call the method ETAG_MATCH.findall with an argument etag_str, substitute the result for etags. if etags is false, for every e in etags call the method e.encode with an argument string 'ascii', call the method decode on the result with an argument, return a string '"%s"' formated with etag, in which every occurrence of '\\' is replaced with '\\\\' and every occurrence of '"', substitute result of the function urlparse with an argument ur1 for p1 and result of the function urlparse with an argument ur2 for p2. if p2.scheme, p2.hostname and p2.port equals p1.scheme, p1.hostname and p1.port, respectively, return boolean True, otherwise return boolean False. if url is false, replace every occurrence of '\\' in url with '/'. if url starts with '///', call the function urlparse with an argument url, substitute the result for url_info. if url_info.netloc is false and url_info.scheme is true, if url_info.netloc is false or url_info.netloc equals host, and if url_info.scheme is false or url_info.scheme equals, if package doesnt have an 'rindex' attribute, for every x is the range of integers from level to the integer 2, in the reversed order, call the method package.rindex with 3 arguments: string '.', integer 0 and dot, substitute the result for dot. return a string "%s.%s" formated with first dot package elements and name. if not, if name starts with an string '.', if package is false, level is an integer 0. for every character in name, if character is not equal to a string '.', increment level by one. call the function _resolve_name with 3 arguments: name list elements from the level index to the end, package and level, substitute the result for name. call the function __import__ with an argument name. best_doublecolon_start is an integer -1. best_doublecolon_len is an integer 0. doublecolon_start is an integer -1. doublecolon_len is an integer 0. call he function is_valid_ipv6_address with an argument ip_str, if it evaluates to false, call the function _explode_shorthand_ip_string with an argument ip_str, substitute the result for ip_str. call the function _explode_shorthand_ip_string with an argument ip_str, substitute the result for ip_str. if unpack_ipv4 is true, call the function _unpack_ipv4 with an argument ip_str, substitute the result for ipv4_unpacked. if ipv4_unpacked is true, split ip_str by ':', substitute the result for hextets. get the value under the index key of the hextets dictionary, remove the leading '0' characters, substitute the result for value under the index key of the hextets dictionary. get the value under the index key of the hextets dictionary, if it is false, value under the index key of the hextets dictionary is a string '0'. if value under the index key of the hextets dictionary equals to string '0', increment doublecolon_len by integer 1, if doublecolon_start equals integer -1, substitute index for doublecolon_start. if doublecolon_len is greater than best_doublecolon_len, substitute doublecolon_len for best_doublecolon_len. substitute doublecolon_start for best_doublecolon_start. if not, doublecolon_len is integer 0. doublecolon_start is integer -1. if best_doublecolon_len is greater than integer 1, sum best_doublecolon_start and best_doublecolon_len, substitute the result for best_doublecolon_end, append an empty string to list hextets. replace hextets list from the best_doublecolon_start index to best_doublecolon_end index with an empty string. if best_doublecolon_start equals integer 0, prepend an empty string to hextets list. join elements of hextets into a string, separated with ':', substitute it for result. convert ip_str to lowercase, if it doesnt start with a string '0000:0000:0000:0000:0000:ffff:', split ip_str into parts by ':', substitute the result for hextets. if '.' is contained in last elements of hextets, ipv4_address is a string "%d.%d.%d.%d" formated with first 2 elements of seventh element of hextets converted into hexadecimal number, second 2 elements of seventh element of hextets converted into hexadecimal number, first 2 elements of eight element of hextets converted into hexadecimal number, second 2 elements of eight element of hextets converted into hexadecimal number. join first 5 elements of hextets into a string, separated by ':', substitute the result for result. append ':' and ipv4_address to result. convert ip_str to lowercase, if it doesnt start with a string '0000:0000:0000:0000:0000:ffff:', if ':' is not contained in ip_str. if count of occurrence of '::' in ip_str is greater than integer 1, if string ':::' is contained in ip_str, if ip_str starts with ':, but it doesnt starts with '::', or if ip_str ends with ':, but it doesnt ends with '::', if count of occurrence of ':' in ip_str is greater than integer 7, if '::' is not contained in ip_str and number of occurrences of ':' in ip_str is not equal to integer 7, if count of occurrence of '.' in ip_str is not equal to integer 3, call the function _explode_shorthand_ip_string with an argument ip_str, substitute the result for ip_str. split ip_str into parts by ':', for every hextet in the result, if count of occurrence of '.' in ip_str is equal to integer 3, split ip_str by ':', if last element of the result is not equal to hextet. call the function validate_ipv4_address with an argument hextet. if ValidationError exception is caught, if not, if hextet converted to hexadecimal number is smaller than hexadecimal 0, or hextet converted to hexadecimal number is smaller than hexadecimal FFFF, call the function _is_shorthand_ip with an argument ip_str, if it evaluates to false, new_ip is an empty list, split ip_str by '::', substitute it for hextet. split ip_str into parts by ':', if '.' is contained in the last element of the result, fill_to is an integer 7. if not, fill_to is an integer 8. split first element of hextet into parts by ':', append them to new_ip. for every __ in range of integers from 0 up to sep subtracted from fill_to, split second element of hextet into parts by ':', append them to new_ip. if not, split ip_str into parts by ':', substitute the result for new_ip. ret_ip is an empty list. for every hextet in new_ip, if count of occurrence of '::' in ip_str equals integer 1, create an iterator out of x. if not, num is an integer 0. substitute Tok.num for self.id. increment Tok.num with an integer 1. substitute regex for self.regex. for every c in choices split into words, concatenate prefix, result of the function re.escape with an argument c and suffix, call the method states.items, for every state and rules in the result, parts is an empty list. for every tok in rules, groupid is a string "t%d" formated with tok.id. substitute tok for value under the groupid key of the self.toks dictionary. call the function re.compile with 2 arguments: elements of parts joined into a string, separated with '|', substitute self.state for state. substitute self.regexes for regexes. substitute self.toks for toks. start is an integer 0. while start is lesser than end. get the value under the state key of the regexes dictionary, call the method finditer on the result with 2 arguments: text and start, for every match in the result, substitute match.lastgroup for name. substitute value under the name key of the toks dictionary for tok. call the method match.group with an arugument name, substitute the result for toktext. if tok.next is true, substitute tok.next for state. substitute state for self.state. both_before is a list containing 14 elements, all of them are instances of Tok class, created with 2 arguments, a string and a raw string. both_after is an list with an element instance of Tok class, created with 2 arguments: string 'other' and raw string '.'. states is a dictionary with 2 arguments: appended list with an element instance of a class Tok, created with 3 arguments: "punct", call the method m.group with an argument integer 0, substitute the result for s. if s equals a string '"', if not, lexer is an instance of JsLexer class. c is an empty list. call the method lexer.lex with an arguments js, for every name and tok in the result, if name equals a string 'regex', tok is a string '"REGEX"', if tok starts with "'", call the function re.sub with 3 arguments: raw string "\\.|.", escape_quotes and tok without the first and last element, substitute the result for guts. concatenate string '"', guts and string '"', substitute the result for tok. replace every occurrence of '\\' in tok with 'U', substitute the result for tok. from logging.config import dictConfig. substitute logging.getLogger for getLogger. DEFAULT_LOGGING is a dictionary with 5 initial entries: 1 for 'version', False for 'disable_existing_loggers', if sys.warnoptions is false, call the function warnings.simplefilter with 2 arguments: string "default" and RemovedInNextVersionWarning. if logging_config is true, call the function import_string with an argument logging_config, substitute the result for logging_config_func. call the function logging_config_func with an argument DEFAULT_LOGGING. if logging_settings is true, call the function logging_config_func with an argument logging_settings. substitute include_html for self.include_html. substitute email_backend for self.email_backend. subject is an string '%s (%s IP): %s', formated with record.levelname, string 'internal' if value under the 'REMOTE_ADDR' key, call the method filter.get_request_repr with an argument request, format string '\n{0}' with the result, substitute the result for request_repr. if Exception exception is caught, subject is an string '%s: %s' formated with record.levelname and result of the method record.getMessage, respectively. request_repr is a string "unavailable". call the function self.format_subject with an argument subject, substitute the result for subject. if record.exc_info is true, substitute record.exc_info for exc_info. if not, exc_info is an tuple with 3 elements: None, result of method record.getMessage and None. message is an string "%s\n\nRequest repr(): %s" formated with the result of the metod self.format with an argument record, and request_repr, respectively. reporter is an instance of ExceptionReporter class, created with 3 arguments: request, is_email as boolean True, unpacked list exc_info. if self.include_html is true, call the method reporter.get_traceback_html and substitute the result for html_message, replace every occurrence of '\n' in subject with '\\n' and replace every occurrence of '\r' in subject with '\\r', substitute the result for formatted_subject. return first 989 elements of formatted_subject. substitute callback for self.callback. _CacheInfo is an instance of namedtuple class created with 2 arguments: string "CacheInfo" and a list with 4 elements: string 'hits', __slots__ is a string 'hashvalue'. get the hash value of the tup, substitute it for self.hashvalue. if kwds is true, sort elements of kwds, substitute the result for sorted_items. for every item in sorted_items, if typed is true, if kwds is true, cache is an empty dictionary. stats is an list with 2 elements: 2 integers 0. HITS and MISSES are integer 0 and 1, respectively. substitute _make_key for make_key. substitute cache.get for cache_get. lock is an instance of RLock class. root is an empty list. root is a list with elements: root, root, None and None. nonlocal_root is an list with an element root. if maxsize equals integer 0, call the function user_function with 2 arguments: unpacked list args and unpacked dictionary kwds, substitute the result for result. increment stats dictionary value under the MISSES key by integer 1. if result is not root, increment stats dictionary value under the HITS key by integer 1. call the function user_function with 2 arguments unpacked list args and unpacked dictionary kwds, substitute the result for result. increment stats dictionary value under the MISSES key by integer 1. if not, if kwds is true or typed is true, call the function make_key with 3 arguments: args, kwds and typed, substitute the result for key, otherwise substitute args for key. with lock, if link is not None, substitute nonlocal_root for a tuple with an element root. substitute link_next for value under the NEXT key of the link_prev dictionary. substitute link_prev for value under the PREV key of the link_next dictionary. substitute value under the PREV key of the root dictionary for last. substitute link for values under the NEXT key of the last dictionary and PREV key of the root dictionary. substitute last for value under the PREV key of the link dictionary. substitute root for value under the NEXT key of the link dictionary. increment stats dictionary value under the HITS key by integer 1. call the function user_function with 2 arguments: unpacked list args and unpacked dictionary kwds, substitute the result for result. with lock, substitute nonlocal_root for tuple root. substitute root for oldroot. substitute result for value under the RESULT key of the oldroot dictionary. substitute value under the NEXT key of the oldroot dictionary for root and first element of nonlocal_root. substitute value under the RESULT key of the root dictionary for oldvalue. delete entry under the oldkey key of the cache dictionary. if not, substitute value under the PREV key of the root dictionary for last. for value under the key key of the cache dictionary. increment stats dictionary value under the MISSES key by integer 1. with lock, return an instance of _CacheInfo class, created with 4 arguments: value under the HITS key of the stats dictionary, with lock, call the method cache.clear. substitute first element of nonlocal_root for root. root is an list with 4 elements: root, root, None and None. stats is a list with 2 elements: 2 integers 0. substitute user_function for wrapper.__wrapped__. substitute cache_info for wrapper.cache_info. substitute cache_clear for wrapper.cache_clear. call the function update_wrapper with 2 arguments: wrapper and user_function, return the result. split dotted_path into two parts from the right at the '.' character, assign the result to module_path and class_name, respectively. msg is a string "%s doesn't look like a module path" formated with dotted_path. and third element of result of the function sys.exc_info. call the function import_module with an argument module_path, substitute the result for module. get attribute class_name form the module object, return it. if AttributeError exception is caught, call the function warnings.warn with 3 arguments: string 'import_by_path() has been deprecated. Use import_string() instead.', call the function import_string with an argument dotted_path, substitute the result for attr. msg is a string '%sError importing module %s: "%s"', where '%s' is replaced with error_prefix, dotted_path and e, respectively. call the function six.reraise with 3 arguments: ImproperlyConfigured, instance of ImproperlyConfigured class created with msg, get value under the 'register_to' key of the kwargs dictionary, substitute it for register_to. if register_to is true, call the method copy.copy with an argument register_to._registry, substitute the result for before_import_registry. is exception is caught, if register_to is true, substitute before_import_registry for register_to._registry. if first and second element of sys.version_info are both equal to integer 3, if first and second element of sys.version_info are equal to integers 3 and 4, respectively, from importlib.util import find_spec as importlib_find. if not, from importlib import find_loader as importlib_find. substitute package.__name__ for package_name. substitute package.__path__ for package_path. if AttributeError exception is caught, concatenate package_name, string '.' and module_name, substitute it for full_module_name. call the function importlib_find with 2 arguments: full_module_name and package_path, if the result is not None, return boolean True, otherwise return boolean False. if not, join package.__name__ and module_name into a string separated with '.', substitute it for name. if KeyError exception is caught, substitute package.__path__ for package_path. if AttributeError exception is caught, for every finder in sys.meta_path, if call to the method finder.find_module with 2 arguments: name and package_path evaluates to true, for every entry in package_path, substitute the value under the entry key of the sys.path_importer_cache dictionary for finder. if finder is None, call the method imp.find_module with 2 arguments: module_name and list containing element entry, assign the result to file_, _, and _, respectively. if file_ is true, close file_ file descriptor. if not, if KeyError exception is caught, for every hook in sys.path_hooks, call the function hook with an argument entry, substitute the result for finder. if call to the method finder.find_module with an argument name evaluates to true, if not, if not, call the method imp.find_module with 2 arguments: module_name and list containing element entry, assign the result to file_, _, and _, respectively. if file_ is true, close file_ file descriptor. if not, otherwise substitute settings.USE_L10N for use_grouping. if use_grouping is true substitute it for use_grouping, otherwise substitute force_grouping for use_grouping. if use_grouping is true and grouping is greater than integer 0, use_grouping is boolean True, otherwise it is boolean False. return the result. sign is an empty string. call the function six.text_type with an argument number, substitute the result for str_number. if first element of str_number equals a string '-'. sign is a string '-'. remove the first element from str_number. if '.' is not contained in str_number, split str_number by '.', substitute the result for int_part and dec_part, respectively. if decimal_pos is not None, substitute first decimal_pos elements of dec_part for dec_part. if not, substitute str_number and an empty string for int_part and dec_part. if decimal_pos is not None subtract length of dec_part from decimal_pos, multiply the number of character '0' by the result, append the resulting string to dec_part, substitute it for dec_part. if dec_part is true, add decimal_sep and dec_part, substitute the result for dec_part. if use_grouping is true, int_part_gd is an empty string. for every cnt and digit in enumerated list int_part with reversed ordering of elements, if cnt is true and remained of dividing cnt with grouping is zero, increment int_part_gd by thousand_sep. append digit to int_part_gd. invert the ordering of elements of int_part_gd, substitute it for int_part. sum sign, int_part and dec_part, return the result. ESCAPE_MAPPINGS is an dictionary with 10 initial entries: None for 'A', None for 'b', None for 'B', '0' for 'd', 'x' for 'D', result is an empty list. non_capturing_groups is an empty list. call the function next_char with an argument iterator pattern, substitute the result for pattern_iter. num_args is an integer 0. if StopIteration exception, if escaped is true, remove first element from non_capturing_groups, substitute it for start. inner is an instance of NonCapture, created with elements of result from start index to the end. append list with element inner to list containing first start elements of result, substitute it for result. name is a string "_%d" formated with num_args. increment num_args by one. if not, if ch is contained in string "iLmsu#", if not, terminal_char is an string '>'. if not, terminal_char is an string ')'. name is an empty list. while ch is not equal to terminal_char, join elements of name into a string, substitute it for param. if terminal_char is not equal to string ')', if not, if count is equal to integer 0. if call to the function contains with 2 arguments: last element of result and Group, evaluates to true, last element of result is an instance of Choice class, created with an argument list with 2 elements: None and last element of result. if not, remove the first element from result. create a list with count decremented by 1 number of last element of result elements, extend list result with it. if not, if consume_next is true, if not, if StopIteration exception, if NotImplementedError exception, call the function flatten_result with an argument result, unpack the resulting list and zip it in the list of tuples, return the result. if representative is None, nesting is integer 1. if not, nesting is integer 0. if escaped is true, increment nesting by one. if nesting is false, decrement nesting by one. get the next element of the iterable pattern_iter, assign the result for ch2 and escaped, respectively. if StopIteration exception, ch2 is None. if ch2 equals string '?', ch2 is None. quant is an empty list. remove last element for quant. join elements of quant into a string, split it by string ',', substitute the result for values. if StopIteration exception, convert first element of values into a integer, return the result and ch. for every elt in source, call the function contains with 2 arguments: elt and inst, if it evaluates to true, if source is None, if second element of source is None, params is an empty list, if not, params is a list with second element of source as a element. result is a list containing an empty string. result_args is a list containing an empty list. pos and last are integer 0. for every pos and elt in enumerated iterable source, join source list elements from last till pos indexes into a string, substitute the result for piece. increment piece by firs element of elt. substitute second element of elt for param. if not, param is None. increment pos by one, substitute the result for last. increment i-th element of result by piece. if param is true, elt is an list with an element elt. inner_result and inner_args are empty lists. for every item in elt, call the function flatten_result with an argument item, assign the result to res and args, respectively. extend list inner_result with res. new_result is an empty list. new_args is an empty list. zip elements of result and result_args into a list of tuples, for every item and args in the result, zip elements of inner_result and inner_args into a list of tuples, for every i_item and i_args in the result, substitute new_result for result. substitute new_args for result_args. if pos is greater than or equal to last, join elements of list source from index last to the end into a string, substitute it for piece. increment i-th element of result by piece. substitute EscapeText for EscapeString. if not, substitute EscapeBytes for EscapeString. substitute EscapeText for EscapeUnicode. call the __add__ method with an arguments rhs from the base class of the class SafeBytes, substitute the result for t. remove kwargs dictionary element under the 'method' key, substitute it for method. if not, call the function curry with 2 arguments: _proxy_method and method set to bytes.decode, substitute the result for decode. call the __add__ method with an arguments rhs from the base class of the class SafeText, substitute the result for t. remove kwargs dictionary element under the 'method' key, substitute it for method. if not, call the function curry with 2 arguments: _proxy_method and method set to six.text_type.encode, substitute the result for encode. substitute SafeText for SafeString. if not, substitute SafeBytes for SafeString. substitute SafeText for SafeUnicode. __author__ is a string "Benjamin Peterson ". __version__ is a string "1.6.1". if first element of sys.version_info equals integer 2, PY2 is boolean True, otherwise it is boolean False. substitute str for string_types. substitute int for integer_types. substitute type for class_types. substitute str for text_type. substitute bytes for binary_type. substitute sys.maxsize for MAXSIZE. if not, substitute basestring for string_types. integer_types is a tuple with 2 elements int and long. class_types is a tuple with 2 elements: type and types.ClassType. substitute unicode for text_type. substitute str for binary_type. if sys.platform starts with string 'java', bitwise shift integer 1 to the left by 31 spaces, substitute integer 1 from the result, convert the result to a integer, substitute it for MAXSIZE. if not, if OverflowError exception is caught, bitwise shift integer 1 to the left by 31 spaces, substitute integer 1 from the result, convert the result to a integer, substitute it for MAXSIZE. if not, bitwise shift integer 1 to the left by 63 spaces, substitute integer 1 from the result, convert the result to a integer, substitute it for MAXSIZE. delete X. call the function __import__ with an argument name. delete self.name attribute from the obj.__class__ object. if new is None, substitute name for new. substitute new for self.mod. if not, substitute old for self.mod. call the function _import_module with an argument self.mod, return the result. if attr equals any of the strings "__file__", "__name__" or "__path__" and self.mod is not contained in sys.modules, call the method self._resolve, substitute the result for _module. attrs is a list with 2 elements: strings "__doc__" and "__name__". append attr.name to attrs for every attr in self._moved_attributes. _moved_attributes is an empty list. if new_mod is None, substitute name for new_mod. substitute new_mod for self.mod. if new_attr is None, if old_attr is None, substitute name for new_attr. if not, substitute old_attr for new_attr. substitute new_attr for self.attr. if not, substitute old_mod for self.mod. if old_attr is None, substitute name for old_attr. substitute old_attr for self.attr. call the function _import_module with an argument self.mod, substitute the result for module. _moved_attributes is a list with 55 initial elements, 13 of them are the results of the call to the function MovedAttribute, with different 3 string arguments, the others are results of the call to the function MovedModule called with 3 string arguments. for every attr in _moved_attributes, set attr.name attribute of the _MovedItemst object to attr. concatenate __name__, string '.moves' and attr.name together, use it as an key to get the value from the sys.modules dictionary, substitute attr for the obtained value. delete attr. substitute _moved_attributes for _MovedItems._moved_attributes. append string '.moves' to __name__, use it as an argument to instantiate _MovedItems class, assign it to moves, _urllib_parse_moved_attributes is a list with 16 elemetns, all of them are the results of the call to the function MovedAttribute with different 3 string arguments. for every attr in _urllib_parse_moved_attributes, set attr.name attribute of the Module_six_moves_urllib_parse object to attr. delete attr. substitute _urllib_parse_moved_attributes for Module_six_moves_urllib_parse._moved_attributes. call the method Module_six_moves_urllib_request with an argument: string ".moves.urllib_parse" appended to __name__, _urllib_error_moved_attributes is a list with 3 elements: result of the call to the function MovedAttribute with 3 arguments: strings "URLError", "urllib2", "urllib.error", result of the call to the function MovedAttribute with 3 arguments: strings "HTTPError", "urllib2", "urllib.error" and result of the call to the function MovedAttribute with 3 arguments: strings "ContentTooShortError", "urllib", "urllib.error". for every attr in _urllib_error_moved_attributes, set attr.name attribute of the Module_six_moves_urllib_error object to attr. delete attr. substitute _urllib_error_moved_attributes for Module_six_moves_urllib_error._moved_attributes. call the method Module_six_moves_urllib_request with an argument: string ".moves.urllib.error" appended to __name__, for every attr in _urllib_request_moved_attributes, set attr.name attribute of the Module_six_moves_urllib_request object to attr. delete attr. substitute _urllib_request_moved_attributes for Module_six_moves_urllib_request._moved_attributes. call the method Module_six_moves_urllib_request with an argument: string ".moves.urllib.request" appended to __name__, strings "addbase", "urllib" and "urllib.response", result of the function MovedAttribute, called with 3 arguments: strings "addclosehook", "urllib", "urllib.response", result of the function MovedAttribute, called with 3 arguments: strings "addinfo", "urllib", "urllib.response" and result of the function MovedAttribute, called with 3 arguments: strings "addinfourl", "urllib", "urllib.response". for every attr in _urllib_response_moved_attributes, set attr.name attribute of Module_six_moves_urllib_response object to attr. delete attr. substitute _urllib_response_moved_attributes for Module_six_moves_urllib_response._moved_attributes. _urllib_robotparser_moved_attributes is a list containing an instance of MovedAttribute class, created with 3 argument: strings, "RobotFileParser", "robotparser", "urllib.robotparser". for every attr in _urllib_robotparser_moved_attributes, set attr.name attribute of Module_six_moves_urllib_robotparser object to attr. delete attr. substitute _urllib_robotparser_moved_attributes for Module_six_moves_urllib_robotparser._moved_attributes. instantiate class Module_six_moves_urllib_robotparser with an argument, string ".moves.urllib.robotparser" appended to __name__, append string ".moves.urllib_parse" to __name__, use it as an key to get the value from the sys.modules dictionary, substitute it for parse. append string ".moves.urllib_error" to __name__, use it as an key to get the value from the sys.modules dictionary, substitute it for error. append string ".moves.urllib_robotparser" to __name__, use it as an key to get the value from the sys.modules dictionary, substitute it for robotparser. instantiate class Module_six_moves_urllib with an argument, string ".moves.urllib" appended to __name__, set move.name attribute of the _MovedItems to move. delete name attribute of the _MovedItems object. if AttributeError exception is caught, delete entry under the name key of the moves.__dict__ dictionary. if NameError exception is caught, _meth_func is a string "__func__". _meth_self is a string "__self__". _func_closure is a string "__closure__". _func_code is a string "__code__". _func_defaults is a string "__defaults__". _func_globals is a string "__globals__". _iterkeys is a string "keys". _itervalues is a string "values". _iteritems is a string "items". _iterlists is a string "lists". if not, _meth_func is a string "im_func". _meth_self is a string "im_self". _func_closure is a string "func_closure". _func_code is a string "func_code". _func_defaults is a string "func_defaults". _func_globals is a string "func_globals". _iterkeys is a string "iterkeys". _iterkeys is a string "iterkeys". _iteritems is a string "iteritems". _iterlists is a string "iterlists". substitute next for advance_iterator. if NameError exception is caught, substitute klass.__dict__ for next. substitute callable for callable. if NameError exception is caught, if "__call__" is contained in klass.__dict__ for any klass in __mro__ field of the obj class, return boolean True, otherwise return False. substitute Iterator for create_bound_method. substitute object for Iterator. if not, return unbound.im_func. substitute callable for callable. call the function _add_doc with 2 arguments: get_unbound_function and string """Get the function out of a possibly unbound function""". call the method operator.attrgetter with an argument _meth_func, substitute the result for get_method_function. call the method operator.attrgetter with an argument _meth_self, substitute the result for get_method_self. call the method operator.attrgetter with an argument _func_closure, substitute the result for get_method_closure. call the method operator.attrgetter with an argument _func_code, substitute the result for get_method_code. call the method operator.attrgetter with an argument _func_defaults, substitute the result for get_method_defaults. call the method operator.attrgetter with an argument _func_globals, substitute the result for get_method_globals. get _iterkeys attribute of the class d, call the result with an argument unpacked dictionary kw, convert the result to a iterable, get _itervalues attribute of the class d, call the result with an argument unpacked dictionary kw, convert the result to a iterable, get _iteritems attribute of the class d, call the result with an argument unpacked dictionary kw, convert the result to a iterable, get _iterlists attribute of the class d, call the result with an argument unpacked dictionary kw, convert the result to a iterable, substitute chr for unichr. if second element of sys.version_info is smaller than or equal to integer 1, if not, call the method operator.methodcaller with 3 arguments: string 'to_bytes', integer 1 and string 'big', substitute the result for int2byte. call te method operator.itemgetter with an argument integer 0, substitute the result for byte2int. substitute operator.getitem for indexbytes. substitute iter for iterbytes. substitute io.StringIO for StringIO. substitute io.BytesIO for BytesIO. if not, replace every occurrence of raw string '\\' in s with a raw string '\\\\', use the result and string "unicode_escape", as arguments for the call to the unicode function, return the result. substitute unichr for unichr. substitute chr for int2byte. get the integer representation of the first element of bs, return it. get the integer representation of the i-th element of buf, return it. convert byte to its integer representation, return all of the results for every byte in buf. assign StringIO.StringIO to StringIO and BytesIO. call the function _add_doc with 2 arguments: b and string """Byte literal""". call the function _add_doc with 2 arguments: u and string """Text literal""". get 'exec' attribute from the moves.builtins object, substitute it for exec_. if not, if _globs_ is None, call the method sys._getframe with an argument 1, substitute the result for frame. substitute frame.f_globals for _globs_. if _locs_ is None, substitute if _locs_ is None for _locs_. delete frame. substitute _globs_ with an argument _locs_. execute code statement """exec _code_ in _globs_, _locs_""". get attribute 'print' from the moves.builtins object, if it exists substitute it for print_, if not print_ is None. if print_ is None, remover 'file' key from the kwargs dictionary, if it exists substitute it for fp, if not substitute sys.stdout for fp. if fp is None, get 'errors' attribute from fp object, substitute it for errors if it exists, if not errors is None. if errors is None, errors is a string "strict". remove 'sep' key from the kwargs dictionary, if it exists substitute it for sep, if not sep is None. if sep is not None, remove 'end' key from the kwargs dictionary, if it exists substitute it for end, if not end is None. if end is not None, if want_unicode is false, if want_unicode is true, convert newline character to unicode and substitute the result for newline. convert whitespace character to unicode and substitute the result for space. if not, substitute newline character for newline. substitute string " " for space. if sep is None, substitute space for sep. if end is None substitute space for end. if i is true, call the function write with an argument sep. call the function write with an argument arg. call the function write with an argument end. call the function _add_doc with 2 arguments: reraise and string """Reraise an exception.""". substitute type.__call__ for __call__. substitute type.__init__ for __init__. if this_bases is None, call the method type.__new__ with 4 arguments: cls, name, empty tuple and d, return the result. return an instance of metaclass class, created with 3 arguments: string 'temporary_class', None and an empty dictionary. call the method cls.__dict__.copy substitute the result for orig_vars. remove '__dict__' key from the orig_vars dictionary. remove '__weakref__' key from the orig_vars dictionary. get the value under the '__slots__' key of the orig_vars dictionary, substitute it for slots. if slots is not None, slots is a list with an element, slots. for every slots_var in slots, remove slots_var key from the orig_vars dictionary. return an instance of metaclass class, created with 3 arguments: cls.__name__, cls.__bases__ and orig_vars. _assertCountEqual is a strnig "assertCountEqual". _assertRaisesRegex is a strnig "assertRaisesRegex". _assertRegex is a strnig "assertRegex". substitute memoryview for memoryview. buffer_types is a tuple with 3 elements: bytes, bytearray and memoryview. if not, _assertCountEqual is a strnig "assertItemsEqual". _assertRaisesRegex is a strnig "assertRaisesRegexp". _assertRegex is a strnig "assertRegexpMatches". if sys.platform starts with a string 'java', substitute memoryview for memoryview. if not, substitute buffer for memoryview. buffer_types is a tuple with 2 elements bytearray and memoryview. and unpacked dictionary kwargs, return the result. call the function MovedModule with 2 arguments: strings "_dummy_thread" and "dummy_thread", use the result as an argument for the call to the add_move function. call the function MovedModule with 2 arguments: strings "_thread" and "thread", call the method threading.RLock, substitute the result for self.mutex. call the method threading.Semaphore with an argument integer 0, substitute the result for self.can_read. call the method threading.Semaphore with an argument integer 0, substitute the result for self.can_write. call the method self.can_read.release. if not, call the method self.can_read.acquire. call the method self.can_write.release. contextlib.contextmanager decorator, finally perform, call the method self.can_write.release. if not, call the method self.can_write.acquire. call the method self.can_write.release. while t is greater than integer 0, call the method self.can_read.release. decrement t by integer 1, contextlib.contextmanager decorator, finally perform, color_names is a tuple with 8 elements: strings 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan' and 'white'. foreground is a dictionary created with elements: x appended to a string '3' for value under the key x of color_names dictionary, for every x in sequence of integers from 0 to 7. background is a dictionary created with elements: x appended to a string '4' for value under the key x of color_names dictionary, for every x in sequence of integers from 0 to 7. RESET is a string '0'. opt_dict is an dictionary with 5 elements: '1' for 'bold', '4' for 'underscore', '5' for 'blink', '7' for 'reverse', code_list is an empty list. format string '\x1b[%sm' with RESET, return the result. if k equals a string 'fg', for every o in opts, if o is contained in opt_dict, if string 'noreset' is not contained in opts, if text is true format with it and RESET a string '%s\x1b[%sm', if not format it with an empty string and RESET, substitute the result for text. join elements of code_list in a string, separated by ';', format string '\x1b[%sm' with it, append text to the result if exists, return lambda function with text as argument and return value being result of the function colorize, called with 3 arguments: text, opts and unpacked dictionary kwargs. NOCOLOR_PALETTE is a string 'nocolor'. DARK_PALETTE is a string 'dark'. LIGHT_PALETTE is a string 'light'. PALETTES is a dictionary containing 3 elements, a dictionary with 18 pairs of dictionary value and string keys for NOCOLOR_PALETTE, a dictionary with 18 pairs of dictionary value and string keys for DARK_PALETTE, and a dictionary with 18 pairs of dictionary value and string keys for LIGHT_PALETTE. substitute DARK_PALETTE for DEFAULT_PALETTE. if config_string is false, return value under the DEFAULT_PALETTE key of the PALETTES dictionary. convert config_string to lowercase and split it by ';' character, substitute the result for parts. get value under the config_string key of the PALETTES dictionary, call the copy method on the result and substitute it for palette. for every part in parts, if part is contained in PALETTES, get the value under the part key of the PALETTES dictionary, update with it palette dictionary. definition is an empty dictionary, split part by '=' character, substitute the result for role and instructions, respectively. convert role to uppercase. split instructions by ',' character, substitute the result for styles. reverse the order of elements of styles. remove first element from styles, split it by the '/' character, substitute the result for colors. reverse the order of colors elements, remove the first element from colors, substitute it for fg. if fg is contained in color_names, substitute fg for value under the 'fg' key of definition dictionary. if colors is true and last element of colors is contained in color_names, substitute last element of colors for value under the 'bg' key of definition dictionary. opts is a tuple created out of elements s, for every s in styles is s is in the keys of the opt_dict dictionary. if opts is true, substitute opts for value under the 'opts' key of definition dictionary. if role is contained in value under the NOCOLOR_PALETTE key of the PALETTES dictionary and definition is true, substitute definition for value under the role key of palette dictionary. if palette equals value under the NOCOLOR_PALETTE key of the PALETTES dictionary, from gzip import GzipFile into default name space. if six.PY2 is true, if identity lambda function returns false, substitute the x for capfirst, if not call the function force_text with an argument x, convert the first element of the result to uppercase, append to it the rest of the result, substitute it for capfirst. call the function allow_lazy with 3 arguments: capfirst and six.text_type. call the function re.compile with 2 arguments: raw string '<.*?>|((?:\w[-\w]*|&.*?;)+)' and bitwise OR performed with 2 operands, re.U and re.S, substitute the result for re_words. call the function re.compile with 2 arguments: raw string '<.*?>|(.)' and bitwise OR performed with 2 operands, re.U and re.S, substitute the result for re_chars. call the function re.compile with 2 arguments: raw string '<(/)?([^ ]+?)(?:(\s*/)| .*?)?>' and bitwise OR performed with 2 operands, re.U and re.S, substitute the result for re_chars. call the function re.compile with an argument raw string '\r\n|\r', substitute the result for re_newlines. call the function re.compile with an argument raw string '(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', substitute the result for re_camel_case. call the function force_text with an argument text, substitute the result for text. if line ends with a new line character substitute width incremented by integer 1 for max_width, if not substitute width for max_width. get fist max_width incremented by 1 elements from line, find index of the first occurrenece of whitespace from the right side, add integer 1 to it, substitute the result for space. if space equals integer 0, find first index of whitespace occurrence in line, add integer 1 to it, substitute the result for space. if space equals integer 0, line is an empty string. remove all the elements from space index of line. if line ends with a new line character substitute width incremented by integer 1 for max_width, if not substitute width for max_width. if line is true, call the function allow_lazy with 2 arguments: wrap and six.text_type, substitute the result for wrap. if truncate is None, call the function pgettext with an argument 'String to return when truncating text', '%(truncated_text)s...', substitute the result for truncate. call the function force_text with an argument truncate, substitute the result for truncate. if string '%(truncated_text)s' is contained in truncate, format truncate with a dictionary with an element: text for 'truncated_text', return the result. if text ends with truncate, convert num to an integer, substitute it for length. call the function unicodedata.normalize with 2 arguments: string 'NFC' and self._wrapped, substitute the result for text. substitute length for truncate_len. for every char in result of the self.add_truncation_text, called with 2 arguments: an empty string and truncate. call the method unicodedata.combining with an argument char, if it evaluates to false, decrement truncate_len by integer 1. if truncate_len equals integer 0. if html is true, call the function self._truncate_html with 5 arguments: length, truncate, text, truncate_len and boolean False, return the result. call the method self._text_chars with 4 arguments: length, truncate, text and truncate_len, return the result. call the function allow_lazy with an argument chars, substitute the result for chars. s_len is integer 0. end_index is None. for every i and char in enumerated text, call the function unicodedata.combining with an argument char, if it evaluates to true, increment s_len by integer 1, if end_index is None and s_len is greater than truncate_len, substitute i for end_index. if s_len is greater than length, call the method self.add_truncation_text with 2 arguments: if end_index is greater than zero, first end_index elements of text, convert num to an integer, substitute the result for length. if html is true, call the method self._text_words with 2 arguments length and truncate, return the result. call the function allow_lazy with an argument words, substitute the result for words. split self._wrapped into words, substitute the result for words. substitute first length elements of words for words. call the method self.add_truncation_text with 2 arguments: elements of words joined in a string, separated with whitespaces, if words is not empty and length is smaller than or equal to integer 0, html4_singlets is a tuple with 9 elements: strings 'br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr' and 'input'. pos is equal to integer 0. end_text_pos is equal to integer 0. current_len is equal to integer 0. open_tags is an empty list. if words is true, substitute re_words for regex, if not substitute re_chars for regex. while current_len is smaller than or equal to length, call the method regex.search with 2 arguments: text and pos. if m is false, call the method m.end with an argument integer 0, substitute the result for pos. call the function m.group, if the result evaluates to true, increment current_len by integer 1, if current_len equals truncate_len, substitute pos for end_text_pos. convert tagname to lowercase, substitute it for tagname. if self_closing is true or tagname is contained in html4_singlets, get the index of the first occurrence of tagname, substitute it for i. if not, create a list out of open_tags elements form (i+1)-th index to the end, substitute it for open_tags. if not, insert tagname at the beginning of open_tags. if current_len is smaller than or equal to length, create a list out of fist end_text_pos text elemnts, substitue it for out. call the method self.add_truncation_text with 2 arguments: an empty string and truncate, substitute it for truncate_text. if truncate_text is true, append truncate_text to out. call the function force_text with an argument s, strip the result of whitespaces from both ends, call the function allow_lazy with 2 arguments: get_valid_filename and six.text_type, substitute the result for get_valid_filename. return a string '%s %s %s' formated with 3 elements: result of the function force_text called with an argument i, separated by result of the function _ called with an argument string ', ', for every i in list_ without last element, result of the function force_text called with an argument last_word, result of the function force_text called with an argument: last element of list_. call the function allow_lazy with 2 arguments: get_text_list and six.text_type, substitute the result for get_text_list. call the function force_text with an argument text, substitute the result for text. call the method re_newlines.sub with 2 arguments: '\n' and text, return the result. call the function allow_lazy with 2 arguments: normalize_newlines and six.text_type, substitute the result for normalize_newlines. char2number is an dictionary, with 26 elements: 2 for 'a', 2 for 'b', 2 for 'c', 3 for 'd', 3 for 'e', 3 for 'f', 4 for 'g', 4 for 'h', 4 for 'i', 4 for 'j', 5 for 'k', 5 for 'l', 5 for 'm', 6 for 'n', 6 for 'o', 6 for 'p', 7 for 'q', 7 for 'r', 7 for 'r', 7 for 's', 7 for 't', 8 for 't', 8 for 'u', 8 for 'v', 9 for 'w', 9 for 'x', 9 for 'y' and 9 for 'z'. for every c in phone converted to lowercase, join the value under the c key of the char2number dictionary into a string, return it. call the function allow_lazy with an argument phone2numeric, substitute the result for phone2numeric. zbuf is an instance of BytesIO class. zfile is an instance of GzipFile class, created with 3 arguments: mode set to string 'wb', compresslevel set to integer 6, and fileobj set to zbuf. call the method zfile.write with an argument s. call the method zfile.close. call the method zbuf.getvalue, return the result. join elements of self.vals into a bytes string, substitute the result for ret. buf is an instance of StreamingBuffer class. zfile is an instance of GzipFile class, created with 3 arguments: mode set to string 'wb', compresslevel set to integer 6, for every item in sequence, write item to zfile stream. flush zfile stream buffer. close zfile stream. call the function re.compile with an argument string "([\u0080-\uffff])", substitute the result for ustring_re. call the function warnings.warn with 3 arguments: msg, RemovedInDjango19Warning and stacklevel as integer 2. get the unicode representation of result of the method match.group called with an integer 1, format with in a string "\\u%04x", return the result. if type of s equals bytes, call the method s.decode with an argument string 'utf-8', substitute the result for s. replace every occurrence of '\\' in s with '\\\\'. replace every occurrence of '\r' in s with '\\r'. replace every occurrence of '\n' in s with '\\n'. replace every occurrence of '\t' in s with '\\t'. replace every occurrence of "'" in s with "\\'". replace every occurrence of '", where '%s' is replaced with self.__language. call the method gettext_module.translation with 5 arguments: domain set to string 'django', localedir set to localedir, languages set to a list with an element self.__locale, codeset set to a string 'utf-8' and fallback set to use_null_fallback, substitute the result for translation. if translation has an attribute '_catalog', translation._catalog is an empty dictionary. translation._info is an empty dictionary. get the value under the settings.__module__ key of the sys.modules dictionary, call the function self._new_gnu_trans with 2 arguments: localedir and use_null_fallback, substitute the result for translation. call the method translation._info.copy, substitute the result for self._info. call the method translation._catalog.copy, substitute the result for self._catalog. call the method apps.get_app_configs, convert the result in a list, reverse the order of elements, substitute the result for app_configs. if AppRegistryNotReady exception is caught, rais an AppRegistryNotReady exception with an argument string "The translation infrastructure cannot be initialized before the " call the method self._new_gnu_trans with an argument localedir, substitute the result for translation. call the function self._new_gnu_trans with an argument localedir, substitute the result for translation. call the method self.add_fallback with an argument default_translation. update the self._catalog dictionary with other._catalog. use global variable _translations. if language is not contained in _translations, _translations dictionary value, under the language key is an instance of DjangoTranslation class, created with an argument language. if language is contained in _DJANGO_DEPRECATED_LOCALES, msg is a string "The use of the language code '%s' is deprecated. Please use the '%s' translation instead.". call the method call the function warnings.warn with 3 arguments: msg formatted with language and value under the language key, call the method gettext_module.NullTranslations, substitute the result for _active.value. if t is not None, if AttributeError exception is caught, call the function get_language, split the result by '-', substitute the first element of the result for base_lang. use global variable _default. if t is not None if _default is None use global variable _default. replace every occurrence of string '\r\n' in message with '\n', replace every occurrence of string '\r', if t is not None, get translation_function attribute of the object t, call the result with an argument eol_message, substitute the result for result. if not, if _default is None, get translation_function attribute of the object _default, call the result with an argument eol_message, substitute the result for result. substitute gettext for ugettext. if not, call the function ugettext with an argument msg_with_ctxt, substitute the result for result. if CONTEXT_SEPARATOR is contained in result, use global variable _default. if t is not None, get translation_function attribute of the t object, call the result with 3 arguments: singular, plural and number, return the result. if _default is None, get translation_function attribute of the _default object, call the result with 3 arguments: singular, plural and number, return the result. call the function do_ntranslate with 3 arguments: singular, plural, number and string 'ngettext', return the result. substitute ngettext for ungettext. if not, call the function do_ntranslate with 3 arguments: singular, plural, number and string 'ngettext', return the result. msgs_with_ctxt is a tuple containing 2 elements: string created by concatenating context, CONTEXT_SEPARATOR and singular, string created by concatenating context, CONTEXT_SEPARATOR and plural and number. call the function ungettext with unpacked dictionary msgs_with_ctxt, substitute the result for result. if CONTEXT_SEPARATOR is contained in result, call the function ungettext with 3 arguments: singular, plural and number, substitute the result for result. decorator function lru_cache.lru_cache with an argument maxsize set to integer 1000. call the method language_code_re.search with an argument lang_code, if it evaluates to false, call the method gettext_module.find with 3 arguments: string 'django', path and list with an element: result of the function, decorator function lru_cache.lru_cache with an argument maxsize set to integer 1000. use global variable _supported. if _supported is None, if lang_code is true, get the value under the lang_code key of the _BROWSERS_DEPRECATED_LOCALES dictionary, substitute it for replacement. if lang_code is not contained in _supported and replacement is contained in _supported, split lang_code by '-', substitute the first element of the result for generic_lang_code. for every code in tuple with 2 elements: lang_code and generic_lang_code, if code is contained in _supported and call to the function check_for_language with an argument code evaluates to true, if strict is false, for every supported_code in _supported, append '-' to generic_lang_code, if supported_code starts with it, if regex_match is false, call the method regex_match.group with an argument integer 1, substitute the result for lang_code. call the function get_supported_language_variant with 2 arguments: lang_code and strict set to strict, return the result. if LookupError exception is caught, use global variable _supported. if _supported is None, if check_path is true, if lang_code is not None, if lang_code is contained in _supported and lang_code is not None and result of the function check_for_language, call the function get_supported_language_variant with an argument lang_code, return the result. if LookupError exception is caught, if not accept is an empty string. call the function parse_accept_lang_header with an argument accept, for every accept_lang and unused in the result, if accept_lang equals '*', call the method language_code_re.search with an argument accept_lang, if it evaluates to false, call the function get_supported_language_variant with an argument accept_lang, return the result. if LookupError exception is caught, if LookupError exception is caught, call the function re.compile with an argument raw string '\S', substitute it for dot_re. call the method dot_re.sub with 2 arguments: char and src, return the result. call the function re.compile with an argument raw string "^\s+.*context\s+((?:"[^"]*?")|(?:'[^']*?'))\s*", substitute the result for context_re. call the function re.compile with an argument string "^\s*trans\s+((?:"[^"]*?")|(?:'[^']*?'))(\s+.*context\s+((?:"[^"]*?")|(?:'[^']*?')))?\s*", substitute the result for inline_re. call the function re.compile with an argument raw string "^\s*blocktrans(\s+.*context\s+((?:"[^"]*?")|(?:'[^']*?')))?(?:\s+|$)", substitute the result for block_re. call the function re.compile with an argument raw string "^\s*endblocktrans$", substitute the result for endblock_re. call the function re.compile with an argument raw string "^\s*plural$", substitute the result for plural_re. call the function re.compile with an argument raw string "_\(((?:".*?")|(?:'.*?'))\)", substitute the result for constant_re. call the function re.compile with an argument raw string "(?