Datasets:

AhmedSSoliman

/

DJANGO

like 2

yield obj, as an return value of the generator.

yield obj

define the function is_ignored with arguments path and ignore_patterns.

def is_ignored ( path , ignore_patterns ) :

zip elements of result and result_args into a list of tuples, for every item and args in the result,

for item , args in zip ( result , result_args ) :

try,

try :

dest as a string 'ignore', default set to boolean False and help set to string 'Ignores entries in the serialized data for fields that do not currently exist on the model.'. define the method handle with 3 arguments: self, unpacked list fixture_labels and unpacked dictionary options.

def handle ( self , * fixture_labels , ** options ) :

call the method cls.__promise__ with 3 arguments: resultclass, k and v, substitute the result for meth.

meth = cls . __promise__ ( resultclass , k , v )

if IndexError exception is caught,

except IndexError :

call the method apps.get_app_configs, for app_config in the result,

for app_config in apps . get_app_configs ( ) :

self._errors is an empty list.

self . _errors = [ ]

derive class LimitedStream from the object base class, making it a new-style class.

class LimitedStream ( object ) :

if VariableDoesNotExist exception is caught,

except VariableDoesNotExist :

if fext is a file,

if os . path . isfile ( fext ) :

call the method self.stdout.write with an argument string 'examining files with the extensions: %s\n',

self . stdout . write ( 'examining files with the extensions: %s\n' % get_text_list ( list ( self . extensions ) , 'and' ) )

define the function remove_tags with 2 arguments: html and tags.

def remove_tags ( html , tags ) :

call the function force_str with an argument quoted_url, use the result as an argument for the call to the function unquote,

return force_text ( unquote ( force_str ( quoted_url ) ) )

call the method self._delete with argument k.

self . _delete ( k )

if name is not None,

if name is not None :

from django.template.loader import BaseLoader into default name space.

from django . template . loader import BaseLoader

define the function valid_ident with an argument s.

def valid_ident ( s ) :

define the method __getattr__ with 2 arguments: self and attr set to None.

def __getattr__ ( self , attr ) :

if ImportError exception is caught,

except ImportError :

value under the self.var_name key of the context dictionary is an empty list.

context [ self . var_name ] = [ ]

otherwise, length of options.args is lesser than integer 1,

elif len ( options . args ) < 1 :

and dictionary of arbitrary length **kwargs as arguments. call the initialization method for the base class, _html_parser.HTMLParser.__init__ with self,

_html_parser . HTMLParser . __init__ ( self , convert_charrefs = convert_charrefs , ** kwargs )

if UnicodeError exception is caught,

except UnicodeError :

if length of fks_to_parent equals integer 1.

if len ( fks_to_parent ) == 1 :

return self.

return self

if nesting is false,

if not nesting :

import module os.

import os

if not,

else :

define the method __bytes_cast with an argument self.

def __bytes_cast ( self ) :

for every format in BUILTIN_SERIALIZERS,

for format in BUILTIN_SERIALIZERS :

define the function validate_ipv46_address with an argument value.

def validate_ipv46_address ( value ) :

'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'.

MEDIA_TYPES = ( 'css' , 'js' )

return cls.

return cls

if empty_label is not None,

if empty_label is not None :

substitute lib for value under the library_name key of libraries dictionary.

libraries [ library_name ] = lib

return it. if PY3 is true,

if PY3 :

do nothing

pass

yield subnode.

yield subnode

call the function sql_create with 3 arguments: app_config, self.style and connection, substitute the result for statements.

statements = sql_create ( app_config , self . style , connection )

define the function get_urlconf with an argument default set to None.

def get_urlconf ( default = None ) :

return self._queryset.

return self . _queryset

call the function allow_lazy with 2 arguments: normalize_newlines and six.text_type, substitute the result for normalize_newlines.

normalize_newlines = allow_lazy ( normalize_newlines , six . text_type )

if err_log is true,

if err_log :

define the method content with an argument self.

def content ( self ) :

call the private dict.__setitem__ method with self class instance, key and M as arguments.

dict . __setitem__ ( self , key , M )

define the method __init__ with 3 arguments: self, attrs set to None and choices set to an empty tuple.

def __init__ ( self , attrs = None , choices = ( ) ) :

define the function find_filter with 2 arguments: self and filter_name.

def find_filter ( self , filter_name ) :

call the method parser.add_library with an argument lib.

parser . add_library ( lib )

call the function re.compile with 2 arguments: raw string "((?:[^\s'"]*(?:(?:"(?:[^"\\]|\\.)*" | '(?:[^'\\]|\\.)*')[^\s'"]*)+) | \+)",

