idx int64 0 63k | question stringlengths 61 4.03k | target stringlengths 6 1.23k |
|---|---|---|
52,600 | def _format_lines ( self , tokensource ) : nocls = self . noclasses lsep = self . lineseparator getcls = self . ttype2class . get c2s = self . class2style escape_table = _escape_html_table tagsfile = self . tagsfile lspan = '' line = [ ] for ttype , value in tokensource : if nocls : cclass = getcls ( ttype ) while cclass is None : ttype = ttype . parent cclass = getcls ( ttype ) cspan = cclass and '<span style="%s">' % c2s [ cclass ] [ 0 ] or '' else : cls = self . _get_css_classes ( ttype ) cspan = cls and '<span class="%s">' % cls or '' parts = value . translate ( escape_table ) . split ( '\n' ) if tagsfile and ttype in Token . Name : filename , linenumber = self . _lookup_ctag ( value ) if linenumber : base , filename = os . path . split ( filename ) if base : base += '/' filename , extension = os . path . splitext ( filename ) url = self . tagurlformat % { 'path' : base , 'fname' : filename , 'fext' : extension } parts [ 0 ] = "<a href=\"%s#%s-%d\">%s" % ( url , self . lineanchors , linenumber , parts [ 0 ] ) parts [ - 1 ] = parts [ - 1 ] + "</a>" for part in parts [ : - 1 ] : if line : if lspan != cspan : line . extend ( ( ( lspan and '</span>' ) , cspan , part , ( cspan and '</span>' ) , lsep ) ) else : line . extend ( ( part , ( lspan and '</span>' ) , lsep ) ) yield 1 , '' . join ( line ) line = [ ] elif part : yield 1 , '' . join ( ( cspan , part , ( cspan and '</span>' ) , lsep ) ) else : yield 1 , lsep if line and parts [ - 1 ] : if lspan != cspan : line . extend ( ( ( lspan and '</span>' ) , cspan , parts [ - 1 ] ) ) lspan = cspan else : line . append ( parts [ - 1 ] ) elif parts [ - 1 ] : line = [ cspan , parts [ - 1 ] ] lspan = cspan if line : line . extend ( ( ( lspan and '</span>' ) , lsep ) ) yield 1 , '' . join ( line ) | Just format the tokens without any wrapping tags . Yield individual lines . |
52,601 | def _highlight_lines ( self , tokensource ) : hls = self . hl_lines for i , ( t , value ) in enumerate ( tokensource ) : if t != 1 : yield t , value if i + 1 in hls : if self . noclasses : style = '' if self . style . highlight_color is not None : style = ( ' style="background-color: %s"' % ( self . style . highlight_color , ) ) yield 1 , '<span%s>%s</span>' % ( style , value ) else : yield 1 , '<span class="hll">%s</span>' % value else : yield 1 , value | Highlighted the lines specified in the hl_lines option by post - processing the token stream coming from _format_lines . |
52,602 | def format_unencoded ( self , tokensource , outfile ) : source = self . _format_lines ( tokensource ) if self . hl_lines : source = self . _highlight_lines ( source ) if not self . nowrap : if self . linenos == 2 : source = self . _wrap_inlinelinenos ( source ) if self . lineanchors : source = self . _wrap_lineanchors ( source ) if self . linespans : source = self . _wrap_linespans ( source ) source = self . wrap ( source , outfile ) if self . linenos == 1 : source = self . _wrap_tablelinenos ( source ) if self . full : source = self . _wrap_full ( source , outfile ) for t , piece in source : outfile . write ( piece ) | The formatting process uses several nested generators ; which of them are used is determined by the user s options . |
52,603 | def bygroups ( * args ) : def callback ( lexer , match , ctx = None ) : for i , action in enumerate ( args ) : if action is None : continue elif type ( action ) is _TokenType : data = match . group ( i + 1 ) if data : yield match . start ( i + 1 ) , action , data else : data = match . group ( i + 1 ) if data is not None : if ctx : ctx . pos = match . start ( i + 1 ) for item in action ( lexer , _PseudoMatch ( match . start ( i + 1 ) , data ) , ctx ) : if item : yield item if ctx : ctx . pos = match . end ( ) return callback | Callback that yields multiple actions for each group in the match . |
52,604 | def using ( _other , ** kwargs ) : gt_kwargs = { } if 'state' in kwargs : s = kwargs . pop ( 'state' ) if isinstance ( s , ( list , tuple ) ) : gt_kwargs [ 'stack' ] = s else : gt_kwargs [ 'stack' ] = ( 'root' , s ) if _other is this : def callback ( lexer , match , ctx = None ) : if kwargs : kwargs . update ( lexer . options ) lx = lexer . __class__ ( ** kwargs ) else : lx = lexer s = match . start ( ) for i , t , v in lx . get_tokens_unprocessed ( match . group ( ) , ** gt_kwargs ) : yield i + s , t , v if ctx : ctx . pos = match . end ( ) else : def callback ( lexer , match , ctx = None ) : kwargs . update ( lexer . options ) lx = _other ( ** kwargs ) s = match . start ( ) for i , t , v in lx . get_tokens_unprocessed ( match . group ( ) , ** gt_kwargs ) : yield i + s , t , v if ctx : ctx . pos = match . end ( ) return callback | Callback that processes the match with a different lexer . |
52,605 | def do_insertions ( insertions , tokens ) : insertions = iter ( insertions ) try : index , itokens = next ( insertions ) except StopIteration : for item in tokens : yield item return realpos = None insleft = True for i , t , v in tokens : if realpos is None : realpos = i oldi = 0 while insleft and i + len ( v ) >= index : tmpval = v [ oldi : index - i ] yield realpos , t , tmpval realpos += len ( tmpval ) for it_index , it_token , it_value in itokens : yield realpos , it_token , it_value realpos += len ( it_value ) oldi = index - i try : index , itokens = next ( insertions ) except StopIteration : insleft = False break yield realpos , t , v [ oldi : ] realpos += len ( v ) - oldi while insleft : realpos = realpos or 0 for p , t , v in itokens : yield realpos , t , v realpos += len ( v ) try : index , itokens = next ( insertions ) except StopIteration : insleft = False break | Helper for lexers which must combine the results of several sublexers . |
52,606 | def _process_regex ( cls , regex , rflags , state ) : if isinstance ( regex , Future ) : regex = regex . get ( ) return re . compile ( regex , rflags ) . match | Preprocess the regular expression component of a token definition . |
52,607 | def _process_token ( cls , token ) : assert type ( token ) is _TokenType or callable ( token ) , 'token type must be simple type or callable, not %r' % ( token , ) return token | Preprocess the token component of a token definition . |
52,608 | def _process_new_state ( cls , new_state , unprocessed , processed ) : if isinstance ( new_state , str ) : if new_state == '#pop' : return - 1 elif new_state in unprocessed : return ( new_state , ) elif new_state == '#push' : return new_state elif new_state [ : 5 ] == '#pop:' : return - int ( new_state [ 5 : ] ) else : assert False , 'unknown new state %r' % new_state elif isinstance ( new_state , combined ) : tmp_state = '_tmp_%d' % cls . _tmpname cls . _tmpname += 1 itokens = [ ] for istate in new_state : assert istate != new_state , 'circular state ref %r' % istate itokens . extend ( cls . _process_state ( unprocessed , processed , istate ) ) processed [ tmp_state ] = itokens return ( tmp_state , ) elif isinstance ( new_state , tuple ) : for istate in new_state : assert ( istate in unprocessed or istate in ( '#pop' , '#push' ) ) , 'unknown new state ' + istate return new_state else : assert False , 'unknown new state def %r' % new_state | Preprocess the state transition action of a token definition . |
52,609 | def _process_state ( cls , unprocessed , processed , state ) : assert type ( state ) is str , "wrong state name %r" % state assert state [ 0 ] != '#' , "invalid state name %r" % state if state in processed : return processed [ state ] tokens = processed [ state ] = [ ] rflags = cls . flags for tdef in unprocessed [ state ] : if isinstance ( tdef , include ) : assert tdef != state , "circular state reference %r" % state tokens . extend ( cls . _process_state ( unprocessed , processed , str ( tdef ) ) ) continue if isinstance ( tdef , _inherit ) : continue if isinstance ( tdef , default ) : new_state = cls . _process_new_state ( tdef . state , unprocessed , processed ) tokens . append ( ( re . compile ( '' ) . match , None , new_state ) ) continue assert type ( tdef ) is tuple , "wrong rule def %r" % tdef try : rex = cls . _process_regex ( tdef [ 0 ] , rflags , state ) except Exception as err : raise ValueError ( "uncompilable regex %r in state %r of %r: %s" % ( tdef [ 0 ] , state , cls , err ) ) token = cls . _process_token ( tdef [ 1 ] ) if len ( tdef ) == 2 : new_state = None else : new_state = cls . _process_new_state ( tdef [ 2 ] , unprocessed , processed ) tokens . append ( ( rex , token , new_state ) ) return tokens | Preprocess a single state definition . |
52,610 | def process_tokendef ( cls , name , tokendefs = None ) : processed = cls . _all_tokens [ name ] = { } tokendefs = tokendefs or cls . tokens [ name ] for state in list ( tokendefs ) : cls . _process_state ( tokendefs , processed , state ) return processed | Preprocess a dictionary of token definitions . |
52,611 | def get_tokendefs ( cls ) : tokens = { } inheritable = { } for c in cls . __mro__ : toks = c . __dict__ . get ( 'tokens' , { } ) for state , items in iteritems ( toks ) : curitems = tokens . get ( state ) if curitems is None : tokens [ state ] = items try : inherit_ndx = items . index ( inherit ) except ValueError : continue inheritable [ state ] = inherit_ndx continue inherit_ndx = inheritable . pop ( state , None ) if inherit_ndx is None : continue curitems [ inherit_ndx : inherit_ndx + 1 ] = items try : new_inh_ndx = items . index ( inherit ) except ValueError : pass else : inheritable [ state ] = inherit_ndx + new_inh_ndx return tokens | Merge tokens from superclasses in MRO order returning a single tokendef dictionary . |
52,612 | def memorized_timedelta ( seconds ) : try : return _timedelta_cache [ seconds ] except KeyError : delta = timedelta ( seconds = seconds ) _timedelta_cache [ seconds ] = delta return delta | Create only one instance of each distinct timedelta |
52,613 | def memorized_datetime ( seconds ) : try : return _datetime_cache [ seconds ] except KeyError : dt = _epoch + timedelta ( seconds = seconds ) _datetime_cache [ seconds ] = dt return dt | Create only one instance of each distinct datetime |
52,614 | def memorized_ttinfo ( * args ) : try : return _ttinfo_cache [ args ] except KeyError : ttinfo = ( memorized_timedelta ( args [ 0 ] ) , memorized_timedelta ( args [ 1 ] ) , args [ 2 ] ) _ttinfo_cache [ args ] = ttinfo return ttinfo | Create only one instance of each distinct tuple |
52,615 | def unpickler ( zone , utcoffset = None , dstoffset = None , tzname = None ) : tz = pytz . timezone ( zone ) if utcoffset is None : return tz utcoffset = memorized_timedelta ( utcoffset ) dstoffset = memorized_timedelta ( dstoffset ) try : return tz . _tzinfos [ ( utcoffset , dstoffset , tzname ) ] except KeyError : pass for localized_tz in tz . _tzinfos . values ( ) : if ( localized_tz . _utcoffset == utcoffset and localized_tz . _dst == dstoffset ) : return localized_tz inf = ( utcoffset , dstoffset , tzname ) tz . _tzinfos [ inf ] = tz . __class__ ( inf , tz . _tzinfos ) return tz . _tzinfos [ inf ] | Factory function for unpickling pytz tzinfo instances . |
52,616 | def utcoffset ( self , dt , is_dst = None ) : if dt is None : return None elif dt . tzinfo is not self : dt = self . localize ( dt , is_dst ) return dt . tzinfo . _utcoffset else : return self . _utcoffset | See datetime . tzinfo . utcoffset |
52,617 | def dst ( self , dt , is_dst = None ) : if dt is None : return None elif dt . tzinfo is not self : dt = self . localize ( dt , is_dst ) return dt . tzinfo . _dst else : return self . _dst | See datetime . tzinfo . dst |
52,618 | def tzname ( self , dt , is_dst = None ) : if dt is None : return self . zone elif dt . tzinfo is not self : dt = self . localize ( dt , is_dst ) return dt . tzinfo . _tzname else : return self . _tzname | See datetime . tzinfo . tzname |
52,619 | def check_range ( number , min_r , max_r , name = "" ) : try : number = float ( number ) if number < min_r or number > max_r : raise FFmpegNormalizeError ( "{} must be within [{},{}]" . format ( name , min_r , max_r ) ) return number pass except Exception as e : raise e | Check if a number is within a given range |
52,620 | def add_media_file ( self , input_file , output_file ) : if not os . path . exists ( input_file ) : raise FFmpegNormalizeError ( "file " + input_file + " does not exist" ) ext = os . path . splitext ( output_file ) [ 1 ] [ 1 : ] if ( self . audio_codec is None or 'pcm' in self . audio_codec ) and ext in PCM_INCOMPATIBLE_EXTS : raise FFmpegNormalizeError ( "Output extension {} does not support PCM audio. Please choose a suitable audio codec with the -c:a option." . format ( ext ) ) mf = MediaFile ( self , input_file , output_file ) self . media_files . append ( mf ) self . file_count += 1 | Add a media file to normalize |
52,621 | def run_normalization ( self ) : for index , media_file in enumerate ( tqdm ( self . media_files , desc = "File" , disable = not self . progress , position = 0 ) ) : logger . info ( "Normalizing file {} ({} of {})" . format ( media_file , index + 1 , self . file_count ) ) media_file . run_normalization ( ) logger . info ( "Normalized file written to {}" . format ( media_file . output_file ) ) | Run the normalization procedures |
52,622 | def get_ffmpeg_exe ( ) : if 'FFMPEG_PATH' in os . environ : ffmpeg_exe = os . environ [ 'FFMPEG_PATH' ] else : ffmpeg_exe = which ( 'ffmpeg' ) if not ffmpeg_exe : if which ( 'avconv' ) : raise FFmpegNormalizeError ( "avconv is not supported. " "Please install ffmpeg from http://ffmpeg.org instead." ) else : raise FFmpegNormalizeError ( "Could not find ffmpeg in your $PATH or $FFMPEG_PATH. " "Please install ffmpeg from http://ffmpeg.org" ) return ffmpeg_exe | Return path to ffmpeg executable |
52,623 | def ffmpeg_has_loudnorm ( ) : cmd_runner = CommandRunner ( [ get_ffmpeg_exe ( ) , '-filters' ] ) cmd_runner . run_command ( ) output = cmd_runner . get_output ( ) if 'loudnorm' in output : return True else : logger . warning ( "Your ffmpeg version does not support the 'loudnorm' filter. " "Please make sure you are running ffmpeg v3.1 or above." ) return False | Run feature detection on ffmpeg returns True if ffmpeg supports the loudnorm filter |
52,624 | def parse_streams ( self ) : logger . debug ( "Parsing streams of {}" . format ( self . input_file ) ) cmd = [ self . ffmpeg_normalize . ffmpeg_exe , '-i' , self . input_file , '-c' , 'copy' , '-t' , '0' , '-map' , '0' , '-f' , 'null' , NUL ] cmd_runner = CommandRunner ( cmd ) cmd_runner . run_command ( ) output = cmd_runner . get_output ( ) logger . debug ( "Stream parsing command output:" ) logger . debug ( output ) output_lines = [ line . strip ( ) for line in output . split ( '\n' ) ] for line in output_lines : if not line . startswith ( 'Stream' ) : continue stream_id_match = re . search ( r'#0:([\d]+)' , line ) if stream_id_match : stream_id = int ( stream_id_match . group ( 1 ) ) if stream_id in self . _stream_ids ( ) : continue else : continue if 'Audio' in line : logger . debug ( "Found audio stream at index {}" . format ( stream_id ) ) sample_rate_match = re . search ( r'(\d+) Hz' , line ) sample_rate = int ( sample_rate_match . group ( 1 ) ) if sample_rate_match else None bit_depth_match = re . search ( r's(\d+)p?,' , line ) bit_depth = int ( bit_depth_match . group ( 1 ) ) if bit_depth_match else None self . streams [ 'audio' ] [ stream_id ] = AudioStream ( self , stream_id , sample_rate , bit_depth ) elif 'Video' in line : logger . debug ( "Found video stream at index {}" . format ( stream_id ) ) self . streams [ 'video' ] [ stream_id ] = VideoStream ( self , stream_id ) elif 'Subtitle' in line : logger . debug ( "Found subtitle stream at index {}" . format ( stream_id ) ) self . streams [ 'subtitle' ] [ stream_id ] = SubtitleStream ( self , stream_id ) if not self . streams [ 'audio' ] : raise FFmpegNormalizeError ( "Input file {} does not contain any audio streams" . format ( self . input_file ) ) if os . path . splitext ( self . output_file ) [ 1 ] . lower ( ) in [ '.wav' , '.mp3' , '.aac' ] : logger . warning ( "Output file only supports one stream. " "Keeping only first audio stream." ) first_stream = list ( self . streams [ 'audio' ] . values ( ) ) [ 0 ] self . streams [ 'audio' ] = { first_stream . stream_id : first_stream } self . streams [ 'video' ] = { } self . streams [ 'subtitle' ] = { } | Try to parse all input streams from file |
52,625 | def _get_audio_filter_cmd ( self ) : all_filters = [ ] output_labels = [ ] for audio_stream in self . streams [ 'audio' ] . values ( ) : if self . ffmpeg_normalize . normalization_type == 'ebu' : stream_filter = audio_stream . get_second_pass_opts_ebu ( ) else : stream_filter = audio_stream . get_second_pass_opts_peakrms ( ) input_label = '[0:{}]' . format ( audio_stream . stream_id ) output_label = '[norm{}]' . format ( audio_stream . stream_id ) output_labels . append ( output_label ) all_filters . append ( input_label + stream_filter + output_label ) filter_complex_cmd = ';' . join ( all_filters ) return filter_complex_cmd , output_labels | Return filter_complex command and output labels needed |
52,626 | def parse_volumedetect_stats ( self ) : logger . info ( "Running first pass volumedetect filter for stream {}" . format ( self . stream_id ) ) filter_str = '[0:{}]volumedetect' . format ( self . stream_id ) cmd = [ self . media_file . ffmpeg_normalize . ffmpeg_exe , '-nostdin' , '-y' , '-i' , self . media_file . input_file , '-filter_complex' , filter_str , '-vn' , '-sn' , '-f' , 'null' , NUL ] cmd_runner = CommandRunner ( cmd ) for progress in cmd_runner . run_ffmpeg_command ( ) : yield progress output = cmd_runner . get_output ( ) logger . debug ( "Volumedetect command output:" ) logger . debug ( output ) mean_volume_matches = re . findall ( r"mean_volume: ([\-\d\.]+) dB" , output ) if mean_volume_matches : self . loudness_statistics [ 'mean' ] = float ( mean_volume_matches [ 0 ] ) else : raise FFmpegNormalizeError ( "Could not get mean volume for {}" . format ( self . media_file . input_file ) ) max_volume_matches = re . findall ( r"max_volume: ([\-\d\.]+) dB" , output ) if max_volume_matches : self . loudness_statistics [ 'max' ] = float ( max_volume_matches [ 0 ] ) else : raise FFmpegNormalizeError ( "Could not get max volume for {}" . format ( self . media_file . input_file ) ) | Use ffmpeg with volumedetect filter to get the mean volume of the input file . |
52,627 | def parse_loudnorm_stats ( self ) : logger . info ( "Running first pass loudnorm filter for stream {}" . format ( self . stream_id ) ) opts = { 'i' : self . media_file . ffmpeg_normalize . target_level , 'lra' : self . media_file . ffmpeg_normalize . loudness_range_target , 'tp' : self . media_file . ffmpeg_normalize . true_peak , 'offset' : self . media_file . ffmpeg_normalize . offset , 'print_format' : 'json' } if self . media_file . ffmpeg_normalize . dual_mono : opts [ 'dual_mono' ] = 'true' filter_str = '[0:{}]' . format ( self . stream_id ) + 'loudnorm=' + dict_to_filter_opts ( opts ) cmd = [ self . media_file . ffmpeg_normalize . ffmpeg_exe , '-nostdin' , '-y' , '-i' , self . media_file . input_file , '-filter_complex' , filter_str , '-vn' , '-sn' , '-f' , 'null' , NUL ] cmd_runner = CommandRunner ( cmd ) for progress in cmd_runner . run_ffmpeg_command ( ) : yield progress output = cmd_runner . get_output ( ) logger . debug ( "Loudnorm first pass command output:" ) logger . debug ( output ) output_lines = [ line . strip ( ) for line in output . split ( '\n' ) ] loudnorm_start = False loudnorm_end = False for index , line in enumerate ( output_lines ) : if line . startswith ( '[Parsed_loudnorm' ) : loudnorm_start = index + 1 continue if loudnorm_start and line . startswith ( '}' ) : loudnorm_end = index + 1 break if not ( loudnorm_start and loudnorm_end ) : raise FFmpegNormalizeError ( "Could not parse loudnorm stats; no loudnorm-related output found" ) try : loudnorm_stats = json . loads ( '\n' . join ( output_lines [ loudnorm_start : loudnorm_end ] ) ) except Exception as e : raise FFmpegNormalizeError ( "Could not parse loudnorm stats; wrong JSON format in string: {}" . format ( e ) ) logger . debug ( "Loudnorm stats parsed: {}" . format ( json . dumps ( loudnorm_stats ) ) ) self . loudness_statistics [ 'ebu' ] = loudnorm_stats for key , val in self . loudness_statistics [ 'ebu' ] . items ( ) : if key == 'normalization_type' : continue if float ( val ) == - float ( "inf" ) : self . loudness_statistics [ 'ebu' ] [ key ] = - 99 elif float ( val ) == float ( "inf" ) : self . loudness_statistics [ 'ebu' ] [ key ] = 0 | Run a first pass loudnorm filter to get measured data . |
52,628 | def get_second_pass_opts_ebu ( self ) : if not self . loudness_statistics [ 'ebu' ] : raise FFmpegNormalizeError ( "First pass not run, you must call parse_loudnorm_stats first" ) input_i = float ( self . loudness_statistics [ 'ebu' ] [ "input_i" ] ) if input_i > 0 : logger . warn ( "Input file had measured input loudness greater than zero ({}), capping at 0" . format ( "input_i" ) ) self . loudness_statistics [ 'ebu' ] [ 'input_i' ] = 0 opts = { 'i' : self . media_file . ffmpeg_normalize . target_level , 'lra' : self . media_file . ffmpeg_normalize . loudness_range_target , 'tp' : self . media_file . ffmpeg_normalize . true_peak , 'offset' : self . media_file . ffmpeg_normalize . offset , 'measured_i' : float ( self . loudness_statistics [ 'ebu' ] [ 'input_i' ] ) , 'measured_lra' : float ( self . loudness_statistics [ 'ebu' ] [ 'input_lra' ] ) , 'measured_tp' : float ( self . loudness_statistics [ 'ebu' ] [ 'input_tp' ] ) , 'measured_thresh' : float ( self . loudness_statistics [ 'ebu' ] [ 'input_thresh' ] ) , 'linear' : 'true' , 'print_format' : 'json' } if self . media_file . ffmpeg_normalize . dual_mono : opts [ 'dual_mono' ] = 'true' return 'loudnorm=' + dict_to_filter_opts ( opts ) | Return second pass loudnorm filter options string for ffmpeg |
52,629 | def setup_custom_logger ( name ) : global loggers if loggers . get ( name ) : return loggers . get ( name ) formatter = logging . Formatter ( fmt = '%(levelname)s: %(message)s' ) handler = TqdmLoggingHandler ( ) handler . setFormatter ( formatter ) if system ( ) not in [ 'Windows' , 'cli' ] : logging . addLevelName ( logging . ERROR , "\033[1;31m%s\033[1;0m" % logging . getLevelName ( logging . ERROR ) ) logging . addLevelName ( logging . WARNING , "\033[1;33m%s\033[1;0m" % logging . getLevelName ( logging . WARNING ) ) logging . addLevelName ( logging . INFO , "\033[1;34m%s\033[1;0m" % logging . getLevelName ( logging . INFO ) ) logging . addLevelName ( logging . DEBUG , "\033[1;35m%s\033[1;0m" % logging . getLevelName ( logging . DEBUG ) ) logger = logging . getLogger ( name ) logger . setLevel ( logging . WARNING ) if logger . handlers : logger . handlers = [ ] logger . addHandler ( handler ) loggers . update ( dict ( name = logger ) ) return logger | Create a logger with a certain name and level |
52,630 | def register_checkers ( linter ) : linter . register_checker ( ModelChecker ( linter ) ) linter . register_checker ( DjangoInstalledChecker ( linter ) ) linter . register_checker ( JsonResponseChecker ( linter ) ) linter . register_checker ( FormChecker ( linter ) ) | Register checkers . |
52,631 | def register ( linter ) : linter . register_checker ( NewDbFieldWithDefaultChecker ( linter ) ) if not compat . LOAD_CONFIGURATION_SUPPORTED : load_configuration ( linter ) | Required method to auto register this checker . |
52,632 | def ignore_import_warnings_for_related_fields ( orig_method , self , node ) : consumer = self . _to_consume [ 0 ] new_things = { } iterat = consumer . to_consume . items if PY3 else consumer . to_consume . iteritems for name , stmts in iterat ( ) : if isinstance ( stmts [ 0 ] , ImportFrom ) : if any ( [ n [ 0 ] in ( 'ForeignKey' , 'OneToOneField' ) for n in stmts [ 0 ] . names ] ) : continue new_things [ name ] = stmts consumer . _atomic = ScopeConsumer ( new_things , consumer . consumed , consumer . scope_type ) self . _to_consume = [ consumer ] return orig_method ( self , node ) | Replaces the leave_module method on the VariablesChecker class to prevent unused - import warnings which are caused by the ForeignKey and OneToOneField transformations . By replacing the nodes in the AST with their type rather than the django field imports of the form from django . db . models import OneToOneField raise an unused - import warning |
52,633 | def is_model_admin_subclass ( node ) : if node . name [ - 5 : ] != 'Admin' or isinstance ( node . parent , ClassDef ) : return False return node_is_subclass ( node , 'django.contrib.admin.options.ModelAdmin' ) | Checks that node is derivative of ModelAdmin class . |
52,634 | def is_model_factory ( node ) : try : parent_classes = node . expr . inferred ( ) except : return False parents = ( 'factory.declarations.LazyFunction' , 'factory.declarations.SubFactory' , 'factory.django.DjangoModelFactory' ) for parent_class in parent_classes : try : if parent_class . qname ( ) in parents : return True if node_is_subclass ( parent_class , * parents ) : return True except AttributeError : continue return False | Checks that node is derivative of DjangoModelFactory or SubFactory class . |
52,635 | def is_model_mpttmeta_subclass ( node ) : if node . name != 'MPTTMeta' or not isinstance ( node . parent , ClassDef ) : return False parents = ( 'django.db.models.base.Model' , '.Model' , 'django.forms.forms.Form' , '.Form' , 'django.forms.models.ModelForm' , '.ModelForm' ) return node_is_subclass ( node . parent , * parents ) | Checks that node is derivative of MPTTMeta class . |
52,636 | def _attribute_is_magic ( node , attrs , parents ) : if node . attrname not in attrs : return False if not node . last_child ( ) : return False try : for cls in node . last_child ( ) . inferred ( ) : if isinstance ( cls , Super ) : cls = cls . _self_class if node_is_subclass ( cls , * parents ) or cls . qname ( ) in parents : return True except InferenceError : pass return False | Checks that node is an attribute used inside one of allowed parents |
52,637 | def generic_is_view_attribute ( parents , attrs ) : def is_attribute ( node ) : return _attribute_is_magic ( node , attrs , parents ) return is_attribute | Generates is_X_attribute function for given parents and attrs . |
52,638 | def is_model_view_subclass_method_shouldnt_be_function ( node ) : if node . name not in ( 'get' , 'post' ) : return False parent = node . parent while parent and not isinstance ( parent , ScopedClass ) : parent = parent . parent subclass = ( 'django.views.View' , 'django.views.generic.View' , 'django.views.generic.base.View' , ) return parent is not None and node_is_subclass ( parent , * subclass ) | Checks that node is get or post method of the View class . |
52,639 | def is_model_media_valid_attributes ( node ) : if node . name not in ( 'js' , ) : return False parent = node . parent while parent and not isinstance ( parent , ScopedClass ) : parent = parent . parent if parent is None or parent . name != "Media" : return False return True | Suppress warnings for valid attributes of Media class . |
52,640 | def is_templatetags_module_valid_constant ( node ) : if node . name not in ( 'register' , ) : return False parent = node . parent while not isinstance ( parent , Module ) : parent = parent . parent if "templatetags." not in parent . name : return False return True | Suppress warnings for valid constants in templatetags module . |
52,641 | def is_urls_module_valid_constant ( node ) : if node . name not in ( 'urlpatterns' , 'app_name' ) : return False parent = node . parent while not isinstance ( parent , Module ) : parent = parent . parent if not parent . name . endswith ( 'urls' ) : return False return True | Suppress warnings for valid constants in urls module . |
52,642 | def load_configuration ( linter ) : name_checker = get_checker ( linter , NameChecker ) name_checker . config . good_names += ( 'qs' , 'urlpatterns' , 'register' , 'app_name' , 'handler500' ) linter . config . black_list += ( 'migrations' , 'south_migrations' ) | Amend existing checker config . |
52,643 | def register ( linter ) : register_checkers ( linter ) try : from pylint_django . augmentations import apply_augmentations apply_augmentations ( linter ) except ImportError : pass if not compat . LOAD_CONFIGURATION_SUPPORTED : load_configuration ( linter ) | Registering additional checkers . |
52,644 | async def create_object ( model , ** data ) : warnings . warn ( "create_object() is deprecated, Manager.create() " "should be used instead" , DeprecationWarning ) obj = model ( ** data ) pk = await insert ( model . insert ( ** dict ( obj . __data__ ) ) ) if obj . _pk is None : obj . _pk = pk return obj | Create object asynchronously . |
52,645 | async def get_object ( source , * args ) : warnings . warn ( "get_object() is deprecated, Manager.get() " "should be used instead" , DeprecationWarning ) if isinstance ( source , peewee . Query ) : query = source model = query . model else : query = source . select ( ) model = source for obj in ( await select ( query . where ( * args ) ) ) : return obj raise model . DoesNotExist | Get object asynchronously . |
52,646 | async def delete_object ( obj , recursive = False , delete_nullable = False ) : warnings . warn ( "delete_object() is deprecated, Manager.delete() " "should be used instead" , DeprecationWarning ) if recursive : dependencies = obj . dependencies ( delete_nullable ) for query , fk in reversed ( list ( dependencies ) ) : model = fk . model if fk . null and not delete_nullable : await update ( model . update ( ** { fk . name : None } ) . where ( query ) ) else : await delete ( model . delete ( ) . where ( query ) ) result = await delete ( obj . delete ( ) . where ( obj . _pk_expr ( ) ) ) return result | Delete object asynchronously . |
52,647 | async def update_object ( obj , only = None ) : warnings . warn ( "update_object() is deprecated, Manager.update() " "should be used instead" , DeprecationWarning ) field_dict = dict ( obj . __data__ ) pk_field = obj . _meta . primary_key if only : field_dict = obj . _prune_fields ( field_dict , only ) if not isinstance ( pk_field , peewee . CompositeKey ) : field_dict . pop ( pk_field . name , None ) else : field_dict = obj . _prune_fields ( field_dict , obj . dirty_fields ) rows = await update ( obj . update ( ** field_dict ) . where ( obj . _pk_expr ( ) ) ) obj . _dirty . clear ( ) return rows | Update object asynchronously . |
52,648 | async def select ( query ) : assert isinstance ( query , peewee . SelectQuery ) , ( "Error, trying to run select coroutine" "with wrong query class %s" % str ( query ) ) cursor = await _execute_query_async ( query ) result = AsyncQueryWrapper ( cursor = cursor , query = query ) try : while True : await result . fetchone ( ) except GeneratorExit : pass finally : await cursor . release ( ) return result | Perform SELECT query asynchronously . |
52,649 | async def insert ( query ) : assert isinstance ( query , peewee . Insert ) , ( "Error, trying to run insert coroutine" "with wrong query class %s" % str ( query ) ) cursor = await _execute_query_async ( query ) try : if query . _returning : row = await cursor . fetchone ( ) result = row [ 0 ] else : database = _query_db ( query ) last_id = await database . last_insert_id_async ( cursor ) result = last_id finally : await cursor . release ( ) return result | Perform INSERT query asynchronously . Returns last insert ID . This function is called by object . create for single objects only . |
52,650 | async def update ( query ) : assert isinstance ( query , peewee . Update ) , ( "Error, trying to run update coroutine" "with wrong query class %s" % str ( query ) ) cursor = await _execute_query_async ( query ) rowcount = cursor . rowcount await cursor . release ( ) return rowcount | Perform UPDATE query asynchronously . Returns number of rows updated . |
52,651 | async def delete ( query ) : assert isinstance ( query , peewee . Delete ) , ( "Error, trying to run delete coroutine" "with wrong query class %s" % str ( query ) ) cursor = await _execute_query_async ( query ) rowcount = cursor . rowcount await cursor . release ( ) return rowcount | Perform DELETE query asynchronously . Returns number of rows deleted . |
52,652 | def sync_unwanted ( database ) : warnings . warn ( "sync_unwanted() context manager is deprecated, " "use database's `.allow_sync()` context manager or " "`Manager.allow_sync()` context manager. " , DeprecationWarning ) old_allow_sync = database . _allow_sync database . _allow_sync = False yield database . _allow_sync = old_allow_sync | Context manager for preventing unwanted sync queries . UnwantedSyncQueryError exception will raise on such query . |
52,653 | async def get ( self , source_ , * args , ** kwargs ) : await self . connect ( ) if isinstance ( source_ , peewee . Query ) : query = source_ model = query . model else : query = source_ . select ( ) model = source_ conditions = list ( args ) + [ ( getattr ( model , k ) == v ) for k , v in kwargs . items ( ) ] if conditions : query = query . where ( * conditions ) try : result = await self . execute ( query ) return list ( result ) [ 0 ] except IndexError : raise model . DoesNotExist | Get the model instance . |
52,654 | async def create ( self , model_ , ** data ) : inst = model_ ( ** data ) query = model_ . insert ( ** dict ( inst . __data__ ) ) pk = await self . execute ( query ) if inst . _pk is None : inst . _pk = pk return inst | Create a new object saved to database . |
52,655 | async def get_or_create ( self , model_ , defaults = None , ** kwargs ) : try : return ( await self . get ( model_ , ** kwargs ) ) , False except model_ . DoesNotExist : data = defaults or { } data . update ( { k : v for k , v in kwargs . items ( ) if '__' not in k } ) return ( await self . create ( model_ , ** data ) ) , True | Try to get an object or create it with the specified defaults . |
52,656 | async def create_or_get ( self , model_ , ** kwargs ) : try : return ( await self . create ( model_ , ** kwargs ) ) , True except IntegrityErrors : query = [ ] for field_name , value in kwargs . items ( ) : field = getattr ( model_ , field_name ) if field . unique or field . primary_key : query . append ( field == value ) return ( await self . get ( model_ , * query ) ) , False | Try to create new object with specified data . If object already exists then try to get it by unique fields . |
52,657 | def _subclassed ( base , * classes ) : return all ( map ( lambda obj : isinstance ( obj , base ) , classes ) ) | Check if all classes are subclassed from base . |
52,658 | def _get_result_wrapper ( self , query ) : cursor = RowsCursor ( self . _rows , self . _cursor . description ) return query . _get_cursor_wrapper ( cursor ) | Get result wrapper class . |
52,659 | async def fetchone ( self ) : row = await self . _cursor . fetchone ( ) if not row : raise GeneratorExit self . _rows . append ( row ) | Fetch single row from the cursor . |
52,660 | async def connect_async ( self , loop = None , timeout = None ) : if self . deferred : raise Exception ( "Error, database not properly initialized " "before opening connection" ) if self . _async_conn : return elif self . _async_wait : await self . _async_wait else : self . _loop = loop self . _async_wait = asyncio . Future ( loop = self . _loop ) conn = self . _async_conn_cls ( database = self . database , loop = self . _loop , timeout = timeout , ** self . connect_params_async ) try : await conn . connect ( ) except Exception as e : if not self . _async_wait . done ( ) : self . _async_wait . set_exception ( e ) self . _async_wait = None raise else : self . _task_data = TaskLocals ( loop = self . _loop ) self . _async_conn = conn self . _async_wait . set_result ( True ) | Set up async connection on specified event loop or on default event loop . |
52,661 | async def cursor_async ( self ) : await self . connect_async ( loop = self . _loop ) if self . transaction_depth_async ( ) > 0 : conn = self . transaction_conn_async ( ) else : conn = None try : return ( await self . _async_conn . cursor ( conn = conn ) ) except : await self . close_async ( ) raise | Acquire async cursor . |
52,662 | async def close_async ( self ) : if self . _async_wait : await self . _async_wait if self . _async_conn : conn = self . _async_conn self . _async_conn = None self . _async_wait = None self . _task_data = None await conn . close ( ) | Close async connection . |
52,663 | async def push_transaction_async ( self ) : await self . connect_async ( loop = self . loop ) depth = self . transaction_depth_async ( ) if not depth : conn = await self . _async_conn . acquire ( ) self . _task_data . set ( 'conn' , conn ) self . _task_data . set ( 'depth' , depth + 1 ) | Increment async transaction depth . |
52,664 | async def pop_transaction_async ( self ) : depth = self . transaction_depth_async ( ) if depth > 0 : depth -= 1 self . _task_data . set ( 'depth' , depth ) if depth == 0 : conn = self . _task_data . get ( 'conn' ) self . _async_conn . release ( conn ) else : raise ValueError ( "Invalid async transaction depth value" ) | Decrement async transaction depth . |
52,665 | def allow_sync ( self ) : old_allow_sync = self . _allow_sync self . _allow_sync = True try : yield except : raise finally : try : self . close ( ) except self . Error : pass self . _allow_sync = old_allow_sync | Allow sync queries within context . Close sync connection on exit if connected . |
52,666 | def execute_sql ( self , * args , ** kwargs ) : assert self . _allow_sync , ( "Error, sync query is not allowed! Call the `.set_allow_sync()` " "or use the `.allow_sync()` context manager." ) if self . _allow_sync in ( logging . ERROR , logging . WARNING ) : logging . log ( self . _allow_sync , "Error, sync query is not allowed: %s %s" % ( str ( args ) , str ( kwargs ) ) ) return super ( ) . execute_sql ( * args , ** kwargs ) | Sync execute SQL query allow_sync must be set to True . |
52,667 | async def cursor ( self , conn = None , * args , ** kwargs ) : in_transaction = conn is not None if not conn : conn = await self . acquire ( ) cursor = await conn . cursor ( * args , ** kwargs ) cursor . release = functools . partial ( self . release_cursor , cursor , in_transaction = in_transaction ) return cursor | Get a cursor for the specified transaction connection or acquire from the pool . |
52,668 | def connect_params_async ( self ) : kwargs = self . connect_params . copy ( ) kwargs . update ( { 'minsize' : self . min_connections , 'maxsize' : self . max_connections , 'enable_json' : self . _enable_json , 'enable_hstore' : self . _enable_hstore , } ) return kwargs | Connection parameters for aiopg . Connection |
52,669 | async def release_cursor ( self , cursor , in_transaction = False ) : conn = cursor . connection await cursor . close ( ) if not in_transaction : self . release ( conn ) | Release cursor coroutine . Unless in transaction the connection is also released back to the pool . |
52,670 | def connect_params_async ( self ) : kwargs = self . connect_params . copy ( ) kwargs . update ( { 'minsize' : self . min_connections , 'maxsize' : self . max_connections , 'autocommit' : True , } ) return kwargs | Connection parameters for aiomysql . Connection |
52,671 | def get ( self , key , * val ) : data = self . get_data ( ) if data is not None : return data . get ( key , * val ) if val : return val [ 0 ] raise KeyError ( key ) | Get value stored for current running task . Optionally you may provide the default value . Raises KeyError when can t get the value and no default one is provided . |
52,672 | def set ( self , key , val ) : data = self . get_data ( True ) if data is not None : data [ key ] = val else : raise RuntimeError ( "No task is currently running" ) | Set value stored for current running task . |
52,673 | def get_data ( self , create = False ) : task = asyncio_current_task ( loop = self . loop ) if task : task_id = id ( task ) if create and task_id not in self . data : self . data [ task_id ] = { } task . add_done_callback ( self . del_data ) return self . data . get ( task_id ) return None | Get dict stored for current running task . Return None or an empty dict if no data was found depending on the create argument value . |
52,674 | def _get_from_bin ( self ) : java_bin = os . path . realpath ( self . _java ) if os . path . exists ( java_bin ) : java_home = os . path . abspath ( os . path . join ( os . path . dirname ( java_bin ) , '..' ) ) return self . find_libjvm ( java_home ) | Retrieves the Java library path according to the real installation of the java executable |
52,675 | def initialize_options ( self , * args ) : import distutils . sysconfig cfg_vars = distutils . sysconfig . get_config_vars ( ) for k , v in cfg_vars . items ( ) : if isinstance ( v , str ) and v . find ( "-Wstrict-prototypes" ) : v = v . replace ( '-Wstrict-prototypes' , '' ) cfg_vars [ k ] = v if isinstance ( v , str ) and v . find ( "-Wimplicit-function-declaration" ) : v = v . replace ( '-Wimplicit-function-declaration' , '' ) cfg_vars [ k ] = v build_ext . initialize_options ( self ) | omit - Wstrict - prototypes from CFLAGS since its only valid for C code . |
52,676 | def addClassPath ( path1 ) : global _CLASSPATHS path1 = _os . path . abspath ( path1 ) if _sys . platform == 'cygwin' : path1 = _posix2win ( path1 ) _CLASSPATHS . add ( str ( path1 ) ) | Add a path to the java class path |
52,677 | def getClassPath ( ) : global _CLASSPATHS global _SEP out = [ ] for path in _CLASSPATHS : if path == '' : continue if path . endswith ( '*' ) : paths = _glob . glob ( path + ".jar" ) if len ( path ) == 0 : continue out . extend ( paths ) else : out . append ( path ) return _SEP . join ( out ) | Get the full java class path . |
52,678 | def find_libjvm ( self , java_home ) : found_jamvm = False non_supported_jvm = ( 'cacao' , 'jamvm' ) found_non_supported_jvm = False for root , _ , names in os . walk ( java_home ) : if self . _libfile in names : candidate = os . path . split ( root ) [ 1 ] if candidate in non_supported_jvm : found_non_supported_jvm = True continue return os . path . join ( root , self . _libfile ) else : if found_non_supported_jvm : raise JVMNotSupportedException ( "Sorry '{0}' is known to be " "broken. Please ensure your " "JAVA_HOME contains at least " "another JVM implementation " "(eg. server)" . format ( candidate ) ) raise JVMNotFoundException ( "Sorry no JVM could be found. " "Please ensure your JAVA_HOME " "environment variable is pointing " "to correct installation." ) | Recursively looks for the given file |
52,679 | def find_possible_homes ( self , parents ) : homes = [ ] java_names = ( 'jre' , 'jdk' , 'java' ) for parent in parents : for childname in sorted ( os . listdir ( parent ) ) : path = os . path . realpath ( os . path . join ( parent , childname ) ) if path in homes or not os . path . isdir ( path ) : continue real_name = os . path . basename ( path ) . lower ( ) for java_name in java_names : if java_name in real_name : homes . append ( path ) yield path break | Generator that looks for the first - level children folders that could be Java installations according to their name |
52,680 | def _get_from_java_home ( self ) : java_home = os . getenv ( "JAVA_HOME" ) if java_home and os . path . exists ( java_home ) : java_home = os . path . realpath ( java_home ) if not os . path . exists ( java_home ) : java_home = os . getenv ( "JAVA_HOME" ) return self . find_libjvm ( java_home ) | Retrieves the Java library path according to the JAVA_HOME environment variable |
52,681 | def _get_from_known_locations ( self ) : for home in self . find_possible_homes ( self . _locations ) : jvm = self . find_libjvm ( home ) if jvm is not None : return jvm | Retrieves the first existing Java library path in the predefined known locations |
52,682 | def node_query ( self , node ) : if isinstance ( node , ast . Call ) : assert node . args arg = node . args [ 0 ] if not isinstance ( arg , ast . Str ) : return else : raise TypeError ( type ( node ) ) return arg . s | Return the query for the gql call node |
52,683 | def default ( thumbnailer , prepared_options , source_filename , thumbnail_extension , ** kwargs ) : filename_parts = [ source_filename ] if ( '%(opts)s' in thumbnailer . thumbnail_basedir or '%(opts)s' in thumbnailer . thumbnail_subdir ) : if thumbnail_extension != os . path . splitext ( source_filename ) [ 1 ] [ 1 : ] : filename_parts . append ( thumbnail_extension ) else : filename_parts += [ '_' . join ( prepared_options ) , thumbnail_extension ] return '.' . join ( filename_parts ) | Easy - thumbnails default name processor . |
52,684 | def hashed ( source_filename , prepared_options , thumbnail_extension , ** kwargs ) : parts = ':' . join ( [ source_filename ] + prepared_options ) short_sha = hashlib . sha1 ( parts . encode ( 'utf-8' ) ) . digest ( ) short_hash = base64 . urlsafe_b64encode ( short_sha [ : 9 ] ) . decode ( 'utf-8' ) return '.' . join ( [ short_hash , thumbnail_extension ] ) | Generate a short hashed thumbnail filename . |
52,685 | def source_hashed ( source_filename , prepared_options , thumbnail_extension , ** kwargs ) : source_sha = hashlib . sha1 ( source_filename . encode ( 'utf-8' ) ) . digest ( ) source_hash = base64 . urlsafe_b64encode ( source_sha [ : 9 ] ) . decode ( 'utf-8' ) parts = ':' . join ( prepared_options [ 1 : ] ) parts_sha = hashlib . sha1 ( parts . encode ( 'utf-8' ) ) . digest ( ) options_hash = base64 . urlsafe_b64encode ( parts_sha [ : 6 ] ) . decode ( 'utf-8' ) return '%s_%s_%s.%s' % ( source_hash , prepared_options [ 0 ] , options_hash , thumbnail_extension ) | Generate a thumbnail filename of the source filename and options separately hashed along with the size . |
52,686 | def save_image ( image , destination = None , filename = None , ** options ) : if destination is None : destination = BytesIO ( ) filename = filename or '' Image . init ( ) format = Image . EXTENSION . get ( os . path . splitext ( filename ) [ 1 ] . lower ( ) , 'JPEG' ) if format in ( 'JPEG' , 'WEBP' ) : options . setdefault ( 'quality' , 85 ) saved = False if format == 'JPEG' : if image . mode . endswith ( 'A' ) : image = image . convert ( image . mode [ : - 1 ] ) if settings . THUMBNAIL_PROGRESSIVE and ( max ( image . size ) >= settings . THUMBNAIL_PROGRESSIVE ) : options [ 'progressive' ] = True try : image . save ( destination , format = format , optimize = 1 , ** options ) saved = True except IOError : pass if not saved : image . save ( destination , format = format , ** options ) if hasattr ( destination , 'seek' ) : destination . seek ( 0 ) return destination | Save a PIL image . |
52,687 | def generate_source_image ( source_file , processor_options , generators = None , fail_silently = True ) : processor_options = ThumbnailOptions ( processor_options ) was_closed = getattr ( source_file , 'closed' , False ) if generators is None : generators = [ utils . dynamic_import ( name ) for name in settings . THUMBNAIL_SOURCE_GENERATORS ] exceptions = [ ] try : for generator in generators : source = source_file try : source . open ( ) except Exception : try : source . seek ( 0 ) except Exception : source = None try : image = generator ( source , ** processor_options ) except Exception as e : if not fail_silently : if len ( generators ) == 1 : raise exceptions . append ( e ) image = None if image : return image finally : if was_closed : try : source_file . close ( ) except Exception : pass if exceptions and not fail_silently : raise NoSourceGenerator ( * exceptions ) | Processes a source File through a series of source generators stopping once a generator returns an image . |
52,688 | def revert ( self ) : for attr , value in self . _changed . items ( ) : setattr ( django_settings , attr , value ) for attr in self . _added : delattr ( django_settings , attr ) self . _changed = { } self . _added = [ ] if self . isolated : self . _isolated_overrides = BaseSettings ( ) | Revert any changes made to settings . |
52,689 | def pil_image ( source , exif_orientation = True , ** options ) : if not source : return source = BytesIO ( source . read ( ) ) image = Image . open ( source ) try : image . load ( ) except IOError : pass image . load ( ) if exif_orientation : image = utils . exif_orientation ( image ) return image | Try to open the source file directly using PIL ignoring any errors . |
52,690 | def optimize_thumbnail ( thumbnail ) : try : optimize_command = settings . THUMBNAIL_OPTIMIZE_COMMAND [ determinetype ( thumbnail . path ) ] if not optimize_command : return except ( TypeError , KeyError , NotImplementedError ) : return storage = thumbnail . storage try : with NamedTemporaryFile ( ) as temp_file : thumbnail . seek ( 0 ) temp_file . write ( thumbnail . read ( ) ) temp_file . flush ( ) optimize_command = optimize_command . format ( filename = temp_file . name ) output = check_output ( optimize_command , stderr = subprocess . STDOUT , shell = True ) if output : logger . warning ( '{0} returned {1}' . format ( optimize_command , output ) ) else : logger . info ( '{0} returned nothing' . format ( optimize_command ) ) with open ( temp_file . name , 'rb' ) as f : thumbnail . file = ContentFile ( f . read ( ) ) storage . delete ( thumbnail . path ) storage . save ( thumbnail . path , thumbnail ) except Exception as e : logger . error ( e ) | Optimize thumbnail images by removing unnecessary data |
52,691 | def thumbnail ( parser , token ) : args = token . split_contents ( ) tag = args [ 0 ] if len ( args ) > 4 and args [ - 2 ] == 'as' : context_name = args [ - 1 ] args = args [ : - 2 ] else : context_name = None if len ( args ) < 3 : raise TemplateSyntaxError ( "Invalid syntax. Expected " "'{%% %s source size [option1 option2 ...] %%}' or " "'{%% %s source size [option1 option2 ...] as variable %%}'" % ( tag , tag ) ) opts = { } source_var = parser . compile_filter ( args [ 1 ] ) size = args [ 2 ] match = RE_SIZE . match ( size ) if match : size = '"%s"' % size opts [ 'size' ] = parser . compile_filter ( size ) args_list = split_args ( args [ 3 : ] ) . items ( ) for arg , value in args_list : if arg in VALID_OPTIONS : if value and value is not True : value = parser . compile_filter ( value ) opts [ arg ] = value else : raise TemplateSyntaxError ( "'%s' tag received a bad argument: " "'%s'" % ( tag , arg ) ) return ThumbnailNode ( source_var , opts = opts , context_name = context_name ) | Creates a thumbnail of an ImageField . |
52,692 | def thumbnail_url ( source , alias ) : try : thumb = get_thumbnailer ( source ) [ alias ] except Exception : return '' return thumb . url | Return the thumbnail url for a source file using an aliased set of thumbnail options . |
52,693 | def data_uri ( thumbnail ) : try : thumbnail . open ( 'rb' ) data = thumbnail . read ( ) finally : thumbnail . close ( ) mime_type = mimetypes . guess_type ( str ( thumbnail . file ) ) [ 0 ] or 'application/octet-stream' data = b64encode ( data ) . decode ( 'utf-8' ) return 'data:{0};base64,{1}' . format ( mime_type , data ) | This filter will return the base64 encoded data URI for a given thumbnail object . |
52,694 | def read_files ( * filenames ) : output = [ ] for filename in filenames : f = codecs . open ( filename , encoding = 'utf-8' ) try : output . append ( f . read ( ) ) finally : f . close ( ) return '\n\n' . join ( output ) | Output the contents of one or more files to a single concatenated string . |
52,695 | def all_thumbnails ( path , recursive = True , prefix = None , subdir = None ) : if prefix is None : prefix = settings . THUMBNAIL_PREFIX if subdir is None : subdir = settings . THUMBNAIL_SUBDIR thumbnail_files = { } if not path . endswith ( '/' ) : path = '%s/' % path len_path = len ( path ) if recursive : all = os . walk ( path ) else : files = [ ] for file in os . listdir ( path ) : if os . path . isfile ( os . path . join ( path , file ) ) : files . append ( file ) all = [ ( path , [ ] , files ) ] for dir_ , subdirs , files in all : rel_dir = dir_ [ len_path : ] for file in files : thumb = re_thumbnail_file . match ( file ) if not thumb : continue d = thumb . groupdict ( ) source_filename = d . pop ( 'source_filename' ) if prefix : source_path , source_filename = os . path . split ( source_filename ) if not source_filename . startswith ( prefix ) : continue source_filename = os . path . join ( source_path , source_filename [ len ( prefix ) : ] ) d [ 'options' ] = d [ 'options' ] and d [ 'options' ] . split ( '_' ) or [ ] if subdir and rel_dir . endswith ( subdir ) : rel_dir = rel_dir [ : - len ( subdir ) ] m = re . match ( r'(.*)_(.*)' , source_filename ) if m : source_filename = '%s.%s' % m . groups ( ) filename = os . path . join ( rel_dir , source_filename ) thumbnail_file = thumbnail_files . setdefault ( filename , [ ] ) d [ 'filename' ] = os . path . join ( dir_ , file ) thumbnail_file . append ( d ) return thumbnail_files | Return a dictionary referencing all files which match the thumbnail format . |
52,696 | def thumbnails_for_file ( relative_source_path , root = None , basedir = None , subdir = None , prefix = None ) : if root is None : root = settings . MEDIA_ROOT if prefix is None : prefix = settings . THUMBNAIL_PREFIX if subdir is None : subdir = settings . THUMBNAIL_SUBDIR if basedir is None : basedir = settings . THUMBNAIL_BASEDIR source_dir , filename = os . path . split ( relative_source_path ) thumbs_path = os . path . join ( root , basedir , source_dir , subdir ) if not os . path . isdir ( thumbs_path ) : return [ ] files = all_thumbnails ( thumbs_path , recursive = False , prefix = prefix , subdir = '' ) return files . get ( filename , [ ] ) | Return a list of dictionaries one for each thumbnail belonging to the source image . |
52,697 | def delete_thumbnails ( relative_source_path , root = None , basedir = None , subdir = None , prefix = None ) : thumbs = thumbnails_for_file ( relative_source_path , root , basedir , subdir , prefix ) return _delete_using_thumbs_list ( thumbs ) | Delete all thumbnails for a source image . |
52,698 | def delete_all_thumbnails ( path , recursive = True ) : total = 0 for thumbs in all_thumbnails ( path , recursive = recursive ) . values ( ) : total += _delete_using_thumbs_list ( thumbs ) return total | Delete all files within a path which match the thumbnails pattern . |
52,699 | def signal_committed_filefields ( sender , instance , ** kwargs ) : for field_name in getattr ( instance , '_uncommitted_filefields' , ( ) ) : fieldfile = getattr ( instance , field_name ) if fieldfile : signals . saved_file . send_robust ( sender = sender , fieldfile = fieldfile ) | A post_save signal handler which sends a signal for each FileField that was committed this save . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.