Datasets:

AhmedSSoliman

/

DJANGO

like 2

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.

MAXSIZE = int ( ( 1 << 31 ) - 1 )

add params to extra_params dictionary.

extra_params . update ( params )

self.field.choice_cache is a list containing results of the method self.choice called with an argument obj,

self . field . choice_cache = [ self . choice ( obj ) for obj in self . queryset . all ( ) ]

update defaults dictionary with kwargs.

defaults . update ( kwargs )

matches is boolean True,

matches = True

derive the class EmailMultiAlternatives from the EmailMessage base class.

class EmailMultiAlternatives ( EmailMessage ) :

call the function get_commands, substitute it for commands.

commands = get_commands ( )

define the method get_connection with arguments self and fail_silently set to boolean False.

def get_connection ( self , fail_silently = False ) :

if not,

else :

from functools import update_wrapper.

from functools import update_wrapper

get is a string '<could not parse>'.

get = '<could not parse>'

if not,

else :

from django.template.base import Variable, Library and VariableDoesNotExist into default name space.

from django . template . base import Variable , Library , VariableDoesNotExist

define the function reset_translation.

def reset_translations ( ) :

try,

try :

define the method regex with an argument self.

def regex ( self ) :

return settings.TEMPLATE_STRING_IF_INVALID.

return settings . TEMPLATE_STRING_IF_INVALID

call the method tag.groups, substitute the result for closing_tag, tagname and self_closing, respectively.

closing_tag , tagname , self_closing = tag . groups ( )

return settings.LANGUAGE_CODE.

return settings . LANGUAGE_CODE

from django.template.base import TemplateDoesNotExist into default name space.

from django . template . base import TemplateDoesNotExist

get the value under the key key of the self.find_template_cache dictionary, substitute it for result.

result = self . find_template_cache [ key ]

result of the function force_text with an argument option_label, return the result. define the method render_options with 3 arguments: self, choices and selected_choices.

def render_options ( self , choices , selected_choices ) :

derive the class Command from the BaseCommand base class.

class Command ( BaseCommand ) :

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.

post_sql_fields = [ f for f in opts . local_fields if hasattr ( f , 'post_create_sql' ) ]

substitute self.max_value for the value under the 'max' key of the attrs dictionary.

attrs [ 'max' ] = self . max_value

convert filename to lowercase, use the result as an argument for the call to the function os.path.splitext,

base , tail_ext = os . path . splitext ( filename . lower ( ) )

define the method empty_variable with 2 arguments: self and token.

def empty_variable ( self , token ) :

raise an TypeError exception with an argument string 'Level not an integer or a valid string: %r' formated with level.

raise TypeError ( 'Level not an integer or a ' 'valid string: %r' % level )

get the value under the self key of the context.render_context dictionary, substitute it for cycle_iter.

cycle_iter = context . render_context [ self ]

flush the output buffer of the self.stdout object.

self . stdout . flush ( )

derive the class SerializationError from the Exception base class.

class SerializationError ( Exception ) :

call the BaseCache initialization method __init__ with 3 arguments self, list of arguments args and dictionary of arguments kwargs.

BaseCache . __init__ ( self , * args , ** kwargs )

define the method render with 4 arguments: self, name, value and attrs set to None.

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

assign it to value under the string ".moves.urllib_robotparser" appended to __name__ key of the sys.modules dictionary, and to value under the string ".moves.urllib.robotparser" appended to __name__ key of the sys.modules dictionary. derive class Module_six_moves_urllib from the types.ModuleType base class.

class Module_six_moves_urllib ( types . ModuleType ) :

substitute '%s' in string '%s %s' with the elements of value converted into a tuple, substitute the result for value.

value = '%s %s' % tuple ( value )

delete Trans.

del Trans

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.

hour , minute = divmod ( timezone , 60 )

call the method value.encode with an argument self._charset, use the result as an argument for the call to the bytes function,

return bytes ( value . encode ( self . _charset ) )

break from the loop execution,

break

convert tagname to lowercase, substitute it for tagname.

tagname = tagname . lower ( )

if self.is_bound is false,

if not self . is_bound :

if not,

else :

call the get_script_name function with environ as argument, substitute the result for script_name.

script_name = get_script_name ( environ )

if domain equals a string 'djangojs' and file_ext is contained in command.extensions,

if domain == 'djangojs' and file_ext in command . extensions :

return value.

return value

with an argument i, append the result to a list, substitute the resulting list for forms. return forms.

return forms

use the global variable _serializers.

global _serializers

substitute ending for self.ending.

self . ending = ending

get value under the BLOCK_CONTEXT_KEY key of context.render_context dictionary, substitute it for block_context.

block_context = context . render_context . get ( BLOCK_CONTEXT_KEY )

derive the class VariableDoesNotExist form the base class Exception.

class VariableDoesNotExist ( Exception ) :

