Datasets:

AhmedSSoliman

/

DJANGO

like 2

if func is None,

if func is None :

join trans_bit into a string separated with whitespaces, substitute the result for bit.

bit = ' ' . join ( trans_bit )

derive the class ErrorList from the UserList and list base classes.

class ErrorList ( UserList , list ) :

call the function force_text with an argument formatstr, use the result as an argument for the call to the method,

for i , piece in enumerate ( re_formatchars . split ( force_text ( formatstr ) ) ) :

call the method archive.extract with arguments: filename and tempdir.

archive . extract ( filename , tempdir )

from django.core.mail.backends.base import BaseEmailBackend into default name space.

from django . core . mail . backends . base import BaseEmailBackend

form._meta.fields is a list created out of form._meta.fields elements.

form . _meta . fields = list ( form . _meta . fields )

call the function local, substitute the result _urlconf.

_urlconfs = local ( )

raise an exception.

raise

substitute last for value under the PREV key of the link dictionary.

link [ PREV ] = last

substitute unicode for text_type.

text_type = unicode

call the method self.unclosed_block_tag with an argument parse_until.

self . unclosed_block_tag ( parse_until )

substitute value under name key of handlers dictionary for handler_config.

handler_config = handlers [ name ]

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.

tzinfo = kw . pop ( 'tzinfo' )

decrement self.waiting_writers by integer 1,

self . waiting_writers -= 1

import module os.

import os

call the method value.encode with an argument charset.

value . encode ( charset )

and help is a string 'Module paths to test; can be modulename, modulename.TestCase or modulename.TestCase.test_method'. call the method parser.add_argument with 5 arguments: string '--noinput', action set to 'store_false', dest set to 'interactive',

parser . add_argument ( '--noinput' , action = 'store_false' , dest = 'interactive' , default = True , help = 'Tells Django to NOT prompt the user for input of any kind.' ) ,

allow_files set to boolean True, allow_folders set to boolean False, required set to boolean True, widget set to None, label set to None, initial set to None, help_text set to an empty string, unpacked list args, unpacked dictionary kwargs. substitute path, match and recursive for self.path, self.match and self.recursive.

self . path , self . match , self . recursive = path , match , recursive

unpack dictionary kwargs, map it through self.attrs and convert to dictionary, substitute the result for attrs.

attrs = dict ( self . attrs , ** kwargs )

append label_output to output.

output . append ( label_output )

for every field in return value of the function _parse_date_fmt,

for field in _parse_date_fmt ( ) :

raise an ImportError exception.

raise ImportError

from __future__ import unicode_literals into default name space.

from __future__ import unicode_literals

call the method _isdst with an argument dt from the base class of the class LocalTimezone, return the result.

return super ( LocalTimezone , self ) . _isdst ( dt )

increment self.active_writers by 1.

self . active_writers += 1

define the method get with 4 arguments, self class instance, key, default set to None and version set to None.

def get ( self , key , default = None , version = None ) :

import module mimetypes.

import mimetypes

if password is None substitute settings.EMAIL_HOST_PASSWORD for self.username, if not substitute password for self.password.

self . password = settings . EMAIL_HOST_PASSWORD if password is None else password

call the function new_method_proxy with an argument bool, substitute the result for __bool__.

__bool__ = new_method_proxy ( bool )

if not,

else :

if not,

else :

get _assertCountEqual attribute of the self object, call the result with 2 arguments: unpacked list args,

return getattr ( self , _assertCountEqual ) ( * args , ** kwargs )

raise an base.DeserializationError exception with an argument string "Invalid model identifier: '%s'", where '%s' is replaced with model_identifier.

raise base . DeserializationError ( "Invalid model identifier: '%s'" % model_identifier )

where '%s' is replaced with final_path and base_path. return final_path.

return final_path

return an empty string.

return ''

call the method out.getvalue, return the result.

return out . getvalue ( )

call the function post_callback with an argument retval, substitute the result for newretval.

newretval = post_callback ( retval )

if not,

else :

call the method s.render with 3 arguments: field string formated with name, val and local_attrs, substitute the result for select_html.

select_html = s . render ( field % name , val , local_attrs )

call the force_str function with an argument value, substitute the result for value.

value = force_str ( value )

derive the class SafeMIMEMultipart from the MIMEMixin and MIMEMultipart base class.

class SafeMIMEMultipart ( MIMEMixin , MIMEMultipart ) :

call the method context.render_context.push.

context . render_context . push ( )

try,

try :

decorator function register.filter with an argument is_safe set to boolean False.

@ register . filter ( is_safe = False )

split s into parts by '.', substitute the result for name.

name = s . split ( '.' )

and help set to 'Fixture labels.'. call the method parser.add_argument with 5 arguments: string '--database', action set to string 'store', dest as a string 'database',