smart_split_re = re . compile ( r""" ((?: [^\s'"]* (?: (?:"(?:[^"\\]|\\.)*" | '(?:[^'\\]|\\.)*') [^\s'"]* )+ ) | \S+) """ , re . VERBOSE )

break the loop execution.

break

if settings.FORCE_SCRIPT_NAME is not None,

if settings . FORCE_SCRIPT_NAME is not None :

call the method self.set_cdata_mode with tag as the argument.

self . set_cdata_mode ( tag )

result_args is a list containing an empty list.

result_args = [ [ ] ]

call the method transaction.get_autocommit with an argument self.using, if it evaluates to true,

if transaction . get_autocommit ( self . using ) :

raise an exception.

raise

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,

return self . show_migration_list ( connection , [ options [ 'app_label' ] ] if options [ 'app_label' ] else None )

substitute the result for self.instance. try,

try :

from django.apps import apps into default name space.

from django . apps import apps

substitute logging.getLogger for getLogger.

getLogger = logging . getLogger

substitute sysid for self.sysid.

self . sysid = sysid

return a string '%s(%s)' formated with self.__class__.__name__ and dictreprs.

return '%s(%s)' % ( self . __class__ . __name__ , dictreprs )

substitute '%r' in string ' gettext(%r) ' with result of the function join_tokens, called with 2 arguments: singular,

out . write ( ' gettext(%r) ' % join_tokens ( singular , trimmed ) )

try,

try :

define the function to_locale with 2 arguments language and to_lower set to boolean False.

def to_locale ( language , to_lower = False ) :

if quote_double_quotes is true,

if quote_double_quotes :

call the function prepare_js_for_gettext with an argument src_data, substitute it for src_data.

src_data = prepare_js_for_gettext ( src_data )

get the value under the 'interactive' key of the options dictionary, substitute it for self.interactive.

self . interactive = options . get ( 'interactive' )

define the function deactivate_all.

def deactivate_all ( ) :

substitute value under the 'use_reloader' key of the options dictionary for use_reloader.

use_reloader = options . get ( 'use_reloader' )

derive the class ConvertingList from list base class.

class ConvertingList ( list ) :

call the function is_aware with an argument date, if it evaluates to true,

if is_aware ( date ) :

if self.verbosity is greater than integer 0,

if self . verbosity > 0 :

msg is a string "%s doesn't look like a module path" formated with dotted_path.

msg = "%s doesn't look like a module path" % dotted_path

from django.core.mail.message import sanitize_address into default name space.

from django . core . mail . message import sanitize_address

from __future__ import unicode_literals into default name space.

from __future__ import unicode_literals

define the function get_git_changeset.

def get_git_changeset ( ) :

substitute message.error_dict for message.

message = message . error_dict

i is the reminder of the division of i by j.

i = i % j

add ns_pattern and extra, substitute the result for ns_pattern.

ns_pattern = ns_pattern + extra

from django.core.management.base import AppCommand into default name space.

from django . core . management . base import AppCommand

substitute subject for self.subject.

self . subject = subject

return list_ and boolean False.

return list_ , False

define the method __init__ with 2 arguments: self and s.

def __init__ ( self , s ) :

remove first two elements from bits.

bits = bits [ 2 : ]

if self.fail_silently is false,

if not self . fail_silently :

define the method __init__ with arguments: self, unpacked list args and unpacked dictionary kwargs.

def __init__ ( self , * args , ** kwargs ) :

return a dictionary with 2 elements: self._version for "version" and "http://www.w3.org/2005/Atom" for "xmlns:atom".

return { "version" : self . _version , "xmlns:atom" : "http://www.w3.org/2005/Atom" }

substitute old_attr for new_attr.

new_attr = old_attr

sum lead and opening, substitute the result for lead.

lead = lead + opening

if self.use_ipv6 substitute string '::1' for self.addr, if not substitute '127.0.0.1' for self.addr.

self . addr = '::1' if self . use_ipv6 else '127.0.0.1'

msg is a string "Could not decode base64 data: %r", where '%r' is replace with e.

msg = "Could not decode base64 data: %r" % e

substitute name for self.name.

self . name = name

add bits to a tuple, return it.

return tuple ( bits )

call the method value.astimezone with an argument timezone, substitute the result for value.

value = value . astimezone ( timezone )

if LookupError exception is caught,

except LookupError :

format string ' pgettext(%r, %r) ' with message_context and g, write it to out.

out . write ( ' pgettext(%r, %r) ' % ( message_context , g ) )

return iterable self.keyOrder.

return iter ( self . keyOrder )

if not,

else :