if fp is an instance of file and data is an instance of unicode and fp.encoding is not None,

if ( isinstance ( fp , file ) and isinstance ( data , unicode ) and fp . encoding is not None ) :

call the function _load_serializers.

_load_serializers ( )

define the method changed_data with an argument self.

def changed_data ( self ) :

and ip_address_validator_map converted to a list, respectively. call the re.compile function with an argument raw string '^[\d,]+$', substitute the result for comma_separated_int_list_re.

comma_separated_int_list_re = re . compile ( '^[\d,]+$' )

define the method __init__ with arguments: self and options set to None.

def __init__ ( self , options = None ) :

if elt is an instance of NonCapture class,

if isinstance ( elt , NonCapture ) :

append decimals to parts.

parts . append ( decimals )

call the serializer function, call the dumps method on the result with an argument obj, substitute result for data.

data = serializer ( ) . dumps ( obj )

evaluate the method self._cache.decr with key and negative delta as arguments, return the result.

return self . _cache . decr ( key , - delta )

substitute nodelist_true and nodelist_false for self.nodelist_true and self.nodelist_false, respectively.

self . nodelist_true , self . nodelist_false = nodelist_true , nodelist_false

for every label in labels,

for label in labels :

derive class InvalidCacheBackendError from the ImproperlyConfigured base class.

class InvalidCacheBackendError ( ImproperlyConfigured ) :

if result is not None,

if result is not None :

define the method __init__ with 6 arguments: self, name, old_mod, new_mod, old_attr set to None, new_attr set to None.

def __init__ ( self , name , old_mod , new_mod , old_attr = None , new_attr = None ) :

status_code is an integer 405.

status_code = 405

self.second is None.

self . second = None

call the method f.save_form_data with 2 arguments: instance and value under the f.name key of cleaned_data dictionary.

f . save_form_data ( instance , cleaned_data [ f . name ] )

get the 'value' attribute of the _urlconfs, if it exists return it, otherwise return defaults.

return getattr ( _urlconfs , "value" , default )

raise an exception of class NotImplementedError, with string 'subclasses of BaseCache must provide a get() method' as argument.

raise NotImplementedError ( 'subclasses of BaseCache must provide a get() method' )

substitute tempfile.gettempdir for gettempdir.

gettempdir = tempfile . gettempdir

define the method __init__ with 2 arguments: self and attrs set to None.

def __init__ ( self , attrs = None ) :

paths is a list containing results of the function force_text called with an argument p, for every p in paths.

paths = [ force_text ( p ) for p in paths ]

from unittest import import everything.

from unittest import *

read chunk_size bytes from file and store it in data.

data = file . read ( chunk_size )

for every dirpath, dirnames and locale_filenames in directory tree starting at the basedir directory.

for dirpath , dirnames , locale_filenames in os . walk ( basedir ) :

for every obj in result of the method self.queryset.all. for every choice in self.field.choice_cache,

for choice in self . field . choice_cache :

if ValueError, TypeError or ValidationError exception is caught,

except ( ValueError , TypeError , ValidationError ) :

_meth_self is a string "__self__".

_meth_self = "__self__"

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,

if run_syncdb and executor . loader . unmigrated_apps :

raise an exception.

raise

define the method __getitem__ with 2 arguments: self and idx.

def __getitem__ ( self , idx ) :

self.cookies is an instance of SimpleCookie class created with self.cookies as an argument.

self . cookies = SimpleCookie ( self . cookies )

define the method __init__ with 4 arguments: self, form, field and name.

def __init__ ( self , form , field , name ) :

call the method match.groupdict, substitute the result for kw.

kw = match . groupdict ( )

define the method __bool__ with an argument self.

def __bool__ ( self ) :

if InvalidTemplateLibrary, renamed to e, exception is caught,

except InvalidTemplateLibrary as e :

define the function F with an argument i.

def F ( i ) :

if 'media' is not contained in attrs,

if 'media' not in attrs :

if LookupError exception is caught,

except LookupError :

if initial is None,

if initial is None :

from django.utils import iri_to_uri, force_bytes, force_text to the default name space.

from django . utils . encoding import iri_to_uri , force_bytes , force_text

derive the class StreamingBuffer from the object base class.

class StreamingBuffer ( object ) :

call the method e.encode with an argument string "latin-1".

return s . encode ( "latin-1" )

return boolean False,

return False

for every code in tuple with 2 elements: lang_code and generic_lang_code,

for code in ( lang_code , generic_lang_code ) :

try,

try :

if language_code is not containsed in self._app_dict

if language_code not in self . _app_dict :

subtract length of the ext from the integer 255, take first elements of the name list up to the previous result index,

name = name [ : 255 - len ( ext ) ] + ext

matches is boolean False.

matches = False

substitute value under idx key of dictionary d for d.

d = d [ idx ]