idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
240,400 | def get_lexer_for_mimetype ( _mime , * * options ) : for modname , name , _ , _ , mimetypes in itervalues ( LEXERS ) : if _mime in mimetypes : if name not in _lexer_cache : _load_lexers ( modname ) return _lexer_cache [ name ] ( * * options ) for cls in find_plugin_lexers ( ) : if _mime in cls . mimetypes : return cls ... | Get a lexer for a mimetype . | 143 | 10 |
240,401 | def _iter_lexerclasses ( plugins = True ) : for key in sorted ( LEXERS ) : module_name , name = LEXERS [ key ] [ : 2 ] if name not in _lexer_cache : _load_lexers ( module_name ) yield _lexer_cache [ name ] if plugins : for lexer in find_plugin_lexers ( ) : yield lexer | Return an iterator over all lexer classes . | 87 | 9 |
240,402 | def get_file_stats ( file_name , entity_type = 'file' , lineno = None , cursorpos = None , plugin = None , language = None , local_file = None ) : language = standardize_language ( language , plugin ) stats = { 'language' : language , 'dependencies' : [ ] , 'lines' : None , 'lineno' : lineno , 'cursorpos' : cursorpos ,... | Returns a hash of information about the entity . | 210 | 9 |
240,403 | def guess_language ( file_name , local_file ) : lexer = None language = get_language_from_extension ( file_name ) if language : lexer = get_lexer ( language ) else : lexer = smart_guess_lexer ( file_name , local_file ) if lexer : language = u ( lexer . name ) return language , lexer | Guess lexer and language for a file . | 85 | 10 |
240,404 | def smart_guess_lexer ( file_name , local_file ) : lexer = None text = get_file_head ( file_name ) lexer1 , accuracy1 = guess_lexer_using_filename ( local_file or file_name , text ) lexer2 , accuracy2 = guess_lexer_using_modeline ( text ) if lexer1 : lexer = lexer1 if ( lexer2 and accuracy2 and ( not accuracy1 or accur... | Guess Pygments lexer for a file . | 121 | 10 |
240,405 | def guess_lexer_using_filename ( file_name , text ) : lexer , accuracy = None , None try : lexer = custom_pygments_guess_lexer_for_filename ( file_name , text ) except SkipHeartbeat as ex : raise SkipHeartbeat ( u ( ex ) ) except : log . traceback ( logging . DEBUG ) if lexer is not None : try : accuracy = lexer . anal... | Guess lexer for given text limited to lexers for this file s extension . | 115 | 17 |
240,406 | def guess_lexer_using_modeline ( text ) : lexer , accuracy = None , None file_type = None try : file_type = get_filetype_from_buffer ( text ) except : # pragma: nocover log . traceback ( logging . DEBUG ) if file_type is not None : try : lexer = get_lexer_by_name ( file_type ) except ClassNotFound : log . traceback ( l... | Guess lexer for given text using Vim modeline . | 145 | 12 |
240,407 | def get_language_from_extension ( file_name ) : filepart , extension = os . path . splitext ( file_name ) pathpart , filename = os . path . split ( file_name ) if filename == 'go.mod' : return 'Go' if re . match ( r'\.h.*$' , extension , re . IGNORECASE ) or re . match ( r'\.c.*$' , extension , re . IGNORECASE ) : if o... | Returns a matching language for the given file extension . | 599 | 10 |
240,408 | def standardize_language ( language , plugin ) : if not language : return None # standardize language for this plugin if plugin : plugin = plugin . split ( ' ' ) [ - 1 ] . split ( '/' ) [ 0 ] . split ( '-' ) [ 0 ] standardized = get_language_from_json ( language , plugin ) if standardized is not None : return standardi... | Maps a string to the equivalent Pygments language . | 102 | 10 |
240,409 | def get_language_from_json ( language , key ) : file_name = os . path . join ( os . path . dirname ( __file__ ) , 'languages' , '{0}.json' ) . format ( key . lower ( ) ) if os . path . exists ( file_name ) : try : with open ( file_name , 'r' , encoding = 'utf-8' ) as fh : languages = json . loads ( fh . read ( ) ) if l... | Finds the given language in a json file . | 141 | 10 |
240,410 | def get_file_head ( file_name ) : text = None try : with open ( file_name , 'r' , encoding = 'utf-8' ) as fh : text = fh . read ( 512000 ) except : try : with open ( file_name , 'r' , encoding = sys . getfilesystemencoding ( ) ) as fh : text = fh . read ( 512000 ) # pragma: nocover except : log . traceback ( logging . ... | Returns the first 512000 bytes of the file s contents . | 111 | 12 |
240,411 | def custom_pygments_guess_lexer_for_filename ( _fn , _text , * * options ) : fn = basename ( _fn ) primary = { } matching_lexers = set ( ) for lexer in _iter_lexerclasses ( ) : for filename in lexer . filenames : if _fn_matches ( fn , filename ) : matching_lexers . add ( lexer ) primary [ lexer ] = True for filename in... | Overwrite pygments . lexers . guess_lexer_for_filename to customize the priority of different lexers based on popularity of languages . | 446 | 30 |
240,412 | def customize_lexer_priority ( file_name , accuracy , lexer ) : priority = lexer . priority lexer_name = lexer . name . lower ( ) . replace ( 'sharp' , '#' ) if lexer_name in LANGUAGES : priority = LANGUAGES [ lexer_name ] elif lexer_name == 'matlab' : available_extensions = extensions_in_same_folder ( file_name ) if '... | Customize lexer priority | 208 | 5 |
240,413 | def extensions_in_same_folder ( file_name ) : directory = os . path . dirname ( file_name ) files = os . listdir ( directory ) extensions = list ( zip ( * map ( os . path . splitext , files ) ) ) [ 1 ] extensions = set ( [ ext . lower ( ) for ext in extensions ] ) return extensions | Returns a list of file extensions from the same folder as file_name . | 78 | 15 |
240,414 | def analyse_text ( text ) : if re . search ( r'/\*\**\s*rexx' , text , re . IGNORECASE ) : # Header matches MVS Rexx requirements, this is certainly a Rexx # script. return 1.0 elif text . startswith ( '/*' ) : # Header matches general Rexx requirements; the source code might # still be any language using C comments su... | Check for inital comment and patterns that distinguish Rexx from other C - like languages . | 156 | 18 |
240,415 | def analyse_text ( text ) : result = 0.0 lines = text . split ( '\n' ) hasEndProc = False hasHeaderComment = False hasFile = False hasJob = False hasProc = False hasParm = False hasReport = False def isCommentLine ( line ) : return EasytrieveLexer . _COMMENT_LINE_REGEX . match ( lines [ 0 ] ) is not None def isEmptyLin... | Perform a structural analysis for basic Easytrieve constructs . | 544 | 12 |
240,416 | def analyse_text ( text ) : result = 0.0 lines = text . split ( '\n' ) if len ( lines ) > 0 : if JclLexer . _JOB_HEADER_PATTERN . match ( lines [ 0 ] ) : result = 1.0 assert 0.0 <= result <= 1.0 return result | Recognize JCL job by header . | 74 | 9 |
240,417 | def _objdump_lexer_tokens ( asm_lexer ) : hex_re = r'[0-9A-Za-z]' return { 'root' : [ # File name & format: ( '(.*?)(:)( +file format )(.*?)$' , bygroups ( Name . Label , Punctuation , Text , String ) ) , # Section header ( '(Disassembly of section )(.*?)(:)$' , bygroups ( Text , Name . Label , Punctuation ) ) , # Func... | Common objdump lexer tokens to wrap an ASM lexer . | 663 | 14 |
240,418 | def get_key ( self , fileobj ) : mapping = self . get_map ( ) if mapping is None : raise RuntimeError ( "Selector is closed" ) try : return mapping [ fileobj ] except KeyError : raise KeyError ( "{0!r} is not registered" . format ( fileobj ) ) | Return the key associated with a registered file object . | 68 | 10 |
240,419 | def get_filetype_from_buffer ( buf , max_lines = 5 ) : lines = buf . splitlines ( ) for l in lines [ - 1 : - max_lines - 1 : - 1 ] : ret = get_filetype_from_line ( l ) if ret : return ret for i in range ( max_lines , - 1 , - 1 ) : if i < len ( lines ) : ret = get_filetype_from_line ( lines [ i ] ) if ret : return ret r... | Scan the buffer for modelines and return filetype if one is found . | 111 | 15 |
240,420 | def get_font ( self , bold , oblique ) : if bold and oblique : return self . fonts [ 'BOLDITALIC' ] elif bold : return self . fonts [ 'BOLD' ] elif oblique : return self . fonts [ 'ITALIC' ] else : return self . fonts [ 'NORMAL' ] | Get the font based on bold and italic flags . | 72 | 11 |
240,421 | def _get_char_x ( self , charno ) : return charno * self . fontw + self . image_pad + self . line_number_width | Get the X coordinate of a character position . | 36 | 9 |
240,422 | def _get_text_pos ( self , charno , lineno ) : return self . _get_char_x ( charno ) , self . _get_line_y ( lineno ) | Get the actual position for a character and line position . | 43 | 11 |
240,423 | def _get_image_size ( self , maxcharno , maxlineno ) : return ( self . _get_char_x ( maxcharno ) + self . image_pad , self . _get_line_y ( maxlineno + 0 ) + self . image_pad ) | Get the required image size . | 65 | 6 |
240,424 | def _draw_linenumber ( self , posno , lineno ) : self . _draw_text ( self . _get_linenumber_pos ( posno ) , str ( lineno ) . rjust ( self . line_number_chars ) , font = self . fonts . get_font ( self . line_number_bold , self . line_number_italic ) , fill = self . line_number_fg , ) | Remember a line number drawable to paint later . | 97 | 10 |
240,425 | def _draw_text ( self , pos , text , font , * * kw ) : self . drawables . append ( ( pos , text , font , kw ) ) | Remember a single drawable tuple to paint later . | 38 | 10 |
240,426 | def _create_drawables ( self , tokensource ) : lineno = charno = maxcharno = 0 for ttype , value in tokensource : while ttype not in self . styles : ttype = ttype . parent style = self . styles [ ttype ] # TODO: make sure tab expansion happens earlier in the chain. It # really ought to be done on the input, as to do it... | Create drawables for the token content . | 269 | 8 |
240,427 | def _draw_line_numbers ( self ) : if not self . line_numbers : return for p in xrange ( self . maxlineno ) : n = p + self . line_number_start if ( n % self . line_number_step ) == 0 : self . _draw_linenumber ( p , n ) | Create drawables for the line numbers . | 74 | 8 |
240,428 | def _paint_line_number_bg ( self , im ) : if not self . line_numbers : return if self . line_number_fg is None : return draw = ImageDraw . Draw ( im ) recth = im . size [ - 1 ] rectw = self . image_pad + self . line_number_width - self . line_number_pad draw . rectangle ( [ ( 0 , 0 ) , ( rectw , recth ) ] , fill = self... | Paint the line number background on the image . | 144 | 10 |
240,429 | def update ( self , attrs ) : data = self . dict ( ) data . update ( attrs ) heartbeat = Heartbeat ( data , self . args , self . configs , _clone = True ) return heartbeat | Return a copy of the current Heartbeat with updated attributes . | 46 | 12 |
240,430 | def sanitize ( self ) : if not self . args . hide_file_names : return self if self . entity is None : return self if self . type != 'file' : return self if self . should_obfuscate_filename ( ) : self . _sanitize_metadata ( ) extension = u ( os . path . splitext ( self . entity ) [ 1 ] ) self . entity = u ( 'HIDDEN{0}' ... | Removes sensitive data including file names and dependencies . | 131 | 10 |
240,431 | def should_obfuscate_filename ( self ) : for pattern in self . args . hide_file_names : try : compiled = re . compile ( pattern , re . IGNORECASE ) if compiled . search ( self . entity ) : return True except re . error as ex : log . warning ( u ( 'Regex error ({msg}) for hide_file_names pattern: {pattern}' ) . format (... | Returns True if hide_file_names is true or the entity file path matches one in the list of obfuscated file paths . | 108 | 26 |
240,432 | def _format_local_file ( self ) : if self . type != 'file' : return if not self . entity : return if not is_win : return if self . _file_exists ( ) : return self . args . local_file = self . _to_unc_path ( self . entity ) | When args . local_file empty on Windows tries to map args . entity to a unc path . | 68 | 20 |
240,433 | def create_negotiate_message ( self , domain_name = None , workstation = None ) : self . negotiate_message = NegotiateMessage ( self . negotiate_flags , domain_name , workstation ) return base64 . b64encode ( self . negotiate_message . get_data ( ) ) | Create an NTLM NEGOTIATE_MESSAGE | 68 | 15 |
240,434 | def parse_challenge_message ( self , msg2 ) : msg2 = base64 . b64decode ( msg2 ) self . challenge_message = ChallengeMessage ( msg2 ) | Parse the NTLM CHALLENGE_MESSAGE from the server and add it to the Ntlm context fields | 40 | 28 |
240,435 | def create_authenticate_message ( self , user_name , password , domain_name = None , workstation = None , server_certificate_hash = None ) : self . authenticate_message = AuthenticateMessage ( user_name , password , domain_name , workstation , self . challenge_message , self . ntlm_compatibility , server_certificate_ha... | Create an NTLM AUTHENTICATE_MESSAGE based on the Ntlm context and the previous messages sent and received | 241 | 28 |
240,436 | def lex ( code , lexer ) : try : return lexer . get_tokens ( code ) except TypeError as err : if ( isinstance ( err . args [ 0 ] , str ) and ( 'unbound method get_tokens' in err . args [ 0 ] or 'missing 1 required positional argument' in err . args [ 0 ] ) ) : raise TypeError ( 'lex() argument must be a lexer instance,... | Lex code with lexer and return an iterable of tokens . | 103 | 13 |
240,437 | def format ( tokens , formatter , outfile = None ) : # pylint: disable=redefined-builtin try : if not outfile : realoutfile = getattr ( formatter , 'encoding' , None ) and BytesIO ( ) or StringIO ( ) formatter . format ( tokens , realoutfile ) return realoutfile . getvalue ( ) else : formatter . format ( tokens , outfi... | Format a tokenlist tokens with the formatter formatter . | 169 | 12 |
240,438 | def highlight ( code , lexer , formatter , outfile = None ) : return format ( lex ( code , lexer ) , formatter , outfile ) | Lex code with lexer and format it with the formatter formatter . | 34 | 15 |
240,439 | def getConfigFile ( ) : fileName = '.wakatime.cfg' home = os . environ . get ( 'WAKATIME_HOME' ) if home : return os . path . join ( os . path . expanduser ( home ) , fileName ) return os . path . join ( os . path . expanduser ( '~' ) , fileName ) | Returns the config file location . | 81 | 6 |
240,440 | def find_filter_class ( filtername ) : if filtername in FILTERS : return FILTERS [ filtername ] for name , cls in find_plugin_filters ( ) : if name == filtername : return cls return None | Lookup a filter by name . Return None if not found . | 57 | 13 |
240,441 | def get_filter_by_name ( filtername , * * options ) : cls = find_filter_class ( filtername ) if cls : return cls ( * * options ) else : raise ClassNotFound ( 'filter %r not found' % filtername ) | Return an instantiated filter . | 62 | 6 |
240,442 | def get_tokens_unprocessed ( self , text ) : tokens = self . _block_re . split ( text ) tokens . reverse ( ) state = idx = 0 try : while True : # text if state == 0 : val = tokens . pop ( ) yield idx , Other , val idx += len ( val ) state = 1 # block starts elif state == 1 : tag = tokens . pop ( ) # literals if tag in ... | Since ERB doesn t allow <% and other tags inside of ruby blocks we have to use a split approach here that fails for that too . | 482 | 29 |
240,443 | def format_file_path ( filepath ) : try : is_windows_network_mount = WINDOWS_NETWORK_MOUNT_PATTERN . match ( filepath ) filepath = os . path . realpath ( os . path . abspath ( filepath ) ) filepath = re . sub ( BACKSLASH_REPLACE_PATTERN , '/' , filepath ) is_windows_drive = WINDOWS_DRIVE_PATTERN . match ( filepath ) if... | Formats a path as absolute and with the correct platform separator . | 170 | 14 |
240,444 | def close ( self ) : # Disable access to the pool old_pool , self . pool = self . pool , None try : while True : conn = old_pool . get ( block = False ) if conn : conn . close ( ) except queue . Empty : pass | Close all pooled connections and disable the pool . | 56 | 9 |
240,445 | def is_same_host ( self , url ) : if url . startswith ( '/' ) : return True # TODO: Add optional support for socket.gethostbyname checking. scheme , host , port = get_host ( url ) host = _ipv6_host ( host ) . lower ( ) # Use explicit default port for comparison when none is given if self . port and not port : port = po... | Check if the given url is a member of the same host as this connection pool . | 146 | 17 |
240,446 | def filename ( self , value ) : warnings . warn ( "The 'filename' attribute will be removed in future versions. " "Use 'source' instead." , DeprecationWarning , stacklevel = 2 ) self . source = value | Deprecated user source . | 49 | 5 |
240,447 | def options ( self , section ) : try : opts = self . _sections [ section ] . copy ( ) except KeyError : raise from_none ( NoSectionError ( section ) ) opts . update ( self . _defaults ) return list ( opts . keys ( ) ) | Return a list of option names for the given section name . | 61 | 12 |
240,448 | def read_string ( self , string , source = '<string>' ) : sfile = io . StringIO ( string ) self . read_file ( sfile , source ) | Read configuration from a given string . | 39 | 7 |
240,449 | def read_dict ( self , dictionary , source = '<dict>' ) : elements_added = set ( ) for section , keys in dictionary . items ( ) : section = str ( section ) try : self . add_section ( section ) except ( DuplicateSectionError , ValueError ) : if self . _strict and section in elements_added : raise elements_added . add ( ... | Read configuration from a dictionary . | 172 | 6 |
240,450 | def readfp ( self , fp , filename = None ) : warnings . warn ( "This method will be removed in future versions. " "Use 'parser.read_file()' instead." , DeprecationWarning , stacklevel = 2 ) self . read_file ( fp , source = filename ) | Deprecated use read_file instead . | 65 | 8 |
240,451 | def has_option ( self , section , option ) : if not section or section == self . default_section : option = self . optionxform ( option ) return option in self . _defaults elif section not in self . _sections : return False else : option = self . optionxform ( option ) return ( option in self . _sections [ section ] or... | Check for the existence of a given option in a given section . If the specified section is None or an empty string DEFAULT is assumed . If the specified section does not exist returns False . | 86 | 38 |
240,452 | def _write_section ( self , fp , section_name , section_items , delimiter ) : fp . write ( "[{0}]\n" . format ( section_name ) ) for key , value in section_items : value = self . _interpolation . before_write ( self , section_name , key , value ) if value is not None or not self . _allow_no_value : value = delimiter + ... | Write a single section to the specified fp . | 150 | 10 |
240,453 | def _unify_values ( self , section , vars ) : sectiondict = { } try : sectiondict = self . _sections [ section ] except KeyError : if section != self . default_section : raise NoSectionError ( section ) # Update with the entry specific variables vardict = { } if vars : for key , value in vars . items ( ) : if value is ... | Create a sequence of lookups with vars taking priority over the section which takes priority over the DEFAULTSECT . | 126 | 24 |
240,454 | def _convert_to_boolean ( self , value ) : if value . lower ( ) not in self . BOOLEAN_STATES : raise ValueError ( 'Not a boolean: %s' % value ) return self . BOOLEAN_STATES [ value . lower ( ) ] | Return a boolean value translating from other types if necessary . | 65 | 11 |
240,455 | def _validate_value_types ( self , * * kwargs ) : # keyword-only arguments section = kwargs . get ( 'section' , "" ) option = kwargs . get ( 'option' , "" ) value = kwargs . get ( 'value' , "" ) if PY2 and bytes in ( type ( section ) , type ( option ) , type ( value ) ) : # we allow for a little unholy magic for Python... | Raises a TypeError for non - string values . | 319 | 11 |
240,456 | def set ( self , section , option , value = None ) : _ , option , value = self . _validate_value_types ( option = option , value = value ) super ( ConfigParser , self ) . set ( section , option , value ) | Set an option . Extends RawConfigParser . set by validating type and interpolation syntax on the value . | 54 | 23 |
240,457 | def add_section ( self , section ) : section , _ , _ = self . _validate_value_types ( section = section ) super ( ConfigParser , self ) . add_section ( section ) | Create a new section in the configuration . Extends RawConfigParser . add_section by validating if the section name is a string . | 44 | 28 |
240,458 | def get ( self , option , fallback = None , * * kwargs ) : # keyword-only arguments kwargs . setdefault ( 'raw' , False ) kwargs . setdefault ( 'vars' , None ) _impl = kwargs . pop ( '_impl' , None ) # If `_impl` is provided, it should be a getter method on the parser # object that provides the desired type conversion.... | Get an option value . | 132 | 5 |
240,459 | def analyse_text ( text ) : if re . match ( r'^\s*REBOL\s*\[' , text , re . IGNORECASE ) : # The code starts with REBOL header return 1.0 elif re . search ( r'\s*REBOL\s*[' , text , re . IGNORECASE ) : # The code contains REBOL header but also some text before it return 0.5 | Check if code contains REBOL header and so it probably not R code | 98 | 15 |
240,460 | def get_sign_key ( exported_session_key , magic_constant ) : sign_key = hashlib . md5 ( exported_session_key + magic_constant ) . digest ( ) return sign_key | 3 . 4 . 5 . 2 SIGNKEY | 48 | 9 |
240,461 | def _wait_for_io_events ( socks , events , timeout = None ) : if not HAS_SELECT : raise ValueError ( 'Platform does not have a selector' ) if not isinstance ( socks , list ) : # Probably just a single socket. if hasattr ( socks , "fileno" ) : socks = [ socks ] # Otherwise it might be a non-list iterable. else : socks =... | Waits for IO events to be available from a list of sockets or optionally a single socket if passed in . Returns a list of sockets that can be interacted with immediately . | 140 | 34 |
240,462 | def make_analysator ( f ) : def text_analyse ( text ) : try : rv = f ( text ) except Exception : return 0.0 if not rv : return 0.0 try : return min ( 1.0 , max ( 0.0 , float ( rv ) ) ) except ( ValueError , TypeError ) : return 0.0 text_analyse . __doc__ = f . __doc__ return staticmethod ( text_analyse ) | Return a static text analyser function that returns float values . | 102 | 12 |
240,463 | def shebang_matches ( text , regex ) : index = text . find ( '\n' ) if index >= 0 : first_line = text [ : index ] . lower ( ) else : first_line = text . lower ( ) if first_line . startswith ( '#!' ) : try : found = [ x for x in split_path_re . split ( first_line [ 2 : ] . strip ( ) ) if x and not x . startswith ( '-' )... | r Check if the given regular expression matches the last part of the shebang if one exists . | 168 | 19 |
240,464 | def looks_like_xml ( text ) : if xml_decl_re . match ( text ) : return True key = hash ( text ) try : return _looks_like_xml_cache [ key ] except KeyError : m = doctype_lookup_re . match ( text ) if m is not None : return True rv = tag_re . search ( text [ : 1000 ] ) is not None _looks_like_xml_cache [ key ] = rv retur... | Check if a doctype exists or if we have some tags . | 107 | 13 |
240,465 | def unirange ( a , b ) : if b < a : raise ValueError ( "Bad character range" ) if a < 0x10000 or b < 0x10000 : raise ValueError ( "unirange is only defined for non-BMP ranges" ) if sys . maxunicode > 0xffff : # wide build return u'[%s-%s]' % ( unichr ( a ) , unichr ( b ) ) else : # narrow build stores surrogates, and t... | Returns a regular expression string to match the given non - BMP range . | 472 | 15 |
240,466 | def format_lines ( var_name , seq , raw = False , indent_level = 0 ) : lines = [ ] base_indent = ' ' * indent_level * 4 inner_indent = ' ' * ( indent_level + 1 ) * 4 lines . append ( base_indent + var_name + ' = (' ) if raw : # These should be preformatted reprs of, say, tuples. for i in seq : lines . append ( inner_in... | Formats a sequence of strings for output . | 180 | 9 |
240,467 | def duplicates_removed ( it , already_seen = ( ) ) : lst = [ ] seen = set ( ) for i in it : if i in seen or i in already_seen : continue lst . append ( i ) seen . add ( i ) return lst | Returns a list with duplicates removed from the iterable it . | 60 | 13 |
240,468 | def _lex_fortran ( self , match , ctx = None ) : lexer = FortranLexer ( ) text = match . group ( 0 ) + "\n" for index , token , value in lexer . get_tokens_unprocessed ( text ) : value = value . replace ( '\n' , '' ) if value != '' : yield index , token , value | Lex a line just as free form fortran without line break . | 85 | 14 |
240,469 | def get_project_info ( configs , heartbeat , data ) : project_name , branch_name = heartbeat . project , heartbeat . branch if heartbeat . type != 'file' : project_name = project_name or heartbeat . args . project or heartbeat . args . alternate_project return project_name , branch_name if project_name is None or branc... | Find the current project and branch . | 481 | 7 |
240,470 | def save ( self , session ) : if not HAS_SQL : # pragma: nocover return try : conn , c = self . connect ( ) c . execute ( 'DELETE FROM {0}' . format ( self . table_name ) ) values = { 'value' : sqlite3 . Binary ( pickle . dumps ( session , protocol = 2 ) ) , } c . execute ( 'INSERT INTO {0} VALUES (:value)' . format ( ... | Saves a requests . Session object for the next heartbeat process . | 140 | 13 |
240,471 | def get ( self ) : if not HAS_SQL : # pragma: nocover return requests . session ( ) try : conn , c = self . connect ( ) except : log . traceback ( logging . DEBUG ) return requests . session ( ) session = None try : c . execute ( 'BEGIN IMMEDIATE' ) c . execute ( 'SELECT value FROM {0} LIMIT 1' . format ( self . table_... | Returns a requests . Session object . | 178 | 7 |
240,472 | def delete ( self ) : if not HAS_SQL : # pragma: nocover return try : conn , c = self . connect ( ) c . execute ( 'DELETE FROM {0}' . format ( self . table_name ) ) conn . commit ( ) conn . close ( ) except : log . traceback ( logging . DEBUG ) | Clears all cached Session objects . | 75 | 7 |
240,473 | def rebuild_method ( self , prepared_request , response ) : method = prepared_request . method # http://tools.ietf.org/html/rfc7231#section-6.4.4 if response . status_code == codes . see_other and method != 'HEAD' : method = 'GET' # Do what the browsers do, despite standards... # First, turn 302s into GETs. if response... | When being redirected we may want to change the method of the request based on certain specs or browser behavior . | 170 | 21 |
240,474 | def apply_filters ( stream , filters , lexer = None ) : def _apply ( filter_ , stream ) : for token in filter_ . filter ( lexer , stream ) : yield token for filter_ in filters : stream = _apply ( filter_ , stream ) return stream | Use this method to apply an iterable of filters to a stream . If lexer is given it s forwarded to the filter otherwise the filter receives None . | 60 | 31 |
240,475 | def reset_indent ( token_class ) : def callback ( lexer , match , context ) : text = match . group ( ) context . indent_stack = [ ] context . indent = - 1 context . next_indent = 0 context . block_scalar_indent = None yield match . start ( ) , token_class , text context . pos = match . end ( ) return callback | Reset the indentation levels . | 86 | 7 |
240,476 | def save_indent ( token_class , start = False ) : def callback ( lexer , match , context ) : text = match . group ( ) extra = '' if start : context . next_indent = len ( text ) if context . next_indent < context . indent : while context . next_indent < context . indent : context . indent = context . indent_stack . pop ... | Save a possible indentation level . | 178 | 7 |
240,477 | def set_block_scalar_indent ( token_class ) : def callback ( lexer , match , context ) : text = match . group ( ) context . block_scalar_indent = None if not text : return increment = match . group ( 1 ) if increment : current_indent = max ( context . indent , 0 ) increment = int ( increment ) context . block_scalar_in... | Set an explicit indentation level for a block scalar . | 125 | 12 |
240,478 | def parse_block_scalar_indent ( token_class ) : def callback ( lexer , match , context ) : text = match . group ( ) if context . block_scalar_indent is None : if len ( text ) <= max ( context . indent , 0 ) : context . stack . pop ( ) context . stack . pop ( ) return context . block_scalar_indent = len ( text ) else : ... | Process indentation spaces in a block scalar . | 154 | 10 |
240,479 | def content ( self ) : if self . _content is False : # Read the contents. if self . _content_consumed : raise RuntimeError ( 'The content for this response was already consumed' ) if self . status_code == 0 or self . raw is None : self . _content = None else : self . _content = bytes ( ) . join ( self . iter_content ( ... | Content of the response in bytes . | 136 | 7 |
240,480 | def py_scanstring ( s , end , encoding = None , strict = True , _b = BACKSLASH , _m = STRINGCHUNK . match , _join = u ( '' ) . join , _PY3 = PY3 , _maxunicode = sys . maxunicode ) : if encoding is None : encoding = DEFAULT_ENCODING chunks = [ ] _append = chunks . append begin = end - 1 while 1 : chunk = _m ( s , end ) ... | Scan the string s for a JSON string . End is the index of the character in s after the quote that started the JSON string . Unescapes all valid JSON string escape sequences and raises ValueError on attempt to decode an invalid string . If strict is False then literal control characters are allowed in the string . | 696 | 62 |
240,481 | def _get_css_class ( self , ttype ) : ttypeclass = _get_ttype_class ( ttype ) if ttypeclass : return self . classprefix + ttypeclass return '' | Return the css class of this token type prefixed with the classprefix option . | 45 | 17 |
240,482 | def _get_css_classes ( self , ttype ) : cls = self . _get_css_class ( ttype ) while ttype not in STANDARD_TYPES : ttype = ttype . parent cls = self . _get_css_class ( ttype ) + ' ' + cls return cls | Return the css classes of this token type prefixed with the classprefix option . | 72 | 17 |
240,483 | def get_style_defs ( self , arg = None ) : if arg is None : arg = ( 'cssclass' in self . options and '.' + self . cssclass or '' ) if isinstance ( arg , string_types ) : args = [ arg ] else : args = list ( arg ) def prefix ( cls ) : if cls : cls = '.' + cls tmp = [ ] for arg in args : tmp . append ( ( arg and arg + ' '... | Return CSS style definitions for the classes produced by the current highlighting style . arg can be a string or list of selectors to insert before the token type classes . | 377 | 32 |
240,484 | def _format_lines ( self , tokensource ) : nocls = self . noclasses lsep = self . lineseparator # for <span style=""> lookup only getcls = self . ttype2class . get c2s = self . class2style escape_table = _escape_html_table tagsfile = self . tagsfile lspan = '' line = [ ] for ttype , value in tokensource : if nocls : cc... | Just format the tokens without any wrapping tags . Yield individual lines . | 648 | 14 |
240,485 | 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 : # i + 1 because Python indexes start at 0 if self . noclasses : style = '' if self . style . highlight_color is not None : style = ( ' style="background-... | Highlighted the lines specified in the hl_lines option by post - processing the token stream coming from _format_lines . | 160 | 27 |
240,486 | 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 ... | The formatting process uses several nested generators ; which of them are used is determined by the user s options . | 182 | 21 |
240,487 | 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 Non... | Callback that yields multiple actions for each group in the match . | 162 | 12 |
240,488 | 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 keyword arguments are given the ... | Callback that processes the match with a different lexer . | 345 | 11 |
240,489 | def do_insertions ( insertions , tokens ) : insertions = iter ( insertions ) try : index , itokens = next ( insertions ) except StopIteration : # no insertions for item in tokens : yield item return realpos = None insleft = True # iterate over the token stream where we want to insert # the tokens from the insertion lis... | Helper for lexers which must combine the results of several sublexers . | 317 | 15 |
240,490 | 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 . | 46 | 11 |
240,491 | 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 . | 50 | 10 |
240,492 | def _process_new_state ( cls , new_state , unprocessed , processed ) : if isinstance ( new_state , str ) : # an existing state 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_st... | Preprocess the state transition action of a token definition . | 333 | 11 |
240,493 | 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 [ sta... | Preprocess a single state definition . | 423 | 7 |
240,494 | 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 . | 90 | 8 |
240,495 | 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 : # N.b. because this is assigned by reference, sufficiently # deep hierarchies are processed i... | Merge tokens from superclasses in MRO order returning a single tokendef dictionary . | 302 | 19 |
240,496 | 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 | 49 | 9 |
240,497 | def memorized_datetime ( seconds ) : try : return _datetime_cache [ seconds ] except KeyError : # NB. We can't just do datetime.utcfromtimestamp(seconds) as this # fails with negative values under Windows (Bug #90096) dt = _epoch + timedelta ( seconds = seconds ) _datetime_cache [ seconds ] = dt return dt | Create only one instance of each distinct datetime | 87 | 9 |
240,498 | 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 | 78 | 8 |
240,499 | def unpickler ( zone , utcoffset = None , dstoffset = None , tzname = None ) : # Raises a KeyError if zone no longer exists, which should never happen # and would be a bug. tz = pytz . timezone ( zone ) # A StaticTzInfo - just return it if utcoffset is None : return tz # This pickle was created from a DstTzInfo. We nee... | Factory function for unpickling pytz tzinfo instances . | 482 | 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.