parser . add_argument ( '--database' , action = 'store' , dest = 'database' , default = DEFAULT_DB_ALIAS , help = 'Nominates a specific database to load ' 'fixtures into. Defaults to the "default" database.' )

define the method __init__ with 3 arguments: self, value and text.

def __init__ ( self , value , text ) :

define the function add_metaclass with an argument metaclass.

def add_metaclass ( metaclass ) :

return boolean False.

return False

derive the class Library form the base class object.

class Library ( object ) :

if character is not equal to a string '.',

if character != '.' :

raise an base.DeserializationError exception with an argument string "<%s> node has invalid model identifier: '%s'",

raise base . DeserializationError ( "<%s> node has invalid model identifier: '%s'" % ( node . nodeName , model_identifier ) )

return commands.

return commands

if not,

else :

call the field.to_python method with field_value, substitute the result for field.name key of the data dictionary.

data [ field . name ] = field . to_python ( field_value )

try,

try :

derive the class Operator from the base class TokenBase.

class Operator ( TokenBase ) :

define the method resolve_expression with 3 arguments: self, obj and context.

def resolve_expression ( self , obj , context ) :

derive the class HttpResponseGone from the HttpResponse base class.

class HttpResponseGone ( HttpResponse ) :

return an instance of SafeBytes, created with an argument t.

return SafeBytes ( t )

if commit is true and form has an attribute 'save_m2m',

if commit and hasattr ( form , 'save_m2m' ) :

define the method render with 5 arguments: self, name, value, attrs set to None and choices set to an empty tuple.

def render ( self , name , value , attrs = None , choices = ( ) ) :

call the self.get_dum_object method with an argument obj, use the result as an argument for the self.objects.append method.

self . objects . append ( self . get_dump_object ( obj ) )

call the function new_method_proxy with an argument operator.ne, substitute the result for __ne__.

__ne__ = new_method_proxy ( operator . ne )

return self.

return self

substitute length of values for len_values.

len_values = len ( values )

self._raw_ipv6 is boolean True.

self . _raw_ipv6 = True

if ImportError exception is caught.

except ImportError :

return obj.

return obj

from .html_parser import HTMLParser and HTMLParseError into default name space.

from . html_parser import HTMLParser , HTMLParseError

decorator function register.filter with an argument is_safe set to boolean True.

@ register . filter ( is_safe = True )

get the value under the LANGUAGE_SESSION_KEY key of the request.session dictionary, substitute it for lang_code.

lang_code = request . session . get ( LANGUAGE_SESSION_KEY )

define the function linenumbers with 2 arguments value and autoescape set to None.

def linenumbers ( value , autoescape = None ) :

substitute value for self.value.

self . value = value

if self doesnt have '_queryset' attribute,

if not hasattr ( self , '_queryset' ) :

substitute new_filenames for filelist.

filelist = new_filenames

try,

try :

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,

with open ( old_path , 'rb' ) as template_file :

import module struc.

import struct

from django.utils.six import StringIO into default name space.

from django . utils . six import StringIO

return EventHandler.modified_code.

return EventHandler . modified_code

substitute takes_context for self.takes_context.

self . takes_context = takes_context

from __future__ import absolute_import into default name space.

from __future__ import absolute_import

sort the result and substitute it for options. for every option in options,

for option in options :

value is None.

value = None

try,

try :

substitute TemplateDoesNotExist for self.find_template_cache dictionary value under the key key.

self . template_cache [ key ] = TemplateDoesNotExist

call the function become_daemon with 2 arguments: our_home_dir set to the value under the 'workdir' key of options dictionary and,

become_daemon ( our_home_dir = options [ "workdir" ] , ** daemon_kwargs )

derive the class TemplateSyntaxError form the base class Exception.

class TemplateSyntaxError ( Exception ) :

define the method __len__ with an argument self.

def __len__ ( self ) :

ns_pattern is an empty string.

ns_pattern = ''

month_field is a string '%s_month'.

month_field = '%s_month'

if self.parsed is true,

if self . parsed :

call the function func with unpacked dictionary kwargs as an argument, substitute the result for translated.

translated = func ( ** kwargs )

substitute return value of call to the function _set_response_etag with response as an argument, for response.

response = _set_response_etag ( response )

return an empty string.

return ''

call the function predicate with an argument item, use it as a key to get results dictionary value, append item to it.

results [ predicate ( item ) ] . append ( item )

if attr equals any of the strings "__file__", "__name__" or "__path__" and self.mod is not contained in sys.modules,

if ( attr in ( "__file__" , "__name__" , "__path__" ) and self . mod not in sys . modules ) :

extend errors list with e.error_list.

errors . extend ( e . error_list )