predictions.txt

if self. _leftover :
if instance is not None :
self. strip = [ 1 : - 1 ]
else :
if self. verbosity >= 1 :
LazyModule = ( connections [ HttpLAPPED_PATOR ), HttpAP )
def validate ( self, value ) :
self. can_read. release ( )
__contains__ = has_header
if self. feed [ 'ttl' ] is not None :
def render ( self, context ) :
import datetime
if size :
raise TypeError ( "Non- integer base36 input." )
def size ( self, name ) :
new_ip = ip_str. split ( ':' )
from decimal import Decimal, DecimalException
except AttributeError :
from django. core import signing
__Y = r'(?P<year>\d{4}'
value = self. pop ( key, default )
if constant_time_compare ( k, self. sign ( value ) ) :
return tempdir
raise TemplateSyntaxError ( "'templatetag' statement takes one argument" )
p_pattern = pattern. regex. pattern
if command. verbosity > 1 :
else :
style = method. split ( ',' )
if isinstance ( s, Promise ) :
return '', val = ''
if options [ 'outlog' ] :
raise TemplateSyntaxError ( " only'silent' flags is allowed the cycle name, '%s'." % ( name, cycleup )
parser. add_argument ('migration_name', nargs = '?', help = 'Nominates a database to '
full_module_name = package_name + '.' + module_name
statements = sql_all ( app_config, self. style, connection )
handler. name = name
return new_value
current = getattr ( current, bit )
self. use_natural_foreign_keys = options. pop ( 'use_natural_primary_keys', None )
pass
except AttributeError :
def with_metaclass ( meta, * bases ) :
commands. update ( { name : find_config_name for name in path. update ( path ) ) if name in app_configs
def attach ( self, filename = None, content = None, mimetype = None ) :
def load_command_class ( app_name, name ) :
url = quote ( url, safe = b'*;@@&&+++$' )
for ldir in dirs :
_fields_ = [ ( '_offset', _OFFSET', PValueID ], PValueIDID ] )
return self. render ( )
renderer = CheckboxFieldRenderer
field_name = force_text ( field_name, encoding, errors )
def initial_form_count ( self ) :
continue
def __init__ ( self, language, deactivate = False ) :
raise TemplateSyntaxError ( "Invalid arguments provided to simple_tag" )
_format_cache [ cache_key ] = val
from django. utils. encoding import python_2_unicode_compatible
widget = URLInput
def __init__ ( self, data = None ) :
signal ='signals'
return bool ( ret )
from django. core. exceptions import ImproperlyConfigured
foreals = dict ( color_names [ x ], "3", x. name )
return "< DeserializedObject: %s.%s(pk=%s)>" % ( self. _meta. app_label
parser. add_argument ( '--extensions', '-e', dest = 'extensions', dest = 'extensions'
@ register. filter ( is_safe = False )
if response. streaming :
words = force_text ( text_split_re ). split ( )
def parse_http_date_safe ( date ) :
from xml. s import handler
use_natural_foreign_keys = options. get ( 'use_natural_foreign_keys' )
return RegexURLResolver ( r'^/', ns_resolver )
return timedelta ( 0 )
self. loaddata ( fixture_labels )
def __setitem__ ( self, key, value ) :
pass
except UnicodeDecodeError :
self. instance = opts. model ( )
compile_func, kwargs = generic_tag_comp compile ( params = params, varargs = varargs, varkw = defaults
raise CommandError ( "Unknown application: %s" % app_label )
self. data = data or { }
from __future__ import unicode_literals
if form. cleaned_data and form. cleaned_data [ field ] is not None :
key = self. make_key ( key, version = version )
primary_keys = [ ]
self. _populate ( )
save.al_data = True
if value is not result :
if command. use_argparse :
return attr
if num > self. _max_entries :
 strip_entities = allow_lazy ( strip_entities, six. text_type )
return self. strptime ( value, format )
parser. add_argument ( '--no-ignore', action ='store_false', dest = 'no_ignore', default
from django. core. management. sql import sql_delete
self. _deleted_form_indexes. append ( i )
if args [ - 1 ]!= "silent" :
self. _unget_history = [ ]
elif not isinstance ( file_name, six. string_types ) and is_iterable ( file_name ) :
form = ManagementForm ( auto_id = self. auto_id, prefix = self. prefix, formfield_form = attrs, prefix
if isinstance ( receiver, types. FunctionType ) :
def __text_cast ( self ) :
else :
del ( key, version = version )
from __future__ import unicode_literals
def urletet ofrunc ( value, limit, autoescape = None ) :
return False
if self. can_delete :
nodelist_true = parser. parse ( ( 'else', end_tag ) )
from django. utils. safestring import mark_safe
def stringformat ( value, arg ) :
guessed_filename = params. get ( 'filename', None )
return self. text
import os
return lazy_number ( ungettext, six. text_type, singular = singular, plural = plural, plural = plural_html = True
open_tags = [ ]
if name is None :
self. blocks = list ( defaultdict )
return None
clean = lambda self, x : len ( x )
return apps. get_model ('auth', 'permissions' )
template_with_clear = '%(clear)s<label for="(clear_checkbox_id)s</label>'
def invalid_block_tag ( self, token, command, parse_until = None ) :
except ImportError :
@ register. tag ( 'with', parser. compile_filter ( max_value_expr ), ** kwargs )
def pretty_name ( name ) :
while len ( line ) > max_width :
pass
data_value = data if data is not None else [ ]
return re. compile ( r'^(?:0-9', number, 0, count_Dict )
response = None
fk = _get_foreign_key ( parent_model, model, fk_name = fk_name )
self. unlink ( self. name )
chunk = stream. read ( max_header_size )
for label in app_labels :
fixture. close ( )
if len ( val1 )!= len ( val2 ) :
else :
return '\n'. join ( output )
default_validators = [ validators. validate_ipv4_address ]
except ( LookupError, Badascii ) as e :
from functools import wraps
self. urlconf_module = self. urlconf_name
pass
rem -= len ( emit )
memo = { }
indent = options. get ( "indent" )
def __init__ ( self, regex ) :
help = ''
last = self. data. day // 10
for location in format_locations :
raise ValueError ( "Unable to convert %r" % value )
def recipients ( self ) :
six. reraise ( UnreadablePostError, UnreadablePostError ( * e. args ), sys. exc_info ( ) [ 2
for fname in filelist :
return LANG_INFO [ generic_lang_code ]
return metaclass ( 'temporary_class', { } )
for k, v in ** kwargs :
if options [ 'plain' ] :
def get_internal_wsgi_application ( ) :
for lineno, line in enumerate ( content. splitlines ( True ) ) :
def contains ( source, inst ) :
def __getitem__ ( self, key ) :
if pathext is None :
else :
__all__ = ( 'WSGIServer', 'WSGIRequestHandler' )
except Exception :
error_dict. setdefault ( NON_FIELD_ERRORS, [ ] )
with open ( old_file_name, 'rb' ) as f :
parser. add_argument ( '--keep-pot', action ='store_true', dest = 'use_true', default
try :
idstring = '.' + idstring
return self. filter ( name, func, ** flags )
if len_values < 1 :
pass
self. file. seek ( 0 )
if link is not None :
except StopUpload as e :
open_method, mode = self.compformats [ ctype_fmt ]
else :
from django. forms import Form
if text [ 0 ] in 'xX' :
inner_html = '<ul{id_attr}></ul>'
def _get_size_from_underlying_file ( self ) :
from django. utils. six. moves. urllib. parse import urlparse
self. _stream = stream
return Header ( value, 'utf-8', maxlinen = sys. maxsize ( ) ). encode ( )
self. seconds = parser. expression ( bp )
tok = match. group ( name )
else :
else :
super ( JsonResponse, self ). __init__ ( content = data, * args, ** kwargs )
length = int ( arg )
self. configure_logger ( name, loggers [ name ], True )
if start > upto :
def compile_messages ( self, locations ) :
excluded_apps. add ( app_config )
return self. represent_scalues ( 'tag:yaml.m2, data: strs', str ( data ) )
known_models = [ ]
run_syncdb = False
class pylibMCCCache ( BaseMemcachedCache ) :
import re
try :
return b''. join ( [ t ) + F ( t [ : r ] ) + 1 ]
return lang_code
elif str ( level ) == level :
self. _raw_ipv6 = False
default_validators = [ validators.URLValidator ( ) ]
if item [ 'unique_id' ] is not None :
return formats. date_format ( value, arg )
import warnings
class Request LocalTimezone ( tzinfo ) :
clean = self. clean ( value )
from django. utils import six
color_names = ('-','re', 'j', 'jango', 'May', 'May',
if language_code not in self. _regex_dict :
def _make_parser ( self ) :
from django. core. exceptions import ValidationError
return instance
if CONTEXT_SEPARATOR in result :
 Iterator = object
if indent :
def Z ( self ) :
self. current_app = current_app
name = args [ 1 ]
html_class_attr = ''
return ( ( self ) < other or ( self. __get__ is not None else ( other, ) )
from __future__ import unicode_literals
import sys
def validate ( request ) :
from django. utils import six
class DummyCache ( BaseCache ) :
if getattr ( e, 'winerror', 16 ) and getattr ( 'errno', 13 ) :
from django. conf import settings
want_unicode = True
msgs = self. copy_plural_forms ( msgs, locale )
getattr ( request, 'LANGUAGE_CODE', get_language ( request, 'LANGUAGE_CODE )
return int ( timeout )
parser. add_argument ( '--database', default = DEFAULT_DB_ALIAS, help = 'database', default = DEFAULT
self. _fname = None
raise TypeError ( msg )
if self. cc :
for k, v in ret. items ( ) :
return mark_safe ( ''. join ( bits ) )
 DjangoSafeDumper. add_render ( decimal. Decimal, DjangoSafeDumper. represent_decimal )
self. error ( rawdata [ i : j ]: %r" % e )
def __exit__ ( self, exc_type, exc_value, traceback ) :
field_desc += '. join ( [ ')' for k, v in extra_params. items ( ) ] )
cursor = hashlib ( dirs )
while current_chunk :
loop_dict [ 'first' ] = i == 0
content_type, content_type_extra = meta_data. get ( 'content-type', None )
def pop ( self, k, * args ) :
def add_truncation_text ( self, text, truncate = None ) :
parser. add_argument ( '--fail-parser', action ='store_true', dest = 'database', default = DE_
chars = 'abcdefghijklmnopqrstststuvzinfo.@^_= formats
digits = len ( digittuple )
__version__ = "0.1"
self. max_expr = max_expr
class DeserializationError ( Exception ) :
if autoescape :
def force_bytes ( s, encoding = 'utf-8', strings_only = False, errors ='strict' ) :
except VariableDoesNotExist :
regex_re = re. compile ( r"""^(?:(?P<addr>(?P<ipv4,3{
data = self. form. initial. get ( self. name, self. initial )
signals. request_finished. connect ( cache. close )
return None
return iter ( self. file )
prefix = settings. MEDIA_URL
smlob_path = os. path. join ( tmpdir,'sysml' )
def render ( self, context ) :
use_natural_primary_keys = options. get ( 'use_natural_primary_keys' )
def inner ( self, * args ) :
if '::' not in ip_str and len ( ':' )!= 7 :
parser. add_argument ( 'args', metavar = 'app_label', nargs = '*', help = '
if os. path. exists ( django_po ) :
now = datetime. now ( )
kwargs [ 'tzinfo' ] = tzinfo
raise ValidationError ( self. error_messages [ 'list' ], code = 'list' )
class MigrationEmailHandler ( logging.Handler ) :
t = select_template ( template_name, dirs )
if value in self. empty_values and self. required :
except TypeError :
from io import BytesIO
 tell = property ( lambda self : self. file. tell )
continue
parser. delete_first_token ( )
class FieldField ( ChoiceField ) :
import fcntl
if can_fail :
if template_source_loaders is None :
callback = pattern. _callback
call_command ( 'loaddata', * fixture_labels, ** kwargs )
if value is None :
return int ( value )
elif '=' in part :
compare_to = [ var. resolve ( context, True ) for var in var_list ]
def to_python ( self, value ) :
elif isinstance ( value, decimal. Decimal, float, six. integer_types ) :
@ contextlib. contextmanager
if event. path. endswith ( '.mo' ) :
if node. must_be_first and nodelist :
return False
self. auto_id = auto_id
def rss_attributes ( self ) :
return ungettext_lazy ( 'Ensure this value has at least %(limit_value)d, % ( force_text (
if six. PY3 :
for k, v in six. iteritems ( self ) :
pass
def b64_hmac ( salt, value, key ) :
del _active. value
for basedir in basedirs :
else :
full_path = self. path ( name )
if not self. form. is_bound :
del self. dicts [ - 1 ] [ key ]
self. reader_leaves ( )
_regex_re = re. compile ( r"""^(?:(?:a-z0-9]+[A-Z0-9
class Widget ( six. with_metaclass ( MediaDefiningClass ) ) :
get_language = lambda settings. LANGUAGE_CODE
from django. utils. six. moves. urllib. parse import urlsplit, urlunsplit
from email. mime. text import MIMEText
self. fed = [ ]
class MaxLengthValidator ( BaseValidator ) :
self. lookups = None
raise TypeError ( " if the flags is set, regex must be a normal expression." )
return default
attrs. get ('step',step )
import sys
break
value = ''
to_delete. add ( model )
file_, _, _, _ = imp. find_module ( module_name, [ entry ] )
self. _cache = _caches. setdefault ( name, { } )
html4_singets = ( '10', 'col', 'link', 'html', 'html', 'html'
if os. path. isdir ( template_dir ) :
def make_key ( self, key, version = None ) :
return self. __name
if not match :
def to_python ( self, value ) :
def lower ( value ) :
ip ( )
connection = connections [ database ]
def _format_value ( self, value ) :
args = parse_header ( boundary ( 'ascii' ) )
initial = self. initial. get ( name, field. initial )
from django. utils import six
if data in self. children :
elif isinstance ( timezone, six. string_types ) and pytz is not None :
@ register. filter ( is_safe = True )
status_code = 300
if i >= self. initial_form_count ( ) and not form. has_changed ( ) :
return ord ( bs [ 0 ] )
if is_ignored ( file_path, self. ignore_patterns ) :
if app_config. models_module is None or app_config in excluded_apps :
return code
chunks = ( zip ( ', 'ascii' ), ( ), ( ), ( ) )
else :
message = e
FormSet = modelformset_factory ( model, str ( 'FormSet', '_num', max_max ) )
rest = value
raise SuspiciousFileOperation ( "arsed access to '%s' and name." % name )
hidden_widget = SplitHiddenDateTimeWidget
for node in compiled_parent. nodelist :
if isinstance ( template_name, ( list, tuple ) ) :
def get_str_from_wsgi ( environ, key, default ) :
model_models = model. check ( ** kwargs ) for model in apps. get_models ( ) ]
def initial_form_count ( self ) :
def j ( self ) :
pass
if format not in _serializers :
return int ( tzinfo ) > int ( tzinfo [ 3 : 3 ] ) + int ( tzinfo ) + int ( tz
return False
if not content_type :
elif cwords [ 0 ] in sorted ( subcommands ) and 'help' in _ ( 'help' ) :
return ip_str
else :
class HttpResponseForbidden ( HttpResponse ) :
return
nodes. append ( self )
if instance is None :
if ip_str. split ( ':' )!= hextet :
for app_dir in app_dirs :
DEBUG = 300
os. chdir ( our_home_dir )
config ['mail' ] = self. as_tuple ( config ['mailhost' ] )
obj. widgets = copy. deepcopy ( self. widgets )
yield buf. read ( )
if not isinstance ( self. regex, six. string_types ) :
if hasattr ( timezone, 'normalize' ) :
from django. utils import termcolors
except ( ssl. SLError, smtplib. SMTPutor ) :
self. stdout. write ( 'ignoring file %s in %s\n' % ( filename, dirpath ) )
default_settings = module_to_dict ( global_settings )
self. imp = self. imp ( used )
def decorating_function ( user_function ) :
pass
key = self. to_field_name or 'pk'
stats [ MISSES ] += 1
return False
from django. utils import six
if self. is_reversed :
for line in text. splitlines ( True ) :
return value
return self. forms [ index ]
if isinstance ( path, six. string_types ) :
all_models = [ ]
truncate_text = self. add_truncation_text ( '', truncate )
help = "Prints the SQL statements for the named migration."
initial = [ ]
value = arg. replace ( arg, value )
httpd = httpd_cls ( server_address, WSGIRequestHandler, ipv6 = ipv6 )
_urllib_request_moved_attributes = [ MovedAttribute ( "c", "urllib", "ur
def empty_form ( self ) :
def handle ( self, * args, ** options ) :
other_dict = args
if params. get ( 'filename' ) :
try :
raise TemplateSyntaxError ( "'%s' is not a valid tag library: %s" % ( taglib, e ) )
_translations [ language ] = Djangolations ( language )
c = subject [ i ]
return IfchangedNode ( nodelist_true, nodelist_false, * values )
from django. core. management. base import BaseCommand, CommandError
_version = "0. ser"
finally :
guessed_path = path. join ( tempdir, guessed_filename )
else :
value = '.'. join ( reversed ( parts ) )
def __init__ ( self ) :
class RssStns1Feed ( RssFeed ) :
new_filenames += os. path. join ( dirpath, filename )
parser. add_argument ( '-v', '--osity', action ='store_true', dest = 'interactive'
urlconf = settings. new_POT_urLCONF
return [ '', [ ] ], [ ]
else :
continue
def dec ( func ) :
if old_attr is None :
name, val = forbid_multi_line_headers ( name, val, self. encoding )
class Input ( Widget ) :
handler. startElement ( "channel", self. root_attributes ( ) )
opts = ( s for s in opt_dict. keys ( ) )
warnings. warn ( "django.utils.tzinfo. FixedOffset will be removed in Django 1.9.", RemovedInDjango
self. fixture_object_count = 0
extra_classes. add ( self. form. required_css_class )
from django. utils import six
filelist = int ( num_cull_entries, self. _cull_frequency )
try :
if os. path. exists ( new_path ) :
class Lexer ( object ) :
error_messages = opts. error_messages [ NON_FIELD_ERRORS ]
self. _table = table
return _trans. to_locale ( language )
tempdir = tempfile. mkdtemp ( prefix = prefix, suffix = '_ext extract' )
tt = ( ( [ tt ], [ tt ] ) [ 1 : ] )
except Exception as e :
def __iter__ ( self ) :
else :
os. chmod ( full_path, self. file_permissions_mode )
for fname in glob.glob1 ( self. _dir, * args ) :
for log in existing :
for app_label in app_labels :
return fastcgi_help ( "Invalid * host + port, socket." )
def as_widget ( self, widget = None, attrs = None, only_initial = False ) :
return
SINGLE_BRACE_END = '}'
url = 'view.decorators.cache.%s' % ( key_prefix, str ( urllib, 'cache' ) )
label = conditional_escape ( checkbox_id )
else :
if self. interactive :
yield safe_join ( template_dir, template_name )
if delta < 0 :
def error ( self, message ) :
return template_name
def update_watch ( sender = None, ** kwargs ) :
else :
val2 = self. var2. resolve ( context, True )
class NullBooleanSelect ( Select ) :
if not isinstance ( value, ( bytes, six. text_type ) ) :
parser. add_argument ( '--noinput', action ='store_false', dest = 'interactive', default = True
return default
try :
msguniq_options = [ '--to-code=utf-8' ]
if self. locale_paths :
version = get_complete_version ( version )
return strip_prefix = lambda s : s [ 'a-z0-9' ]
ns = "http://www.w3. os. getto/to/ path"
else :
app_dir = os. path. join ( app_config. path, 'fixtures' )
from gzip import GzipFile
self. active_writers = 0
raise ValueError ( "alternative base36 input input." )
def __eq__ ( self ) :
try :
tag, self. lasttag = match. group ( 1 ). lower ( )
else :
 secret = settings. SECRET_KEY
project_name, target = options. pop ( 'name', 'dummy' )
logger = logging. getLogger ( 'django.request' )
 tmpdir = tempfile. mkdtemp ( )
def handle_m2m ( value ) :
except ImportError as e :
self. stdout. write ( " No else features." )
moved_oved_oved_attributes = MovedModule ( "_thread", "thread" )
locale = options. get ( 'locale' )
self. cookies [ key ] = cookie_date ( [ key ] )
if isinstance ( f, models. FileField ) :
os. unlink ( work_file )
_regex_re = re. compile ( r"""^\s*transtrans(\s+context\s+*?"*(?:
import time as _time
raise CommandError ( "Django't does not use to use the SQL statements, " "\n" % app_label )
if self. verbosity > 0 :
def delete ( self, key, version = None ) :
if representative is None :
self. language = language
callable = callable
iteritems = _iteritems
continue
sign Name = "%4d" % dt. year
m = re. match (ipipip_re, options [ 'addrport' ] )
if isinstance ( template, ( list, tuple ) ) :
def __exit__ ( self, exc_type, exc_value, tb ) :
yield "from__ import unicode_literals
try :
if timeout is None :
def end_serialization ( self ) :
if att_name == 'id' and extra_params == { 'invalid' : True } :
try :
parser. add_argument ( '--plain', action ='store_true', dest = 'plain', default = True, help
class DisallowedRedirect ( SuspiciousOperation ) :
else :
raise CommandError ( "You must provide at least one app label if using." )
i = 0
if value and hasattr ( value, 'url' ) :
self. validate_key ( key )
if i >= 0 :
elif indexes [ column_name ] [ 'unique' ] :
else :
assert to not isinstance ( six. string_types, '"to" argument must be a list or tuple' )
 WSGIServer = module. WSGIServer
def _createdir ( self ) :
if message_context :
else :
sites = [ ]
def set ( self, key, value, timeout = DEFAULT_TIMEOUT, version = None ) :
def setlistdefault ( self, key, default_list = None ) :
self. widgetchoices = self. choices
trim_whitespace_re = re. compile ( '\s*\n\s*' )
input_type = 'text'
def __getinitargs__ ( self ) :
raise
location = '%s:%s' % self. get_full_path ( )
msgs = msgs. decode ( 'utf-8' )
try :
from django. utils import six
raise ValueError ( 'Unable to configure handler''%r: %s' % ( name, e ) )
with self. mutex :
from django. middleware.csrf import get_token
except OSError as e :
value = self. make_bytes ( value )
queryset = self. model. _default_manager
if settings. USE_TZ and value is not None and timezone. is_naive ( value ) :
with transaction. atomic ( using = connection. alias, savepoint = connection. features. can_rollback_ddl ) :
if serializers is None :
return self. find_template_cache [ key ]
def flatten ( self ) :
def is_valid_ipv6_address ( ip_str ) :
pass
url = None
self. _request_middleware = None
import importlib
self. version = params. get ('version', 1 )
if not isinstance ( index, six. integer_types, tuple ) :
@ register. filter ( is_safe = False )
 members = [ member for member in self. _archive. get members ( ) for member in self. items ( ) ]
return obj
return list ( urlsplit ( url ) )
else :
raise AttributeError ( "%s cannot be import " % self. name )
if self. verbosity > 1 :
def validate ( self, value ) :
self. _cache. set ( key, value, self. get_backend_timeout ( timeout ) )
from django. utils. six. moves import zip
self. _setup ( )
builtins = [ ]
except ValueError :
logger_kwargs [ 'out_log' ] = options [ 'outlog' ]
return
MIN_NUM_FORM_COUNT = 'MIN_NUM_FORMS'
validate_conETA_separated_string_list = RegexValidator ( _separated_int_list, _ ( 'Enter
def is_checked ( self ) :
return self. management_form. cleaned_data [INITIAL_FORM_COUNT ]
pass
forclable in self. _closable_objects :
def __init__ ( self, * args, ** kwargs ) :
from django. forms. fields import Field, FileField
self. file. close ( )
parts = viewname. split ( ':' )
raise ValidationError ( ungettext ( "invalid", "gettext_num", self. min_message = _gettext
def get_json_data ( self, escape_html = False ) :
MAXSIZE = int ( ( 1 << 31 ) - 1 )
yield ''
result. parent = self
message = message. replace ( '\r\n', '\n' ). replace ( '\r', '\n'
return 1 << [ 2 : - 2 ]
def _populate ( self ) :
if not token. contents :
from django. core import checks
if len ( parts ) > 1 and parts [ - 1 ] in self. compression_formats :
newline = b'\n'
def widget_attrs ( self, widget ) :
pot_path = os. path. join ( path, '%s.pot' % self. domain )
for field, error_list in error. items ( ) :
def _set_regex ( self, regex ) :
if dirname and not os. path. exists ( dirname ) :
output_transaction = True
return force_text ( ngettext ( singular, plural, number ) )
def add_prefix ( self, field_name ) :
return False
try :
original_path = os. path. join ( tmpdir, " original" )
in_index = index if is_reversed else 2
lexer = lexer_class ( template_string, origin )
self. _non_form_errors = self. error_class ( )
if hasattr ( test_runner_class, 'add_arguments' ) :
def __repr__ ( self ) :
if var. endswith ( '.' ) :
import json
options = [ opt [ 0 ] if opt in options [ 0 ] not in var_opts ]
 fs_encoding = sys. getfilesfilesencoding ( ) or not self. getfilespath ( )
if isinstance ( message, ValidationError ) :
def __init__ ( self, stream_or_string, ** options ) :
return _import_module ( self. mod )
continue
if isinstance ( slots, str ) :
self. __starttag_text = None
return int ( bytes ) for bytes in buf
raise UnrecognizedArchiveFormat ( "File object not a than archive format." )
self. options. update ( dictionary, 'use_decimal' )
def validate ( self, value ) :
fail_message = 'created'
state = { "pk : Tok ( Tok ( "pkg", "pkg", "pk", "rel",
for item in values :
def utcoffset ( self, dt ) :
leave_locale_alone = False
from __future__ import unicode_literals
def __str__ ( self ) :
end = rawdata [ k : endpos ]. strip ( )
zipfile. ZipFile. read ( self, self. nelist [ 0 ] )
def render ( self, context ) :
confirm = 'Please must be "yes" or "no:" '
return b'\v4" % b'\\0', "\\03", "\\#3" )
widget. is_localized = self. is_localized
klass. deconstruct = deconstruct
if extend :
connection = connections [ options [ 'database' ] ]
try :
warnings. warn ( "No fixture named '%s' found." % fixture_name )
return self. data. replace ( month = 1, day = 1 ). replace ( 1 )
if self. lookups is not None :
initial_path = os. path. join ( migrations_directory, "__init__.py" )
return value
value = timezone. normalize ( value )
@ property
subject = self. subject
return '0'
super ( LoaderOrigin, self ). __init__ ( display_name )
if pos >= last :
from django. conf import settings
def normalize ( pattern ) :
import operator
finally :
def tzname ( self, dt ) :
if self. allow_files :
if not custom_sql :
msg = SafeMIMEMultipart ( _subtype = self. alternatives_subtype, encoding = encoding )
if field in self. cleaned_data :
if args and kwargs :
builtins. append ( import_library ( module ) )
return self. compress ( [ ] )
def parse_endtag ( self, i ) :
import types
def M ( self ) :
self. creation_counter = Field. creation_counter
attrs = {'model' : model }
except ( ImportError, AttributeError ) as e :
def __getitem__ ( self, key ) :
if '=' in x :
def tell ( self ) :
raise AttributeError ( "This QueryDict instance is_ object" )
@ python_2_unicode_compatible
if p. find ( ':' in p. find ( ':' ) >= 0 :
 flags = 0
target_app_labels_only = False
class IfchangedNode ( Node ) :
p open ( file ). check ( ). open ( )
if self. selected_fields is None or field. attname in self. selected_fields :
name = self. split_leading_dir ( name ) [ 0 ]
from django. utils import six
except AttributeError :
return arg
return _trans. get_language_from_path ( path )
if db. settings_ddef getattr ( 'AT must provideICES', db. alias, 'atomic_atomic_ vES'
class InlineForeignKeyField ( Field ) :
if is_aware ( o ) :
try :
self. years = [ this_year ] + 10_year
for refto, refs in references. items ( ) :
from django. core. exceptions import AppRegistryNotReady
settings.FORMATAT_MODULE_PATH = settings.FORMAT_MODULE_PATH
if ch in '*?+' :
try :
else :
if send :
http = http_cookies. SimpleCookie ( ). value_encode ( ";" )
nodelist_empty = parser. parse ( ( 'endfor', ) )
except ( KeyError, AttributeError ) as exc :
class objectDoesNotExist ( Exception ) :
@ register. filter ( is_safe = False )
return iri
value = environ. get ( key, str ( default ) )
def __init__ ( self, lexer ) :
return time. mktime ( self. data. timeetuple ( ) )
try :
safe_data = { }
import stat
def write_items ( self, handler ) :
wrap = allow_lazy ( wrap, six. text_type )
from __future__ import unicode_literals
for path in paths :
sys. stdout. write ( self. main_help_text ( ) + '\n' )
def __init__ ( self ) :
import sys
def ngettext ( context, singular, plural, number ) :
def reload ( self ) :
from django. utils. module_loading import import_string
else :
continue
import warnings
if exp is not None and exp < time. time ( ) :
if t is not None :
time_str = time_str. decode ( 'utf-8' )
field_notes. append ( "Field renamed because it wasn." )
super ( QueryDict, self ). __setitem__ ( key, value )
def write_message ( self, message ) :
def list ( self ) :
return mark_safe ( '\n'. join ( output ) )
super ( LocaleRegexURLResolver, self ). __init__ ( None, urlconf_name, default_kwargs, namespace
var_obj = None
response = middleware. process_template_response ( request, response )
loop_dict [ 'counter' ] = i + 1
return size
is_a_names = hasattr ( sys. stdout, 'isatty' ) and not sys. stdout. is_to
if isinstance ( offset, timedelta ) :
self. _assert_mutable ( )
return int ( values [ 0 ] ), ch
import codecs
try :
@ register. tag
result. setFormatter ( formatter )
memo [ id ( self ) ] = result
other = other. __cast ( )
if isinstance ( other, Promise ) :
else :
self. _cull ( )
e. args = ( "Problem installing [ fixture: %s" % e )
os. makedirs ( directory )
raise OverflowError ( 'dklen too large' )
return clean_ipv6_address ( value, self. unpack_ipv4 )
from importlib import import_module
parser. add_argument ( '--pks', action ='store_true', dest = 'use_base', default =
if header_end == - 1 :
def b ( s ) :
g = loader. ByGenerator ( fp, pickle_from_ = False )
import unicodedata
if t. token_type == TOKEN_BLOCK :
if len ( self. nelist ) :
else :
for medium in extend :
if url :
from collections import defaultdict
now = datetime. datetime ( now. year, now. month, now. day )
while i < len ( subject ) and subject [ i ]!= c :
self. _changed_data = [ ]
yield parse_boundary_stream ( sub_stream, 1024 )
return value. replace ( tzinfo )
def __init__ ( self, cyclevars, variable_name = None, silent = False ) :
if six. PY3 :
return value. strftime ( format )
logger_kwargs [ 'errlog' ] = options [ 'errlog' ]
for migration_name in migration_names :
from itertools import chain
return obj_dict
buffer_ = line
raise ValueError ( "Key '%s' not found" % key )
if self. _request_middleware is None :
def render ( self, name, value, attrs = None ) :
TYPE = RAW
TYPE = FILE
tok = '"' + roots + '"'
condition = TemplateIfParser ( parser, bits ). parse ( )
return apps. get_model ( model_identifier )
return loader. get_template ( template )
def cl ( ) :
def handle_data ( self, d ) :
def lock ( f, flags ) :
template_string = force_text ( template_string )
if not os. path. exists ( potfile ) :
self. active_writers -= 1
if hasattr ( self, '_coerce' ) :
return _trans.templatize ( src, origin )
def compile_string ( template_string, origin ) :
try :
raise NotImplementedError ( 'Subclasses must define this method.' )
@ wraps ( func )
return value. replace ( '\x0', '\x0' )
request_middleware. append ( mw_instance. process_request )
if not boundary or cgi. valid_boundary ( boundary ) :
val = list ( val )
except ValueError :
import re
over = allow_lazy ( capfirst, six. text_type ) + [ six. text_type ( )
def eval ( self, context ) :
from django. utils. six import StringIO
self. _size = size
errors = [ ]
if 'error_messages' in kwargs :
self. _add_local_translations ( )
class Node ( object ) :
if os. path. sep in fixture_name :
def __init__ ( self, tokens ) :
if primary_keys :
def __mod__ ( self, rhs ) :
except socket. error as e :
self. __dict__ [ '_setupfunc' ] = func
data = None
from django. utils. text import get_valid_filename
elif auto_id :
self. get_json_data ( escape_html )
self. nodelist_empty = NodeList ( )
except ValidationError as e :
app = 'django'
try :
for char in self. add_truncation_text ( '', truncate ) :
etags = etAG_Match. findall ( etag_str )
if field_type == 'autoField(' :
c = SimpleCookie ( )
attrs = {'model' : smart_text ( obj. _meta ) }
return ip_str. split ( 1 ) [ 1 ]
def flatten_result ( source ) :
if request. _post_parse_error :
except KeyError :
for f in opts. fields :
field_url_re = constant_string_regex ( r'^\n', re.w )
def incr ( self, key, delta = 1, version = None ) :
if type ( result ) in ( ConvertingDict, ConvertingList, ConvertingTuple ) :
message = ','. join ( [ " %s.model.__name ] )
comment_lineno_cache = None
else :
result = avoid_wrapping ( name % count )
values = [ ]
if hasattr ( field. rel. to. _default_manager, 'get_by_natural_key' ) :
self. dict = OrderedDict ( ( x, None ) for x in iterable ( x ) if x. dict_dict. join
else :
@ register. tag ( 'filter' )
def _samefile ( src, dst ) :
requires_system_checks = False
if not ( message, six. PY3 ) and not hasattr ( message,'message' ) and not hasattr ( message, 'code
except KeyError :
try :
try :
m = int ( d ) - d
def make_key ( self, key, version = None ) :
filemsg = 'file %s,'% origin
if hasattr ( cls, k ) :
else :
raise TemplateSyntaxError ( "backcalled with next after the given params" )
for field_name in self. fields :
self. _upload_handlers = upload_handlers
if options. get ( 'no_color', sys. stdout ) :
if self. instance. pk is not None :
try :
return klass
value = [ ]
try :
import time
raise NoReverseMatch ( "%s is not a registered namespace" % key )
nodelist. append ( node )
error_messages [ 'invalid' ] = error_messages
if options. traceback or e isinstance ( ) :
return self. _choices
try :
try :
try :
to_python = self. _get_to_python ( pk_field )
self. varlist = varlist
return encoding
if now == True and not isinstance ( now, datetime. datetime ) :
if token. contents == 'else' :
return results
plmatch = plural_re. match ( t. contents )
for middleware_method in self. _exception_middleware :
from xml.sals.sals import xmlGenerator
if fields :
for c in reversed ( self. __class__. __mro__ ) :
from django. utils import six
return
return '<page %s of %s' % ( self. number, self. paginator. num_pages )
else :
default_error_messages = { 'invalid' : _ ( 'Enter a list of values.' ), 'invalid_choice'
_called_from_command_line = False
if opts. model :
def copy ( self ) :
collect = [ ]
if len ( value )!= 1 :
self. blocks = dict ( ( n. name, n ) for n in nodelist. get_nodes_by_type ( ) )
label = ''
old_attr = name
ch, escaped = next ( pattern_iter )
except ( AttributeError, UnsupportedOperation ) :
raise ValidationError ( self. error_messages [ 'invalid_date' ], code = 'invalid_date' )
def __init__ ( self, request, template, context = None, content_type = None, content_type = None, content_type
if self. field. cache_choices :
def fix_location_header ( request, response ) :
del attr
pk_key = "%s-%s" % ( i % i ) for i in self. add_prefix if has_value is
from __future__ import unicode_literals
from __future__ import unicode_literals
def widget_attrs ( self, widget ) :
value = self. to_python ( value ). strip ( )
yield line
self. file. write ( raw_data )
self. empty_label = empty_label
 TemplateLoader = import_string ( loader )
for sql in connection. creation. sql_for_pending_references ( model, style, style, style, html_references_
if response. streaming :
output. append ( error_row % force_text ( top_errors ) )
@ register. filter ( is_safe = True )
raise ImproperlyConfigured ( 'Loader does not define a "load_template" callable' )
new_value. append ( self. coerce ( choice ) )
for i in range ( 0, self. total_form_count ( ) ) :
raise NoReverseMatch ( "Reverse for '%s' % ( key " "%s" % ( key, keyword )
except CommandError :
table_output. append ( '%s_%s' % ( tablename, f. name ) )
response = self. get_response ( request )
import django. core. checks. compatibility. django_1_7_0
escaped = True
self. unclosed_block_tag ( [ endtag ] )
def __init__ ( self, cmd, ** kwargs ) :
if len ( list_ ) == 0 :
return value
try :
max_width = ( line. endswith ( '\n' ) + width )
result = getattr ( t, translation_function ) ( eol_message )
import hmac
from django. utils import six, lru_cache
models = app_config. get_models ( include_auto_created = True )
raise TemplateDoesNotExist ( "Could not " " notfound", self. __class__. __name__ )
return False
__all__ = ( 'Template', 'Context', 'RequestContext', 'comp compile_string' )
def conditional_escape ( text ) :
if not isinstance ( candidate, six. string_types ) :
comment = [ ]
emit_post_migrate_signal ( set ( all_models, interactive, database ) )
if'%s%s' % ( line,') < len ( table_output - 1 ) :
if ch == '?' :
self. inverse_match = inverse_match
self. _pk_field, pk = self. model. _meta. pk
return super ( Error, self ). __init__ ( ERROR, * args, ** kwargs )
if token. token_type == 0 :
if 'forloop' in context :
class BoundaryIter ( six. Iterator ) :
self. path_info = path_info
def clean ( self, value ) :
args. append ( get_file ( ), get_text_key, help = '--notext_l10n', help =
if html :
self. is_reversed = is_reversed
def total_ordering ( cls ) :
return ''
final_output. append ( '--The You that will be removed in nontables:' )
return [ ( i, i ) for i in range ( 1, str ( i ) ) ]
self. _clean_form ( )
for handler in handlers :
if imatch :
return None
fixture = 0
from django. core. management. sql import sql_custom
l = len ( tokens )
if fk_name :
except HTMLParseError :
view_name = callback. name ( )
def __setattr__ ( self, name, value ) :
self. use_l10n = use_l10n
match = kwarg_re. match ( bits [ 0 ] )
for hook in sys. path_loops :
intrans = False
warnings. warn ( "msg_msg, TranslatorCommentWarning )
def compress ( self, data_list ) :
class ViewDoesNotExist ( Exception ) :
final_output. extend ( output )
requires_system_checks = False
else :
if self. choices :
callback, param_dict = resolver. resolve_error_handler ( status_code )
def render ( self ) :
return data
else :
level = config. pop ( 'level', None )
res, args = flatten_result ( item )
obj_pk = obj_pk. pk
return False
class NoReverseMatch ( Exception ) :
import json
global _default
def configure_handler ( self, config ) :
if ch!= '\\' :
else :
translated = int ( rhs )
if location is None :
biggest_number = max ( number )
wsgi_opts = {'maxup' : options ['maxup' ], int ( options ),'maxup' :
raise AttributeError ( "You cannot set content to a 304 (Not MB) response" )
is_usable = True
raise ValueError ( "Not a string literal: %r" % s )
yield 'year'
return scheme in self. url_schemes
if six. PY2 and value > sys. maxint :
if match :
def extend_nodelist ( self, nodelist, node, token ) :
return ( form. has_changed ( ) for form in self ) :
 construct_instance_exclude = list ( exclude )
if new_conn_created :
@ register. tag ( 'block' )
if bf_errors :
if not self. is_bound :
if var. startswith ( '_(' ) and var. endswith ( ')' ) :
__M = r'(?P< os>\w{3}'
return TemplateTagNode ( tag )
def strftime ( self, fmt ) :
if isinstance ( stream_or_string, six. string_types ) :
setattr ( Module_six_moves_urllib_response, attr. name, attr )
def write ( self, outfile, encoding ) :
continue
def add_filters ( self, filtersterer, filters ) :
time_str = time_str. decode ( 'utf-8' )
__dir__ = new_method_proxy ( dir )
def __len__ ( self ) :
bits = token. split_contents ( ) [ 1 : ]
return offset. days * 86400 + offset. seconds // 60
yield b''. join ( self )
import warnings
else :
import warnings
return (TYPE, outdict, stream )
from collections import OrderedDict
def safe_join ( base, ** paths ) :
newline = unicode ( '\n' )
exp = datetime. utcfromtimestamp ( timeout )
LockFileEx. restype = BOOL
return _serializers [ format ]. Serializer
unpack = num_loopvars > 1
words [ i ] = mark_safe ( word )
openLock = Lock ( )
@ deconstructible
chunk_size = 64 * 2 ** 10
def __init__ ( self, conditions_nodelists ) :
def _save ( self, name, content ) :
return '%s_%s' % ( id_, first_select )
if len ( key ) > ModelCACHE_MAX_KEY_LENGTH_LENGTH :
if formfield :
cache [ settings. CACHE_MIDDLEWARE_ALIAS ] = cache [ settings. CACHE_MIDDLE
return nodelist_true_output ( self. nodelist_true. render ( context ) )
return repr ( list ( self ) )
if number > self. num_pages :
return force_text ( name, "\\", '/' )
return True
save.al_data = True
s = s1
return 'tag:%s:%s' % ( ( bits. hostname, d. path, bits. str ( ) ) )
return 0
if cache_timeout == None :
class TemplateLiteral ( Literal ) :
 color_settings = termcolors. parse_color_setting ( "ANGO_locORS )
TOANGO_COMMENT_MARK = 'translators_MARK'
response = self. handle_uncaught_exception ( request, resolver, sys. exc_info ( ) )
 latest_date = item_date
value, prog = signed_value. rsplit ( self. sep, 1 )
qs = f. value_from_object ( instance )
from email import charset as Charset, ( or message_from_string, token )
if isinstance ( v, ( list, tuple ) ) :
incomment = True
return self. _num_pages
return get_supported_language_variant ( accept_lang )
if unicodedata. combining ( char ) :
@ deconstructible
use_base_manager = options. get ( 'use_base_manager' )
def reverse ( viewname, urlconf = None, args = None, kwargs = None, use_l10n = None ) :
if self. _is_rendered :
while current_len <= length :
def _set_response_etag ( response ) :
@ register. filter ( "escapejs" )
if hasattr ( mw_instance, 'process_response' ) :
self. xml. endElement ( "object" )
django_%s_template_' % self. app_or_project
out. write ( blankout ( part, 'S' ) )
from django. utils import six
parser. add_argument ( 'args', metavar = 'app_label', nargs = '*' )
if six. PY2 :
self. waiting_readers = 0
return node. render ( context )
name, ext = os. path. splitex ( name )
@ stringfilter
PATTERN = "class default'(?class'(?:seselfp*etime' or '('>', '(''
self. invoked_for_django = True
media_attrs = kwargs
def read ( self, * args, ** kwargs ) :
num_num = num // self. _cull_frequency
def cleanup_url ( url ) :
def streaming_content ( self, value ) :
import re
self. tags [ name ] = compile_function
created_models = set ( manifest. values ( ), [ p. it ] )
 WSGIServer ( get_wsgi_application, ** wgi_opts ). run ( )
def is_naive ( value ) :
return connection. creation. sql_create_model ( model, no_style ( ), seen_models )
post = '<could not parse>'
context = Context ( ** kwargs : ** options [ ** options : ** 'en_key' ], ** kwargs )
for key in self. keyOrder :
current_len += 1
class SuspiciousipartForm ( SuspiciousOperation ) :
from django. utils. http import urlquote
from django. core. serializers. base import DeserializationError
from django. utils. deprecation import RemovedInDjango19Warning
if self. _wrapped is empty :
return make_origin ( display_name, self. load_template_source, template_name, template_dirs )
return not self. file or self. file. closed
import warnings
self. pubid = pubid
if len ( bits )!= 2 or 3 :
return WithNode ( None, None, nodelist, extra_context = extra_context )
_iterlists = "lists"
from django. core. exceptions import ValidationError
def __reduce__ ( self ) :
if html_message :
return False
def __init__ ( self, name, regex, next = None ) :
except pickle. pickleError :
def get_public_serializer_formats ( ) :
with open ( writer. path, "wb" ) as fh :
def do_ifequal ( parser, token, negate ) :
def _assert_mutable ( self ) :
pass
if isinstance ( data, bytes ) :
except OSError as e :
for pythonrc in ( os. environ. get ( "PY2START", "PATHS" ), "PAT
parser. add_argument ( '--no-initial-data', action ='store_true', dest = 'interactive',
return False
for dirname in dirs :
try :
val, encoding = super ( SimpleCookie, self ). value_encode ( val )
using_sysrandom = False
 user_settings = module_to_dict ( settings. _wrapped )
ttl = force_text ( ttl )
statements. append ( cleaned_lazy )
if y and m and d :
from django. utils. deprecation import RemovedInDjango19Warning
return date. strftime ( '%s, %d %s % (d: %s: %s: %s' % ( y
def u ( s ) :
super ( AssignmentNode, self ). __init__ ( takes_context, args, kwargs )
except ( ValueError, TypeError ) :
__all__ = [ 'File' ]
return retval
self. stream. write ( '%s\n' % msg_data )
logger. level = logging.NotSET
elif basetype =='message' and subtype == 'rfc8' :
def value_from_datadict ( self, data, files, name ) :
raise ValueError ( "Key '%s' not found" % key )
except SuspiciousOperation as e :
ttl = force_text ( ttl )
if kwargs. split ( defaults )!= set ( defaults, prefix ) :
if self. asvar is None :
if isinstance ( s, ( six. text_type, Promise ) ) :
self. stdout. write ( "Installing %d object(s) from %d fixture(s)" % ( fixture_s ) )
t.ed ( left, self )
return '<extendsNode: %s>' % self. parent_name. token
for attachment in self. attachments :
return value
from django. core. cache. backends. base import BaseCache, DEFAULT_TIMEOUT
def __init__ ( self ) :
value = next ( cycle_iter ). resolve ( context )
if not self. compile_function_error ( token, e ) :
chunks = [ ]
logging.Handler. __init__ ( self )
confconf = executor. loader.t_confconf ( )
_localtime = None
return self. number + self. paginator. per_page
seen_models. add ( model )
def clean ( self, value ) :
if not data and initial :
else :
def url ( self, name ) :
if not hasattr ( package, 'rindex' ) :
raise
match = re_DATE. match ( value )
from django. db. migrations. writer import MigrationWriter
if value in ( None, '' ) :
msg = "Unclosed tag '%s'. a one of: %s " % command %s" % ( command, e )
app_config = apps. get_app_config ( app_label )
def _iterkeys ( self ) :
 shutdown_message = options. get ( 'locup_message', False )
return self. source
if f is None :
def handle ( self, ** options ) :
class CommentNode ( Node ) :
from django. utils. encoding import force_text
module = import_module ( module_path )
return result
temp_lib. tags [ name ] = lib. tags [ name ]
if self. to_field :
from django. http. response import ( HttpResponse, StreamingHttpResponse, HttpResponseRedirect, HttpResponse, self. H
handler. addQuickElement ( "rights", item [ 'item_copyright' ] )
def bytes2int ( bs ) :
return lazy_number ( ngettext, str, singular = singular, plural = plural, plural = True )
class Command ( BaseCommand ) :
stream. unget ( chunk )
for k, v in [ six. iteritems ( fields ) :
_func_defaults = "func_defaults"
parser. add_argument ( '--exclude', '-x', dest = '-e', dest = 'locale'
try :
raise ExternalReferenceForbidden ( context, base, sysid, pubid )
with connection. concrete_checks_false ( ) :
delta = expires. utcnow ( ) - expires
super ( Serializer, self ). handle_fstore ( obj, field )
pass
else :
else :
error = Error ( "%s is connection to connection the '%s' signal ( lazy_view " "%s.%s" % ( i
kwargs [ 'instance' ] = self. _existing_object ( pk )
if len ( bits ) < 2 :
return copy. deepcopy ( self. _wrapped, memo )
loaded_objects_in_fixture = 0
return result
super ( RadioChoiceInput, self ). __init__ ( * args, ** kwargs )
self. dicts [ - 1 ] [ key ] = value
from django. core. cache. backends. base import BaseCache, DEFAULT_TIMEOUT
if self. max_digits is not None and self. decimal_places is not None and self. decimal_places > self. decimal_
if not value and self. required :
base_url. append ( '/' )
if dirname and not os. path. exists ( dirname ) :
def regex ( self ) :
parser. add_argument ( 'args', nargs = '*' )
if plan_node in loader. app_migrations :
self. _regex_dict [ language_code ] = regex_comp compile
self. file. seek ( 0 )
return self. __name
self. _body = self. read ( )
return result
boundary = opts. get ( 'boundary' )
raise InvalidCacheBackendError ( "Could not find backend '%s': %s" % ( backend, e ) )
else :
def save_existing_objects ( self, commit = True ) :
from django. core. mail. utils import DNS_NAME
 needs_multipart_form = True
pass
def indexbytes ( buf, i ) :
__getattr__ = new_method_proxy ( getattr ( getattr ) )
sep = hextet [ 0 ]. split ( ':' )
def __contains__ ( self, item ) :
bits = host. split ( ':', host = ':' )
try :
result. append ( path )
class MiddlewareNotUsed ( Exception ) :
import os
handler = self. configure_handler ( handlers [ name ] )
else :
with connections [ db ]. cursor ( ) as cursor :
return datetime. time ( ** kw )
filelist = _cached_filenames + new_filenames + _error_files
 strip_tags = allow_lazy ( strip_tags )
self. queryset = field. queryset
next = klass. __dict__
import_module ( templatetag_module )
def tag ( self, name = None, compile_function = None ) :
if kwargs. pop ( 'ipv6' ) :
def writer ( self ) :
class InvalidTemplateLibrary ( Exception ) :
def render ( self, context ) :
self. allow_empty_first_page = allow_empty_first_page
s = s. replace ( '\t', '\\t' )
 needs_multipart_form = False
self. handle_starttag ( tag, attrs )
try :
self. _catalog. update ( other. _catalog )
for f in sorted ( opts. concrete_fields + sortable_m_fields, opts. many_to_many ) :
if isinstance ( message, SafeData ) :
if not self. data and not self. files :
setattr ( filter_func, attr, value )
if nodelist. get_nodes_by_type ( ExtendsNode ) :
try :
obj = super ( MultiWidget, self ). __deepcopy__ ( memo )
else :
def sql_indexes ( app_config, style, connection ) :
if app_config. models_module is None :
raise NotImplementedError ('subclasses of Origin must provide a reload() method' )
self. kwargs = kwargs
return True
self. paths_to_remove. append ( tempdir )
if fk. unique :
elif connection. cursor ( ) as cursor :
fields. update ( new_class. declared_fields )
self. choices. append ( ( f, f. replace ( path, "", 1 ) ) )
use_null_fallback = False
kwargs [ name ] = parser. compile_filter ( value )
class SplitDateTimeField ( MultiValueField ) :
result = middleware. process_view ( request, view_func, args, kwargs )
return '\r\n'. join ( [ '. join ( value, 'latin-1' ) ) for 'latin in
class Http404 ( Exception ) :
def media ( self ) :
if ( isinstance ( data, datetime. datetime, datetime. time ) and not self. supports_microseconds ) and not self.
from django. conf import settings
state_frame [ self ] = None
error_msg = "Invalid template name in 'extends' tag: %r." % parent
if option_value is None :
class LocalTimezone ( Date LocalTimezone ) :
@ register. filter ( is_safe = False )
elif field_type =='idField(' and connection. features. can_intspection_autoescape :
return QueryDict ( '', encoding = self. _encoding ). __init__ ( )
def to_python ( self, value ) :
if ( not pk_is_not_edable ( ) or ( pk. rel. to. _meta. pk ) and
if match :
def patch_cache_Control ( response, ** kwargs ) :
def __init__ ( self, level, msg, hint = None, obj = None, if default = None ) :
tag, this_value_expr, max_value_expr, max_width = bits
db = options. pop ( 'using', False )
if not filename :
super ( InlinelineForeignKeyField, self ). __init__ ( * args, ** kwargs )
def __init__ ( self, name ) :
from django. core. exceptions import ImproperlyConfigured
def __init__ ( self ) :
value = [ conditional_escape ( v ) for v in value ]
class TemplateEncodingError ( Exception ) :
if version is None :
self. xml. startElement ( "field", { "field" : field. name, "field" : self. xml. name,
thefile = self. file
seconds = int ( m. group ('seconds' ) )
self. stdout. write ( self. style. MIGRATE_HEADING ( "merge %s" % app_label )
value = getattr ( opts, opt, opt )
for basedir in basedirs :
if hasattr ( file_or_path,'read' ) :
@ classmethod
def _replace_entity ( match ) :
self. _post, self. _files = self. parse_file_upload ( self. META, data )
path_info = get_bytes_from_wsgi ( environ, 'PATH_INFO', '/' )
except Exception :
if self. empty_apps :
subcommand = 'help'
def handle ( self, * app_labels, ** options ) :
raise ValueError ( "'%s' has no field named '%s'." % ( self. __class__. __name__, field )
model_fields = Model. _meta. get_all_field_names ( )
f = os. path. join ( p, cmd )
error_messages = self. fields [ field ]. error_messages [ 0 ]
self. _lock = threading. RLock ( )
from UserList import UserList
from django. http import Http404
token [ id_bit ( upto, ( upto ) + len ( last_bit ) + self. create_token ( ) ) +
class dummy :
def __del__ ( self ) :
link [ NEXT ] = root
from django. apps import apps
else :
while i < l :
def render ( self, context ) :
def _cache ( self ) :
_re = re. compile ( r'<.*?>|(.)?|', r'(??:?:?:?:?:?:
return { }
model = app_config. get_model ( model_label )
if value is not result :
return tt. tm_isdst > 0
def _get_choices ( self ) :
loader = MigrationLoader ( connection )
 termios. tzsetattr ( fd, termios. CSL67 new, attr_list )
_urllib_robotparser_moved_attributes = [ MovedAttribute ( "DovedAttribute", "urllib
def render ( self, name, value, attrs = None ) :
cursor. close ( )
endbmatch = endblock_re. match ( t. contents )
for key, value in parse_gsl ( query_string or '', use_blank_values = True ) :
def get_resolver ( urlconf ) :
app_dir = apps. get_app_config ( model. _m. app_label )
if locations :
class signalsExpired ( BadSignature ) :
def get ( self, key, default = None ) :
def _mark_post_parse_error ( self ) :
self. xml. endElement ( "field" )
super ( GenericIPAddressField, self ). __init__ ( * args, ** kwargs )
from django. utils import six, timezone
return value
return filelist
if self. verbosity >= 1 :
stream = StringIO ( stream_or_string )
from django. utils import archive
return time_str + '-0000'
if not self. allow_multiple_selected :
raise TemplateSyntaxError ( "'%s' received some keyword argument '%s'" % ( name, i ) )
else :
from django. apps import apps
localpart = str ( Header ( localpart, encoding ) )
class FileInput ( Input ) :
d = { }
return data
for line in content. split ( '\n' ) :
if value :
@ property
data [ field. attname ] = value
s = six. text_type ( s, encoding, errors )
raise
if app_config. models_module is None :
for tag in open_tags :
_assertRegex = "assertRegex"
class EmailBackend ( BaseEmailBackend ) :
self. _regex_validator = validators. RegexValidator ( regex = regex )
if error_messages and f. name in error_messages :
parser. add_argument ( 'args', metavar = 'app_label', nargs = '+', help = '
child_loggers. append ( existing [ i ] )
metype, _ = mimetypes. guess_type ( filename )
 secret = force_bytes ( secret )
params, varargs, varkw, defaults = getargspec ( func )
def html_quote ( s, quote_double_quotes = False ) :
i += 1
@ deconstructible
break
def cleaned_data ( self ) :
break
key = self. make_key ( key, version = version )
value = data. get ( name )
changeset = timestamp. strftime ( '%Y%m%d%H%M%S' )
if val is None :
def clear ( self ) :
six. reraise ( exc_type, exc_value, sys. exc_info ( ) )
raise ValidationError ( self. error_messages ['required' ], code ='required' )
def get_default_timezone ( ) :
def get_host ( self ) :
return
fmt = config. get ( 'format', None )
if finder. find_module ( name ) :
ipv4_address = "%d.%d.%d%d" % ( 6 [ 2 : 2 ], ( hextets
return [ bytes_to_text ( elt, self. encoding ) for elt in list_ ]
return name, ser_fmt, ccmp_fmt
from django. utils. http import urlquote
if value. tzinfo is None and value. tzinfo. utcoffset ( value ) is None :
else :
code_list. append ( context [ v ] )
kwargs [ 'initial' ] = self. parent_instance. pk
last = max ( 0, end - 1 )
def __init__ ( self, widgets, attrs = None ) :
class WSGIServer ( simple_server. WSGIServer, object ) :
except Exception as e :
state = self. state
def __get__ ( self, obj, tp ) :
if not tag in tags. tag_exists ( tag ) :
if use_l10n or ( use_l10n is None and settings. USE_L10N ) :
self. activated = True
return '', ''
def wrapper ( * args, ** kwargs ) :
id_ += '_0'
def format_subject ( self, subject ) :
kwargs = match. groupdict ( )
for dict_ in self. dicts :
self. nodelist = t. nodelist
def __bool__ ( self ) :
import sys
kwargs [ 'number' ] = number_value
return result
if hasattr ( timezone, 'normalize' ) :
value = force_text ( value )
weight = 0
from super ( SimpleCookie, self ). load ( rawdata )
class DefusedXmlException ( ValueError ) :
else :
self. _leftover = b''. join ( bytes, self. _leftover )
formfield = f. formfield ( ** kwargs )
return
def make_decorator ( * m_args, ** m_kwargs ) :
def _set_post ( self, post ) :
def clear ( self ) :
if safe is not None :
filter_expression = self. compile_filter ( token. contents )
attrs = super ( DecimalField, self ). widget_attrs ( widget )
return bytes ( value )
if self. allow_folders :
app_list = resolver. app_dict [ ns ]
def activate ( timezone ) :
else :
def writeString ( self, encoding ) :
else :
choices = property ( _get_choices, _set_choices )
def has_other_pages ( self ) :
parser. modules [ __name__ + ".moves.urllib_parse" ] = sys. modules [ __name__ + ".m
form. save_m2m = save_m2m
else :
_templatetags_modules. append ( templatetag_module )
return format_html_join ( '', '{0}{1}"', format_join ( self. _meta [ 2 ],
return self
self. can_write. release ( )
raise KeyError ( key )
for arg in args :
def has_key ( self, key ) :
kw ['microsecond' ] = kw ['microsecond' ]. ljust ( 6, '0' )
if var. find ( VARIABLE_ATTRIBUTE_SEPARATOR ) > - 1 :
__all__ = ( 'MultiPartParser', 'MultiPartParserError', 'InputStreamExhausted' )
dictreprs = ', '. join ( repr ( d ) for d in self. dicts )
elif field. rel and isinstance ( field. rel, models. ManyToOneRel ) :
if text == len ( opts ) and len ( opts ) == 1 and opts [ 0 ] =='reset' :
from django. utils. six. moves. urllib. parse import urljoin
self. xml. startElement ( "natural", { } )
@ property
raise ValidationError ( self. error_messages [ 'invalid_choice' ], code = 'invalid_choice', params
self. delete ( key, version = version )
new_matches = normalize ( parent_pat + pat )
yield self [ key ]
cache [ key ] = result
self. cookies [ key ] ['max-age' ] = max_age
def __copy__ ( self ) :
from django. utils. functional import lazy
sites1 = _findall ( str ( s1, year ) )
for middleware_method in self. _request_middleware :
def add_arguments ( self, parser ) :
ULONG_PTR = c_int64
if not language_code_re. search ( lang_code ) :
if isinstance ( s, bytes ) :
for connector_name, object_list in self. m2m_data. items ( ) :
if isinstance ( obj, datetime. datetime ) :
handler. addQuickElement ( "pubDate", rfc2822_date ( item [ 'pubdate' ] ) )
self. file = file. mode
fils = int ( candidate ) + int ( c ) + ( c )
if sys. version_info [ 0 ] == 3 :
chunk = b''. join ( chunks )
app_template_dirs = [ ]
def split_leading_dir ( self, path ) :
with self. _lock. reader ( ) :
locale_dir = self. default_locale_path
output_transaction = True
obj = Model ( ** data )
return apps. setdefault ( pattern, [ ] ). append ( pattern. namespace )
for key, value in data :
def configure_root ( self, config, incremental = False ) :
if item [ 'pubdate' ] is not None :
tzinfo = get_fixed_timezone ( offset )
class SuspiciousOperation ( Exception ) :
from django. conf import settings
try :
if os. path. isdir ( app_dir ) :
def mark_for_escaping ( s ) :
except AttributeError :
obj_pk = field. rel. to. _meta. get_field ( field. rel. field_name ). to_python
def __init__ ( self, object_list, number, paginator ) :
return [ None, None ]
def timeuntil ( d, now = None ) :
super ( DecimalField, self ). validate ( value )
field_type ='ForeignKey(' + rel_to
def avoid_wrapping ( value ) :
from django. core. serializers. python import Deserializer as PythonDeserializer
if code is not None :
raise TemplateSyntaxError ( "'firstof' statement requires at least one argument" )
from importlib import find_loader as importlib_find
msgs, errors, status = popen_wrapper ( args )
id_ = self. field. widget. attrs. get ( 'id' ) or self. auto_id
return "< Block Node: %s. contents: %r>" % ( self. name, self. nodelist )
if nodelist_empty is None :
def __iter__ ( self ) :
from django. utils. module_loading import import_string
return b''. join ( b' '\n'. join ( self. make_bytes ( chunk ) ) for chunk in value )
if value in self. empty_values :
parser. add_argument ('migration_name', action ='store_true', dest ='migration', default =
def jython_reloader ( main_func, args, kwargs ) :
from django. test. signals import setting_changed
file. seek ( 0 )
return False
from django. template. base import TemplateDoesNotExist
from django. http import HttpResponse
code = 'limit_value'
text = match. group ( 1 )
for line in '\r\n'. split ( '\r\n' ) :
obj = base. build_instance ( Model, data, db )
iterkeys = _iterkeys
return value. pk
quant. append ( ch )
def write ( self, val ) :
def handle_app_config ( self, app_config, ** options ) :
return None
num_loopvars = len ( self. loopvars )
deactivate, deactivate_all = lambda self : None
AG = 1 << 10
start = 0
def render_option ( self, selected_choices, option_value, option_label ) :
def __getitem__ ( self, key ) :
language_code = get_language ( )
if bit. startswith ( '_(' ). startswith ( "_(' ) :
return _i18n_cache_key_suffix ( request, cache_key )
try :
c = int ( text [ 1 : ] )
if not os. path. isdir ( self. file_path, os. path. isdir ) :
if self. feed [ 'feed_url' ] is not None :
return
import os
return iter ( getattr ( d, _iterlists ) ( ** kw ) )
def wrapper ( * args, ** kwds ) :
out. write ('pgettext(%r, %r)'% join_tokens ( message_context, join_only
return self. getlist ( key )
defaults = dict ( defaults. _get_kwargs, ** options )
response = self. urlconf_module ( 'handler%s' % view_type )
warnings_msg = "The translation- target '%s' %sline %d) be set ( " "The importt't it
return force_text ( getattr ( self, getattr ( self, getattr ( ) ) ) )
d = data. get ( self. day_field % name )
func = getattr ( func, '_decorated_function', func )
for name, block in six. iteritems ( blocks ) :
import django
potfiles = self. build_potfiles ( )
self. stdout. write ( "Runninging %s for for fixtures in tags if ser_fmt is not None )
import sys
if len ( bits )!= 3 :
extim = self. _archive. extractfile ( member )
import binascii
else :
filES = property ( _get_files )
return True
with self. mutex :
return get_template ( template_name, dirs )
l = lambda x : self. make_key ( x, version = version )
def upload_handlers ( self ) :
except AmbiguityError :
except ValidationError as e :
return {'request' : request }
except AttributeError :
result = func ( * args )
else :
from django. utils. encoding import force_text, DEFAULT_LOCALE_ENCODING
field_fields = [ field for field in apps. get_models if model. get_models ( "configs is None else None )
self. ignore = options. get ( 'ignore' )
class NowNode ( Node ) :
except StandardError as e :
if msg :
_error_files = [ ]
@ register. filter ( is_safe = True, needs_autoescape = True )
if isinstance ( filename, MIMEBase ) :
class DebugNodeList ( NodeList ) :
prefix = 1. 0
raise KeyError ( key )
elif isinstance ( klass, logging. handlers. SMTPHandler ) and'mail' in config :
return maybe
def _handle_m2m_field_node ( self, node, field ) :
return super ( DebugParser, self ). extend_nodelist ( nodelist, node, token )
from django. utils. itercompat import is_iterable
return self. has_key ( key )
new_class = super ( mcsFieldsMetaclass, mcs, bases, attrs )
continue
return self. save_existing_objects ( commit ) + self. save_new_objects. items ( ) + self. save_existing_
for attr in ( 'expects_localtime', 'is_safe','needs_autoescape' ) :
for f in file_list :
import re
for processors in get_standard_processors ( ) :
field_name = force_text ( old_field_name, self. _encoding, errors ='replace' )
yield v
else :
cc = dict ( _to_tuple ( el ), dict ( el ) for el in items )
scheme = template. split ( ':'' ) [ 0 ]. lower ( )
DEATE_MAPPING = { 'A' : None, 'b' : None, 'd' : '0' : '2'
locales = [ locale ]
nodelist = parser. parse ( ( 'endblock', ) )
loaders = [ ]
@ register. tag
return client
bit. append ( os. stat ( path ), stat. S_Imode )
def __delitem__ ( self, key ) :
expanded_template = path. expanduser ( template )
data [ field. widget. value_from_datadict ( self. data, self. files, self. handle ( ) ) ] =
def pbkdf2 ( password, salt, iterations, dklen = 0, digest = None ) :
def get_default_timezone_name ( ) :
ch2 = None
def handle_uncaught_exception ( self, request, resolver, exc_info ) :
new_attr = name
parts = config_string. lower ( ). split ( ';' )
doublecolon_start = - 1
self. _start_relational_field ( field )
s = s. decode ( encoding, errors )
if token == "not" and i + 1 < l :
self. help_texts = getattr ( options, 'help_texts', None )
if not match or match. group ( 1 ) :
elif ch == 'P' :
from django. core. wgi import get_wsgi_application
self. appendlist ( force_text ( force_text ( "Django 1.0", encoding = 'ascii',
while i < len ( subject ) and subject [ i ]!= p [ i ] :
return value. replace ( tzinfo = None )
return type ( self ). __bool__ ( self )
parser. add_argument ( '--database', action ='store', dest = 'database', default = DEFAULT_DB_
pk_value = form. instance. pk
return [ etag_str ]
readline. parse_and_bind ( " tab:complete" )
while ch!= terminal_char :
return self. _namespace_dict [ language_code ]
self. changed_objects. append ( ( obj, form. changed_data ) )
 Content = delta. days + 24 + 60, 60. seconds // 60
key += tuple ( type ( k, v ) for k, v in sorted_items )
translation. activate ( saved_locale )
for func in self. response_fixes :
class DebugNode ( Node ) :
import os
try :
if expires < now :
from django. utils. translation import ugettext, ungettext
def valid_value ( self, value ) :
obj = mark_safe ( new_obj )
MB = 1 << 40
return r
from django. core. exceptions import ImproperlyConfigured
handle_app ( app_config. models_module, ** options )
self. validate_key ( key )
@ stringfilter
self. xml = SimplerXMLGenerator ( self. stream, self. encoding [ 'encoding' ] )
self. validate_key ( key )
parser. add_argument ( '--noreload', action ='store_true', dest = 'use_false', default
try :
import cgi
attrs [ 'error_messages' ] = error_messages
return output
def load_template ( self, template_name, template_dirs = None ) :
def __str__ ( self ) :
return len ( self. get_queryset ( ) )
return compiled_parent. _render ( context )
self. exception = Exception
from django. core. files. base import File
handlers = config. get ( 'handlers', EMPTY_DICT )
for root in settings. ALLOWED_INCTUAGE_ROOT_roOT :
for field in self. fields. values ( ) :
def O ( self ) :
return mark_safe ( n for n in nodelist ( force_text ( n ) )
parser. add_argument ( '-o', action ='store', dest = 'interactive', default = DEFAULT_DB
raise NotImplementedError ('subclasses of Storage must provide a listdir() method' )
if is_templatized :
import sys
want_unicode = True
_format_cache = { }
return ( ret == 0 )
self. message_context = None
if varDAYS_re = { 1 : 'Mon', 'Sun' : { 'Sun' : 2 : _ ( 'Sat',
for _, nodelist in self. conditions_nodelists :
else :
val = None
if USE_INOTIFY :
hidden_fields. append ( six. text_type ( bf ) )
return bool ( value )
from django. utils. six. moves. urllib. parse import parse_qsl, urlencode, urllsplit
self. xml. startElement ( "field", { "rel" : field. name, "rel" : self. xml. startsw
from django. db import connections, router, transaction, DEFAULT_DB_ALIAS
self. active_readers += t
return super ( DateField, self ). to_python ( value )
def _get_scheme ( self ) :
self. loaded_object_count = 0
defaults [ 'empty_permitted' ] >= self. min_num
raise TemplateDoesNotExist ( )
s = s. replace ( '\\', '\\' )
firstfirst = lambda x : force_text ( x ) if x else force_text ( x )
return self. data. isoformat ( )
result = super ( MultiValueField, self ). __deepcopy__ ( memo )
elif count > 1 :
self. stdout. write ( " - %s\n" % operation.out ( ) )
return repr ( list ( self ) )
@ python_2_unicode_compatible
if '__str__' not in __dict__. __dict__ :
from. import Error, Tags, register
if self. data. minute == 0 and self. data. hour == 0 :
field_desc +='#'. join ( comment_notes )
else :
return self. DTDIFF
self. stdout. write ( self. template_with_clear ( "%s" % errors )
 traceback. print_exc ( )
self. timezone = None
return tpl. format ( self. name, self. sysid, self. pubid )
else :
raise NotImplementedError ( "This backend doesn't support % paths." )
from. import six
if isinstance ( rhs, dict ) and number :
connection = connections [ options [ 'database' ] ]
elif cls. _delegate_bytes :
inner. update ( password. translate ( hmac. trans_unicCookie ) )
if 'charset' in content_params :
def __str__ ( self ) :
with self. _lock. writer ( ) :
if ip_str. count ( '.' )!= 3 :
return self. dicts. pop ( )
kwargs [ 'error_messages' ] = error_messages [ f. name ]
return ( val, encoding )
try :
self. command_stack. append ( ( command, token. source ) )
for character in name :
def yesno ( value, arg = None ) :
def incr ( self, key, delta = 1, version = None ) :
os. makedirs ( migrations_directory )
form. fields [ BLING_FIELD_NAME ] = IntegerField ( label = _ ( 'Enter a valid choice' ), initial = Integer
using = options. get ( 'database' )
return '%s%s' % six. text_type ( arg )
 hashlib. argv [ force_bytes ( key ) ] = hashlib. shadata ( force_bytes ( key )
defaults = { 'auto_id' : self. auto_id, 'id_prefix' : self. auto_prefix ( ) }
else :
else :
except StopIteration :