idx
int64 0
63k
| question
stringlengths 53
5.28k
| target
stringlengths 5
805
|
|---|---|---|
3,100
|
def _won_in ( self ) : if not self . _summary [ 'finished' ] : return starting_age = self . _summary [ 'settings' ] [ 'starting_age' ] . lower ( ) if starting_age == 'post imperial' : starting_age = 'imperial' ages_reached = set ( [ starting_age ] ) for player in self . _summary [ 'players' ] : for age , reached in player [ 'ages' ] . items ( ) : if reached : ages_reached . add ( age ) ages = [ 'imperial' , 'castle' , 'feudal' , 'dark' ] for age in ages : if age in ages_reached : return age
|
Get age the game was won in .
|
3,101
|
def _rec_owner_number ( self ) : player = self . _header . initial . players [ self . _header . replay . rec_player ] return player . attributes . player_color + 1
|
Get rec owner number .
|
3,102
|
def _get_timestamp ( self ) : filename_date = _find_date ( os . path . basename ( self . _path ) ) if filename_date : return filename_date
|
Get modification timestamp from rec file .
|
3,103
|
def _set_winning_team ( self ) : if not self . _summary [ 'finished' ] : return for team in self . _summary [ 'diplomacy' ] [ 'teams' ] : team [ 'winner' ] = False for player_number in team [ 'player_numbers' ] : for player in self . _summary [ 'players' ] : if player_number == player [ 'number' ] : if player [ 'winner' ] : team [ 'winner' ] = True
|
Mark the winning team .
|
3,104
|
def _map_hash ( self ) : elevation_bytes = bytes ( [ tile . elevation for tile in self . _header . map_info . tile ] ) map_name_bytes = self . _map . name ( ) . encode ( ) player_bytes = b'' for _ , attributes in self . _players ( ) : player_bytes += ( mgz . const . PLAYER_COLORS [ attributes . player_color ] . encode ( ) + attributes . player_name . encode ( ) + mgz . const . CIVILIZATION_NAMES [ attributes . civilization ] . encode ( ) ) return hashlib . sha1 ( elevation_bytes + map_name_bytes + player_bytes ) . hexdigest ( )
|
Compute a map hash based on a combination of map attributes .
|
3,105
|
def device_info ( self ) : return { 'family' : self . family , 'platform' : self . platform , 'os_type' : self . os_type , 'os_version' : self . os_version , 'udi' : self . udi , 'driver_name' : self . driver . platform , 'mode' : self . mode , 'is_console' : self . is_console , 'is_target' : self . is_target , 'hostname' : self . hostname , }
|
Return device info dict .
|
3,106
|
def clear_info ( self ) : self . _version_text = None self . _inventory_text = None self . _users_text = None self . os_version = None self . os_type = None self . family = None self . platform = None self . udi = None self . prompt = None self . prompt_re = None
|
Clear the device info .
|
3,107
|
def disconnect ( self ) : self . chain . connection . log ( "Disconnecting: {}" . format ( self ) ) if self . connected : if self . protocol : if self . is_console : while self . mode != 'global' : try : self . send ( 'exit' , timeout = 10 ) except CommandTimeoutError : break self . protocol . disconnect ( self . driver ) self . protocol = None self . connected = False self . ctrl = None
|
Disconnect the device .
|
3,108
|
def make_driver ( self , driver_name = 'generic' ) : module_str = 'condoor.drivers.%s' % driver_name try : __import__ ( module_str ) module = sys . modules [ module_str ] driver_class = getattr ( module , 'Driver' ) except ImportError as e : print ( "driver name: {}" . format ( driver_name ) ) self . chain . connection . log ( "Import error: {}: '{}'" . format ( driver_name , str ( e ) ) ) return self . make_driver ( ) self . chain . connection . log ( "Make Device: {} with Driver: {}" . format ( self , driver_class . platform ) ) return driver_class ( self )
|
Make driver factory function .
|
3,109
|
def version_text ( self ) : if self . _version_text is None : self . chain . connection . log ( "Collecting version information" ) self . _version_text = self . driver . get_version_text ( ) if self . _version_text : self . chain . connection . log ( "Version info collected" ) else : self . chain . connection . log ( "Version info not collected" ) return self . _version_text
|
Return version text and collect if not collected .
|
3,110
|
def hostname_text ( self ) : if self . _hostname_text is None : self . chain . connection . log ( "Collecting hostname information" ) self . _hostname_text = self . driver . get_hostname_text ( ) if self . _hostname_text : self . chain . connection . log ( "Hostname info collected" ) else : self . chain . connection . log ( "Hostname info not collected" ) return self . _hostname_text
|
Return hostname text and collect if not collected .
|
3,111
|
def inventory_text ( self ) : if self . _inventory_text is None : self . chain . connection . log ( "Collecting inventory information" ) self . _inventory_text = self . driver . get_inventory_text ( ) if self . _inventory_text : self . chain . connection . log ( "Inventory info collected" ) else : self . chain . connection . log ( "Inventory info not collected" ) return self . _inventory_text
|
Return inventory information and collect if not available .
|
3,112
|
def users_text ( self ) : if self . _users_text is None : self . chain . connection . log ( "Getting connected users text" ) self . _users_text = self . driver . get_users_text ( ) if self . _users_text : self . chain . connection . log ( "Users text collected" ) else : self . chain . connection . log ( "Users text not collected" ) return self . _users_text
|
Return connected users information and collect if not available .
|
3,113
|
def get_protocol_name ( self ) : protocol_name = self . node_info . protocol if self . is_console : protocol_name += '_console' return protocol_name
|
Provide protocol name based on node_info .
|
3,114
|
def update_udi ( self ) : self . chain . connection . log ( "Parsing inventory" ) self . udi = parse_inventory ( self . inventory_text )
|
Update udi .
|
3,115
|
def update_config_mode ( self , prompt = None ) : if prompt : self . mode = self . driver . update_config_mode ( prompt ) else : self . mode = self . driver . update_config_mode ( self . prompt )
|
Update config mode .
|
3,116
|
def update_driver ( self , prompt ) : prompt = prompt . lstrip ( ) self . chain . connection . log ( "({}): Prompt: '{}'" . format ( self . driver . platform , prompt ) ) self . prompt = prompt driver_name = self . driver . update_driver ( prompt ) if driver_name is None : self . chain . connection . log ( "New driver not detected. Using existing {} driver." . format ( self . driver . platform ) ) return self . driver_name = driver_name
|
Update driver based on new prompt .
|
3,117
|
def prepare_terminal_session ( self ) : for cmd in self . driver . prepare_terminal_session : try : self . send ( cmd ) except CommandSyntaxError : self . chain . connection . log ( "Command not supported or not authorized: '{}'. Skipping" . format ( cmd ) ) pass
|
Send commands to prepare terminal session configuration .
|
3,118
|
def update_os_type ( self ) : self . chain . connection . log ( "Detecting os type" ) os_type = self . driver . get_os_type ( self . version_text ) if os_type : self . chain . connection . log ( "SW Type: {}" . format ( os_type ) ) self . os_type = os_type
|
Update os_type attribute .
|
3,119
|
def update_os_version ( self ) : self . chain . connection . log ( "Detecting os version" ) os_version = self . driver . get_os_version ( self . version_text ) if os_version : self . chain . connection . log ( "SW Version: {}" . format ( os_version ) ) self . os_version = os_version
|
Update os_version attribute .
|
3,120
|
def update_family ( self ) : self . chain . connection . log ( "Detecting hw family" ) family = self . driver . get_hw_family ( self . version_text ) if family : self . chain . connection . log ( "HW Family: {}" . format ( family ) ) self . family = family
|
Update family attribute .
|
3,121
|
def update_platform ( self ) : self . chain . connection . log ( "Detecting hw platform" ) platform = self . driver . get_hw_platform ( self . udi ) if platform : self . chain . connection . log ( "HW Platform: {}" . format ( platform ) ) self . platform = platform
|
Update platform attribute .
|
3,122
|
def update_console ( self ) : self . chain . connection . log ( "Detecting console connection" ) is_console = self . driver . is_console ( self . users_text ) if is_console is not None : self . is_console = is_console
|
Update is_console whether connected via console .
|
3,123
|
def reload ( self , reload_timeout , save_config , no_reload_cmd ) : if not no_reload_cmd : self . ctrl . send_command ( self . driver . reload_cmd ) return self . driver . reload ( reload_timeout , save_config )
|
Reload device .
|
3,124
|
def run_fsm ( self , name , command , events , transitions , timeout , max_transitions = 20 ) : self . ctrl . send_command ( command ) return FSM ( name , self , events , transitions , timeout = timeout , max_transitions = max_transitions ) . run ( )
|
Wrap the FSM code .
|
3,125
|
def config ( self , configlet , plane , ** attributes ) : try : config_text = configlet . format ( ** attributes ) except KeyError as exp : raise CommandSyntaxError ( "Configuration template error: {}" . format ( str ( exp ) ) ) return self . driver . config ( config_text , plane )
|
Apply config to the device .
|
3,126
|
def device_gen ( chain , urls ) : itr = iter ( urls ) last = next ( itr ) for url in itr : yield Device ( chain , make_hop_info_from_url ( last ) , driver_name = 'jumphost' , is_target = False ) last = url yield Device ( chain , make_hop_info_from_url ( last ) , driver_name = 'generic' , is_target = True )
|
Device object generator .
|
3,127
|
def connect ( self ) : device = None for device in self . devices : if not device . connected : self . connection . emit_message ( "Connecting {}" . format ( str ( device ) ) , log_level = logging . INFO ) protocol_name = device . get_protocol_name ( ) device . protocol = make_protocol ( protocol_name , device ) command = device . protocol . get_command ( ) self . ctrl . spawn_session ( command = command ) try : result = device . connect ( self . ctrl ) except CommandSyntaxError as exc : if exc . command : cmd = exc . command host = device . hostname else : cmd = command host = "Jumphost/CSM" self . connection . log ( "Command not supported or not authorized on {}: '{}'" . format ( host , cmd ) ) raise CommandError ( message = "Command not supported or not authorized" , command = cmd , host = host ) if result : self . connection . emit_message ( "Connected {}" . format ( device ) , log_level = logging . INFO ) else : if device . last_error_msg : message = device . last_error_msg device . last_error_msg = None else : message = "Connection error" self . connection . log ( message ) raise ConnectionError ( message ) if device is None : raise ConnectionError ( "No devices" ) return True
|
Connect to the target device using the intermediate jumphosts .
|
3,128
|
def disconnect ( self ) : self . target_device . disconnect ( ) self . ctrl . disconnect ( ) self . tail_disconnect ( - 1 )
|
Disconnect from the device .
|
3,129
|
def is_discovered ( self ) : if self . target_device is None : return False if None in ( self . target_device . version_text , self . target_device . os_type , self . target_device . os_version , self . target_device . inventory_text , self . target_device . family , self . target_device . platform ) : return False return True
|
Return if target device is discovered .
|
3,130
|
def get_previous_prompts ( self , device ) : device_index = self . devices . index ( device ) prompts = [ re . compile ( "(?!x)x" ) ] + [ dev . prompt_re for dev in self . devices [ : device_index ] if dev . prompt_re is not None ] return prompts
|
Return the list of intermediate prompts . All except target .
|
3,131
|
def get_device_index_based_on_prompt ( self , prompt ) : conn_info = "" for device in self . devices : conn_info += str ( device ) + "->" if device . prompt == prompt : self . connection . log ( "Connected: {}" . format ( conn_info ) ) return self . devices . index ( device ) else : return None
|
Return the device index in the chain based on prompt .
|
3,132
|
def tail_disconnect ( self , index ) : try : for device in self . devices [ index + 1 : ] : device . connected = False except IndexError : pass
|
Mark all devices disconnected except target in the chain .
|
3,133
|
def send ( self , cmd , timeout , wait_for_string , password ) : return self . target_device . send ( cmd , timeout = timeout , wait_for_string = wait_for_string , password = password )
|
Send command to the target device .
|
3,134
|
def update ( self , data ) : if data is None : for device in self . devices : device . clear_info ( ) else : for device , device_info in zip ( self . devices , data ) : device . device_info = device_info self . connection . log ( "Device information updated -> [{}]" . format ( device ) )
|
Update the chain object with the predefined data .
|
3,135
|
def action ( func ) : @ wraps ( func ) def call_action ( * args , ** kwargs ) : try : ctx = kwargs [ 'ctx' ] except KeyError : ctx = None if ctx is None : try : ctx = args [ - 1 ] except IndexError : ctx = None if ctx : if func . __doc__ is None : ctx . device . chain . connection . log ( "A={}" . format ( func . __name__ ) ) else : ctx . device . chain . connection . log ( "A={}" . format ( func . __doc__ . split ( '\n' , 1 ) [ 0 ] ) ) return func ( * args , ** kwargs ) return call_action
|
Wrap the FSM action function providing extended logging information based on doc string .
|
3,136
|
def run ( self ) : ctx = FSM . Context ( self . name , self . device ) transition_counter = 0 timeout = self . timeout self . log ( "{} Start" . format ( self . name ) ) while transition_counter < self . max_transitions : transition_counter += 1 try : start_time = time ( ) if self . init_pattern is None : ctx . event = self . ctrl . expect ( self . events , searchwindowsize = self . searchwindowsize , timeout = timeout ) else : self . log ( "INIT_PATTERN={}" . format ( pattern_to_str ( self . init_pattern ) ) ) try : ctx . event = self . events . index ( self . init_pattern ) except ValueError : self . log ( "INIT_PATTERN unknown." ) continue finally : self . init_pattern = None finish_time = time ( ) - start_time key = ( ctx . event , ctx . state ) ctx . pattern = self . events [ ctx . event ] if key in self . transition_table : transition = self . transition_table [ key ] next_state , action_instance , next_timeout = transition self . log ( "E={},S={},T={},RT={:.2f}" . format ( ctx . event , ctx . state , timeout , finish_time ) ) if callable ( action_instance ) and not isclass ( action_instance ) : if not action_instance ( ctx ) : self . log ( "Error: {}" . format ( ctx . msg ) ) return False elif isinstance ( action_instance , Exception ) : self . log ( "A=Exception {}" . format ( action_instance ) ) raise action_instance elif action_instance is None : self . log ( "A=None" ) else : self . log ( "FSM Action is not callable: {}" . format ( str ( action_instance ) ) ) raise RuntimeWarning ( "FSM Action is not callable" ) if next_timeout != 0 : timeout = next_timeout ctx . state = next_state self . log ( "NS={},NT={}" . format ( next_state , timeout ) ) else : self . log ( "Unknown transition: EVENT={},STATE={}" . format ( ctx . event , ctx . state ) ) continue except EOF : raise ConnectionError ( "Session closed unexpectedly" , self . ctrl . hostname ) if ctx . finished or next_state == - 1 : self . log ( "{} Stop at E={},S={}" . format ( self . name , ctx . event , ctx . state ) ) return True self . log ( "FSM looped. Exiting" ) return False
|
Start the FSM .
|
3,137
|
def build ( port = 8000 , fixtures = None ) : extractor = Extractor ( ) parser = Parser ( extractor . url_details , fixtures ) parser . parse ( ) url_details = parser . results _store = get_store ( url_details ) store = json . dumps ( _store ) variables = str ( Variable ( 'let' , 'store' , store ) ) functions = DATA_FINDER + GET_HANDLER + MODIFY_HANDLER + POST_HANDLER endpoints = [ ] endpoint_uris = [ ] for u in parser . results : endpoint = Endpoint ( ) if u [ 'method' ] . lower ( ) in [ 'get' , 'post' ] : method = u [ 'method' ] . lower ( ) else : method = 'modify' response = str ( ResponseBody ( method ) ) u [ 'url' ] , list_url = clean_url ( u [ 'full_url' ] , _store , u [ 'method' ] . lower ( ) ) if list_url is not None and u [ 'method' ] . lower ( ) == 'get' : list_endpoint = Endpoint ( ) list_endpoint . construct ( 'get' , list_url , response ) if str ( list_endpoint ) not in endpoints : endpoints . append ( str ( list_endpoint ) ) if list_endpoint . uri not in endpoint_uris : endpoint_uris . append ( list_endpoint . uri ) if method == 'modify' : without_prefix = re . sub ( r'\/(\w+)\_\_' , '' , u [ 'url' ] ) for k , v in _store . items ( ) : if without_prefix in k : options = v . get ( 'options' , '{}' ) options = ast . literal_eval ( options ) modifiers = [ ] if options is not None : modifiers = options . get ( 'modifiers' , [ ] ) if modifiers : for mod in modifiers : if u [ 'method' ] . lower ( ) == mod : mod_endpoint = Endpoint ( ) uri = without_prefix if v . get ( 'position' ) is not None and v [ 'position' ] == 'url' : uri = re . sub ( r'\/?\_\_key' , '/:id' , u [ 'full_url' ] ) mod_endpoint . construct ( u [ 'method' ] . lower ( ) , uri , response ) if str ( mod_endpoint ) not in endpoints : endpoints . append ( str ( mod_endpoint ) ) if mod_endpoint . uri not in endpoint_uris : endpoint_uris . append ( mod_endpoint . uri ) else : endpoint . construct ( u [ 'method' ] , u [ 'url' ] , response ) if str ( endpoint ) not in endpoints : endpoints . append ( str ( endpoint ) ) if endpoint . uri not in endpoint_uris : endpoint_uris . append ( endpoint . uri ) endpoints = '' . join ( endpoints ) express = ExpressServer ( ) express . construct ( variables , functions , endpoints , port ) return express
|
Builds a server file .
|
3,138
|
def preferred ( self ) : if 'Preferred-Value' in self . data [ 'record' ] : preferred = self . data [ 'record' ] [ 'Preferred-Value' ] type = self . data [ 'type' ] if type == 'extlang' : type = 'language' return Subtag ( preferred , type ) return None
|
Get the preferred subtag .
|
3,139
|
def format ( self ) : subtag = self . data [ 'subtag' ] if self . data [ 'type' ] == 'region' : return subtag . upper ( ) if self . data [ 'type' ] == 'script' : return subtag . capitalize ( ) return subtag
|
Get the subtag code conventional format according to RFC 5646 section 2 . 1 . 1 .
|
3,140
|
def AuthorizingClient ( domain , auth , request_encoder , response_decoder , user_agent = None ) : http_transport = transport . HttpTransport ( api_url ( domain ) , build_headers ( auth , user_agent ) ) return client . Client ( request_encoder , http_transport , response_decoder )
|
Creates a Freshbooks client for a freshbooks domain using an auth object .
|
3,141
|
def TokenClient ( domain , token , user_agent = None , request_encoder = default_request_encoder , response_decoder = default_response_decoder , ) : return AuthorizingClient ( domain , transport . TokenAuthorization ( token ) , request_encoder , response_decoder , user_agent = user_agent )
|
Creates a Freshbooks client for a freshbooks domain using token - based auth . The optional request_encoder and response_decoder parameters can be passed the logging_request_encoder and logging_response_decoder objects from this module or custom encoders to aid debugging or change the behaviour of refreshbooks request - to - XML - to - response mapping . The optional user_agent keyword parameter can be used to specify the user agent string passed to FreshBooks . If unset a default user agent string is used .
|
3,142
|
def OAuthClient ( domain , consumer_key , consumer_secret , token , token_secret , user_agent = None , request_encoder = default_request_encoder , response_decoder = default_response_decoder ) : return _create_oauth_client ( AuthorizingClient , domain , consumer_key , consumer_secret , token , token_secret , user_agent = user_agent , request_encoder = request_encoder , response_decoder = response_decoder )
|
Creates a Freshbooks client for a freshbooks domain using OAuth . Token management is assumed to have been handled out of band . The optional request_encoder and response_decoder parameters can be passed the logging_request_encoder and logging_response_decoder objects from this module or custom encoders to aid debugging or change the behaviour of refreshbooks request - to - XML - to - response mapping . The optional user_agent keyword parameter can be used to specify the user agent string passed to FreshBooks . If unset a default user agent string is used .
|
3,143
|
def gpg_decrypt ( cfg , gpg_config = None ) : def decrypt ( obj ) : if isinstance ( obj , list ) : res_v = [ ] for item in obj : res_v . append ( decrypt ( item ) ) return res_v elif isinstance ( obj , dict ) : if '_gpg' in obj : try : decrypted = gpg . decrypt ( obj [ '_gpg' ] ) if decrypted . ok : obj = n ( decrypted . data . decode ( 'utf-8' ) . encode ( ) ) else : log . error ( "gpg error unpacking secrets %s" , decrypted . stderr ) except Exception as err : log . error ( "error unpacking secrets %s" , err ) else : for k , v in obj . items ( ) : obj [ k ] = decrypt ( v ) else : try : if 'BEGIN PGP' in obj : try : decrypted = gpg . decrypt ( obj ) if decrypted . ok : obj = n ( decrypted . data . decode ( 'utf-8' ) . encode ( ) ) else : log . error ( "gpg error unpacking secrets %s" , decrypted . stderr ) except Exception as err : log . error ( "error unpacking secrets %s" , err ) except TypeError : log . debug ( 'Pass on decryption. Only decrypt strings' ) return obj if GPG_IMPORTED : if not gpg_config : gpg_config = { } defaults = { 'homedir' : '~/.gnupg/' } env_fields = { 'homedir' : 'FIGGYPY_GPG_HOMEDIR' , 'binary' : 'FIGGYPY_GPG_BINARY' , 'keyring' : 'FIGGYPY_GPG_KEYRING' } for k , v in env_fields . items ( ) : gpg_config [ k ] = env_or_default ( v , defaults [ k ] if k in defaults else None ) try : gpg = gnupg . GPG ( ** gpg_config ) except ( OSError , RuntimeError ) : log . exception ( 'Failed to configure gpg. Will be unable to decrypt secrets.' ) return decrypt ( cfg ) return cfg
|
Decrypt GPG objects in configuration .
|
3,144
|
def kms_decrypt ( cfg , aws_config = None ) : def decrypt ( obj ) : if isinstance ( obj , list ) : res_v = [ ] for item in obj : res_v . append ( decrypt ( item ) ) return res_v elif isinstance ( obj , dict ) : if '_kms' in obj : try : res = client . decrypt ( CiphertextBlob = b64decode ( obj [ '_kms' ] ) ) obj = n ( res [ 'Plaintext' ] ) except ClientError as err : if 'AccessDeniedException' in err . args [ 0 ] : log . warning ( 'Unable to decrypt %s. Key does not exist or no access' , obj [ '_kms' ] ) else : raise else : for k , v in obj . items ( ) : obj [ k ] = decrypt ( v ) else : pass return obj try : aws = boto3 . session . Session ( ** aws_config ) client = aws . client ( 'kms' ) except NoRegionError : log . info ( 'Missing or invalid aws configuration. Will not be able to unpack KMS secrets.' ) return cfg return decrypt ( cfg )
|
Decrypt KMS objects in configuration .
|
3,145
|
def get_version_text ( self ) : show_version_brief_not_supported = False version_text = None try : version_text = self . device . send ( "show version brief" , timeout = 120 ) except CommandError : show_version_brief_not_supported = True if show_version_brief_not_supported : try : version_text = self . device . send ( "show version" , timeout = 120 ) except CommandError as exc : exc . command = 'show version' raise exc return version_text
|
Return the version information from the device .
|
3,146
|
def get_inventory_text ( self ) : inventory_text = None if self . inventory_cmd : try : inventory_text = self . device . send ( self . inventory_cmd , timeout = 120 ) self . log ( 'Inventory collected' ) except CommandError : self . log ( 'Unable to collect inventory' ) else : self . log ( 'No inventory command for {}' . format ( self . platform ) ) return inventory_text
|
Return the inventory information from the device .
|
3,147
|
def get_users_text ( self ) : users_text = None if self . users_cmd : try : users_text = self . device . send ( self . users_cmd , timeout = 60 ) except CommandError : self . log ( 'Unable to collect connected users information' ) else : self . log ( 'No users command for {}' . format ( self . platform ) ) return users_text
|
Return the users logged in information from the device .
|
3,148
|
def get_os_type ( self , version_text ) : os_type = None if version_text is None : return os_type match = re . search ( "(XR|XE|NX-OS)" , version_text ) if match : os_type = match . group ( 1 ) else : os_type = 'IOS' if os_type == "XR" : match = re . search ( "Build Information" , version_text ) if match : os_type = "eXR" match = re . search ( "XR Admin Software" , version_text ) if match : os_type = "Calvados" return os_type
|
Return the OS type information from the device .
|
3,149
|
def get_os_version ( self , version_text ) : os_version = None if version_text is None : return os_version match = re . search ( self . version_re , version_text , re . MULTILINE ) if match : os_version = match . group ( 1 ) return os_version
|
Return the OS version information from the device .
|
3,150
|
def get_hw_family ( self , version_text ) : family = None if version_text is None : return family match = re . search ( self . platform_re , version_text , re . MULTILINE ) if match : self . platform_string = match . group ( ) self . log ( "Platform string: {}" . format ( match . group ( ) ) ) self . raw_family = match . group ( 1 ) for key in sorted ( self . families , key = len , reverse = True ) : if self . raw_family . startswith ( key ) : family = self . families [ key ] break else : self . log ( "Platform {} not supported" . format ( family ) ) else : self . log ( "Platform string not present. Refer to CSCux08958" ) return family
|
Return the HW family information from the device .
|
3,151
|
def get_hw_platform ( self , udi ) : platform = None try : pid = udi [ 'pid' ] if pid == '' : self . log ( "Empty PID. Use the hw family from the platform string." ) return self . raw_family match = re . search ( self . pid2platform_re , pid ) if match : platform = match . group ( 1 ) except KeyError : pass return platform
|
Return th HW platform information from the device .
|
3,152
|
def is_console ( self , users_text ) : if users_text is None : self . log ( "Console information not collected" ) return None for line in users_text . split ( '\n' ) : if '*' in line : match = re . search ( self . vty_re , line ) if match : self . log ( "Detected connection to vty" ) return False else : match = re . search ( self . console_re , line ) if match : self . log ( "Detected connection to console" ) return True self . log ( "Connection port unknown" ) return None
|
Return if device is connected over console .
|
3,153
|
def wait_for_string ( self , expected_string , timeout = 60 ) : events = [ self . syntax_error_re , self . connection_closed_re , expected_string , self . press_return_re , self . more_re , pexpect . TIMEOUT , pexpect . EOF , self . buffer_overflow_re ] events += self . device . get_previous_prompts ( ) self . log ( "Expecting: {}" . format ( pattern_to_str ( expected_string ) ) ) transitions = [ ( self . syntax_error_re , [ 0 ] , - 1 , CommandSyntaxError ( "Command unknown" , self . device . hostname ) , 0 ) , ( self . connection_closed_re , [ 0 ] , 1 , a_connection_closed , 10 ) , ( pexpect . TIMEOUT , [ 0 ] , - 1 , CommandTimeoutError ( "Timeout waiting for prompt" , self . device . hostname ) , 0 ) , ( pexpect . EOF , [ 0 , 1 ] , - 1 , ConnectionError ( "Unexpected device disconnect" , self . device . hostname ) , 0 ) , ( self . more_re , [ 0 ] , 0 , partial ( a_send , " " ) , 10 ) , ( expected_string , [ 0 , 1 ] , - 1 , a_expected_prompt , 0 ) , ( self . press_return_re , [ 0 ] , - 1 , a_stays_connected , 0 ) , ( self . buffer_overflow_re , [ 0 ] , - 1 , CommandSyntaxError ( "Command too long" , self . device . hostname ) , 0 ) ] for prompt in self . device . get_previous_prompts ( ) : transitions . append ( ( prompt , [ 0 , 1 ] , 0 , a_unexpected_prompt , 0 ) ) fsm = FSM ( "WAIT-4-STRING" , self . device , events , transitions , timeout = timeout ) return fsm . run ( )
|
Wait for string FSM .
|
3,154
|
def reload ( self , reload_timeout = 300 , save_config = True ) : self . log ( "Reload not implemented on {} platform" . format ( self . platform ) )
|
Reload the device and waits for device to boot up .
|
3,155
|
def base_prompt ( self , prompt ) : if prompt is None : return None if not self . device . is_target : return prompt pattern = pattern_manager . pattern ( self . platform , "prompt_dynamic" , compiled = False ) pattern = pattern . format ( prompt = "(?P<prompt>.*?)" ) result = re . search ( pattern , prompt ) if result : base = result . group ( "prompt" ) + "#" self . log ( "base prompt: {}" . format ( base ) ) return base else : self . log ( "Unable to extract the base prompt" ) return prompt
|
Extract the base prompt pattern .
|
3,156
|
def update_config_mode ( self , prompt ) : mode = 'global' if prompt : if 'config' in prompt : mode = 'config' elif 'admin' in prompt : mode = 'admin' self . log ( "Mode: {}" . format ( mode ) ) return mode
|
Update config mode based on the prompt analysis .
|
3,157
|
def update_hostname ( self , prompt ) : result = re . search ( self . prompt_re , prompt ) if result : hostname = result . group ( 'hostname' ) self . log ( "Hostname detected: {}" . format ( hostname ) ) else : hostname = self . device . hostname self . log ( "Hostname not set: {}" . format ( prompt ) ) return hostname
|
Update the hostname based on the prompt analysis .
|
3,158
|
def enter_plane ( self , plane ) : try : cmd = CONF [ 'driver' ] [ self . platform ] [ 'planes' ] [ plane ] self . plane = plane except KeyError : cmd = None if cmd : self . log ( "Entering the {} plane" . format ( plane ) ) self . device . send ( cmd )
|
Enter the device plane .
|
3,159
|
def handle_other_factory_method ( attr , minimum , maximum ) : if attr == 'percentage' : if minimum : minimum = ast . literal_eval ( minimum ) else : minimum = 0 if maximum : maximum = ast . literal_eval ( maximum ) else : maximum = 100 val = random . uniform ( minimum , maximum ) return val raise ValueError ( '`%s` isn\'t a valid factory method.' % attr )
|
This is a temporary static method when there are more factory methods we can move this to another class or find a way to maintain it in a scalable manner
|
3,160
|
def _parse_syntax ( self , raw ) : raw = str ( raw ) has_syntax = re . findall ( r'<(\^)?(fk__)?(\w+)?([0-9]*[.]?[0-9]+?)?(\:)?([0-9]*[.]?[0-9]+?)?(\:)?([0-9]*[.]?[0-9]+?)?>' , raw , flags = re . DOTALL ) if has_syntax : fake_val = re . sub ( r'\'?\"?<(\^)?(fk__)?(\w+)?([0-9]*[.]?[0-9]+?)?(\:)?([0-9]*[.]?[0-9]+?)?(\:)?([0-9]*[.]?[0-9]+?)?>\'?\"?' , self . _replace_faker_attr , raw , flags = re . DOTALL ) fake_val = fake_val . replace ( "'" , '"' ) try : fake_val = json . loads ( fake_val ) except : pass return fake_val else : return raw
|
Retrieves the syntax from the response and goes through each one to generate and replace it with mock values
|
3,161
|
def count ( self , source , target ) : try : source_value = self . _response_holder [ source ] except KeyError : raw = self . fake_response [ source ] source_value = self . _parse_syntax ( raw ) if isinstance ( source_value , str ) : source_value = int ( source_value ) target = self . fake_response [ target ] values = [ ] for _ in range ( source_value ) : self . _is_empty = False mock_value = self . _parse_syntax ( target ) mock_value = str ( mock_value ) _target = mock_value [ 1 : - 1 ] _target = _target . replace ( "'" , '"' ) try : mock_value = json . loads ( _target ) except : mock_value = _target if not self . _is_empty : values . append ( mock_value ) return values
|
The count relationship is used for listing endpoints where a specific attribute might hold the value to the number of instances of another attribute .
|
3,162
|
def get_command ( self , version = 2 ) : try : options = _C [ 'options' ] options_str = " -o " . join ( options ) if options_str : options_str = "-o " + options_str + " " except KeyError : options_str = "" if self . username : command = "ssh {}" "-{} " "-p {} {}@{}" . format ( options_str , version , self . port , self . username , self . hostname ) else : command = "ssh {} " "-{} " "-p {} {}" . format ( options_str , version , self . port , self . hostname ) return command
|
Return the SSH protocol specific command to connect .
|
3,163
|
def connect ( self , driver ) : events = [ driver . password_re , self . device . prompt_re , driver . unable_to_connect_re , NEWSSHKEY , KNOWN_HOSTS , HOST_KEY_FAILED , MODULUS_TOO_SMALL , PROTOCOL_DIFFER , driver . timeout_re , pexpect . TIMEOUT , driver . syntax_error_re ] transitions = [ ( driver . password_re , [ 0 , 1 , 4 , 5 ] , - 1 , partial ( a_save_last_pattern , self ) , 0 ) , ( driver . syntax_error_re , [ 0 ] , - 1 , CommandSyntaxError ( "Command syntax error" ) , 0 ) , ( self . device . prompt_re , [ 0 ] , - 1 , partial ( a_save_last_pattern , self ) , 0 ) , ( driver . unable_to_connect_re , [ 0 ] , - 1 , a_unable_to_connect , 0 ) , ( NEWSSHKEY , [ 0 ] , 1 , partial ( a_send_line , "yes" ) , 10 ) , ( KNOWN_HOSTS , [ 0 , 1 ] , 0 , None , 0 ) , ( HOST_KEY_FAILED , [ 0 ] , - 1 , ConnectionError ( "Host key failed" , self . hostname ) , 0 ) , ( MODULUS_TOO_SMALL , [ 0 ] , 0 , self . fallback_to_sshv1 , 0 ) , ( PROTOCOL_DIFFER , [ 0 ] , 4 , self . fallback_to_sshv1 , 0 ) , ( PROTOCOL_DIFFER , [ 4 ] , - 1 , ConnectionError ( "Protocol version differs" , self . hostname ) , 0 ) , ( pexpect . TIMEOUT , [ 0 ] , 5 , partial ( a_send , "\r\n" ) , 10 ) , ( pexpect . TIMEOUT , [ 5 ] , - 1 , ConnectionTimeoutError ( "Connection timeout" , self . hostname ) , 0 ) , ( driver . timeout_re , [ 0 ] , - 1 , ConnectionTimeoutError ( "Connection timeout" , self . hostname ) , 0 ) , ] self . log ( "EXPECTED_PROMPT={}" . format ( pattern_to_str ( self . device . prompt_re ) ) ) fsm = FSM ( "SSH-CONNECT" , self . device , events , transitions , timeout = _C [ 'connect_timeout' ] , searchwindowsize = 160 ) return fsm . run ( )
|
Connect using the SSH protocol specific FSM .
|
3,164
|
def authenticate ( self , driver ) : events = [ driver . press_return_re , driver . password_re , self . device . prompt_re , pexpect . TIMEOUT ] transitions = [ ( driver . press_return_re , [ 0 , 1 ] , 1 , partial ( a_send , "\r\n" ) , 10 ) , ( driver . password_re , [ 0 ] , 1 , partial ( a_send_password , self . _acquire_password ( ) ) , _C [ 'first_prompt_timeout' ] ) , ( driver . password_re , [ 1 ] , - 1 , a_authentication_error , 0 ) , ( self . device . prompt_re , [ 0 , 1 ] , - 1 , None , 0 ) , ( pexpect . TIMEOUT , [ 1 ] , - 1 , ConnectionError ( "Error getting device prompt" ) if self . device . is_target else partial ( a_send , "\r\n" ) , 0 ) ] self . log ( "EXPECTED_PROMPT={}" . format ( pattern_to_str ( self . device . prompt_re ) ) ) fsm = FSM ( "SSH-AUTH" , self . device , events , transitions , init_pattern = self . last_pattern , timeout = 30 ) return fsm . run ( )
|
Authenticate using the SSH protocol specific FSM .
|
3,165
|
def disconnect ( self , driver ) : self . log ( "SSH disconnect" ) try : self . device . ctrl . sendline ( '\x03' ) self . device . ctrl . sendline ( '\x04' ) except OSError : self . log ( "Protocol already disconnected" )
|
Disconnect using the protocol specific method .
|
3,166
|
def fallback_to_sshv1 ( self , ctx ) : command = self . get_command ( version = 1 ) ctx . spawn_session ( command ) return True
|
Fallback to SSHv1 .
|
3,167
|
def search_meta_tag ( html_doc , prefix , code ) : regex = '<meta\s+(?:name=([\'\"]){0}\\1\s+content=([\'\"]){1}\\2|content=([\'\"]){1}\\3\s+name=([\'\"]){0}\\4)\s*/?>' . format ( prefix , code ) meta = re . compile ( regex , flags = re . MULTILINE | re . IGNORECASE ) m = meta . search ( html_doc ) if m : head = re . search ( r'</head>' , html_doc , flags = re . IGNORECASE ) if head and m . start ( ) < head . start ( ) : return True return False
|
Checks whether the html_doc contains a meta matching the prefix & code
|
3,168
|
def find_postgame ( data , size ) : pos = None for i in range ( size - SEARCH_MAX_BYTES , size - LOOKAHEAD ) : op_type , length , action_type = struct . unpack ( '<IIB' , data [ i : i + LOOKAHEAD ] ) if op_type == 0x01 and length == POSTGAME_LENGTH and action_type == 0xFF : LOGGER . debug ( "found postgame candidate @ %d with length %d" , i + LOOKAHEAD , length ) return i + LOOKAHEAD , length
|
Find postgame struct .
|
3,169
|
def parse_postgame ( handle , size ) : data = handle . read ( ) postgame = find_postgame ( data , size ) if postgame : pos , length = postgame try : return mgz . body . actions . postgame . parse ( data [ pos : pos + length ] ) except construct . core . ConstructError : raise IOError ( "failed to parse postgame" ) raise IOError ( "could not find postgame" )
|
Parse postgame structure .
|
3,170
|
def ach ( structure , fields ) : field = fields . pop ( 0 ) if structure : if hasattr ( structure , field ) : structure = getattr ( structure , field ) if not fields : return structure return ach ( structure , fields ) return None
|
Get field from achievements structure .
|
3,171
|
def get_postgame ( self ) : if self . _cache [ 'postgame' ] is not None : return self . _cache [ 'postgame' ] self . _handle . seek ( 0 ) try : self . _cache [ 'postgame' ] = parse_postgame ( self . _handle , self . size ) return self . _cache [ 'postgame' ] except IOError : self . _cache [ 'postgame' ] = False return None finally : self . _handle . seek ( self . body_position )
|
Get postgame structure .
|
3,172
|
def get_duration ( self ) : postgame = self . get_postgame ( ) if postgame : return postgame . duration_int * 1000 duration = self . _header . initial . restore_time try : while self . _handle . tell ( ) < self . size : operation = mgz . body . operation . parse_stream ( self . _handle ) if operation . type == 'sync' : duration += operation . time_increment elif operation . type == 'action' : if operation . action . type == 'resign' : self . _cache [ 'resigned' ] . add ( operation . action . player_id ) self . _handle . seek ( self . body_position ) except ( construct . core . ConstructError , zlib . error , ValueError ) : raise RuntimeError ( "invalid mgz file" ) return duration
|
Get game duration .
|
3,173
|
def get_restored ( self ) : return self . _header . initial . restore_time > 0 , self . _header . initial . restore_time
|
Check for restored game .
|
3,174
|
def get_version ( self ) : return mgz . const . VERSIONS [ self . _header . version ] , str ( self . _header . sub_version ) [ : 5 ]
|
Get game version .
|
3,175
|
def get_dataset ( self ) : sample = self . _header . initial . players [ 0 ] . attributes . player_stats if 'mod' in sample and sample . mod [ 'id' ] > 0 : return sample . mod elif 'trickle_food' in sample and sample . trickle_food : return { 'id' : 1 , 'name' : mgz . const . MODS . get ( 1 ) , 'version' : '<5.7.2' } return { 'id' : 0 , 'name' : 'Age of Kings: The Conquerors' , 'version' : '1.0c' }
|
Get dataset .
|
3,176
|
def get_teams ( self ) : if self . _cache [ 'teams' ] : return self . _cache [ 'teams' ] teams = [ ] for j , player in enumerate ( self . _header . initial . players ) : added = False for i in range ( 0 , len ( self . _header . initial . players ) ) : if player . attributes . my_diplomacy [ i ] == 'ally' : inner_team = False outer_team = False new_team = True for t , tl in enumerate ( teams ) : if j in tl or i in tl : new_team = False if j in tl and i not in tl : inner_team = t break if j not in tl and i in tl : outer_team = t break if new_team : teams . append ( [ i , j ] ) if inner_team is not False : teams [ inner_team ] . append ( i ) if outer_team is not False : teams [ outer_team ] . append ( j ) added = True if not added and j != 0 : teams . append ( [ j ] ) self . _cache [ 'teams' ] = teams return teams
|
Get teams .
|
3,177
|
def get_achievements ( self , name ) : postgame = self . get_postgame ( ) if not postgame : return None for achievements in postgame . achievements : if name . startswith ( achievements . player_name . replace ( b'\x00' , b'' ) ) : return achievements return None
|
Get achievements for a player .
|
3,178
|
def _process_body ( self ) : start_time = time . time ( ) ratings = { } encoding = self . get_encoding ( ) checksums = [ ] ladder = None voobly = False rated = False i = 0 while self . _handle . tell ( ) < self . size : try : op = mgz . body . operation . parse_stream ( self . _handle ) if op . type == 'sync' : i += 1 if op . type == 'sync' and op . checksum is not None and len ( checksums ) < CHECKSUMS : checksums . append ( op . checksum . sync . to_bytes ( 8 , 'big' , signed = True ) ) elif op . type == 'message' and op . subtype == 'chat' : text = op . data . text . decode ( encoding ) if text . find ( 'Voobly: Ratings provided' ) > 0 : start = text . find ( "'" ) + 1 end = text . find ( "'" , start ) ladder = text [ start : end ] voobly = True elif text . find ( '<Rating>' ) > 0 : player_start = text . find ( '>' ) + 2 player_end = text . find ( ':' , player_start ) player = text [ player_start : player_end ] ratings [ player ] = int ( text [ player_end + 2 : len ( text ) ] ) elif text . find ( 'No ratings are available' ) > 0 : voobly = True elif text . find ( 'This match was played at Voobly.com' ) > 0 : voobly = True if i > MAX_SYNCS : break except ( construct . core . ConstructError , ValueError ) : break self . _handle . seek ( self . body_position ) rated = len ( ratings ) > 0 and set ( ratings . values ( ) ) != { 1600 } self . _cache [ 'hash' ] = hashlib . sha1 ( b'' . join ( checksums ) ) if len ( checksums ) == CHECKSUMS else None self . _cache [ 'from_voobly' ] = voobly self . _cache [ 'ladder' ] = ladder self . _cache [ 'rated' ] = rated self . _cache [ 'ratings' ] = ratings if rated else { } LOGGER . info ( "parsed limited rec body in %.2f seconds" , time . time ( ) - start_time ) return voobly , ladder , rated , ratings
|
Get Voobly ladder .
|
3,179
|
def get_settings ( self ) : postgame = self . get_postgame ( ) return { 'type' : ( self . _header . lobby . game_type_id , self . _header . lobby . game_type ) , 'difficulty' : ( self . _header . scenario . game_settings . difficulty_id , self . _header . scenario . game_settings . difficulty ) , 'population_limit' : self . _header . lobby . population_limit * 25 , 'map_reveal_choice' : ( self . _header . lobby . reveal_map_id , self . _header . lobby . reveal_map ) , 'speed' : ( self . _header . replay . game_speed_id , mgz . const . SPEEDS . get ( self . _header . replay . game_speed_id ) ) , 'cheats' : self . _header . replay . cheats_enabled , 'lock_teams' : self . _header . lobby . lock_teams , 'starting_resources' : ( postgame . resource_level_id if postgame else None , postgame . resource_level if postgame else None , ) , 'starting_age' : ( postgame . starting_age_id if postgame else None , postgame . starting_age if postgame else None ) , 'victory_condition' : ( postgame . victory_type_id if postgame else None , postgame . victory_type if postgame else None ) , 'team_together' : not postgame . team_together if postgame else None , 'all_technologies' : postgame . all_techs if postgame else None , 'lock_speed' : postgame . lock_speed if postgame else None , 'multiqueue' : None }
|
Get settings .
|
3,180
|
def get_map ( self ) : if self . _cache [ 'map' ] : return self . _cache [ 'map' ] map_id = self . _header . scenario . game_settings . map_id instructions = self . _header . scenario . messages . instructions size = mgz . const . MAP_SIZES . get ( self . _header . map_info . size_x ) dimension = self . _header . map_info . size_x custom = True name = 'Unknown' language = None encoding = 'unknown' for pair in ENCODING_MARKERS : marker = pair [ 0 ] test_encoding = pair [ 1 ] e_m = marker . encode ( test_encoding ) for line in instructions . split ( b'\n' ) : pos = line . find ( e_m ) if pos > - 1 : encoding = test_encoding name = line [ pos + len ( e_m ) : ] . decode ( encoding ) language = pair [ 2 ] break if not language : language = 'unknown' for pair in LANGUAGE_MARKERS : if instructions . find ( pair [ 0 ] . encode ( pair [ 1 ] ) ) > - 1 : language = pair [ 2 ] break self . _cache [ 'encoding' ] = encoding self . _cache [ 'language' ] = language if map_id != 44 : if map_id not in mgz . const . MAP_NAMES : raise ValueError ( 'unspecified builtin map' ) name = mgz . const . MAP_NAMES [ map_id ] custom = False match = re . search ( b'\x00.*? (\-?[0-9]+)\x00.*?\.rms' , instructions ) seed = None if match : seed = int ( match . group ( 1 ) ) has_modes = name . find ( ': !' ) mode_string = '' if has_modes > - 1 : mode_string = name [ has_modes + 3 : ] name = name [ : has_modes ] modes = { 'direct_placement' : 'P' in mode_string , 'effect_quantity' : 'C' in mode_string , 'guard_state' : 'G' in mode_string , 'fixed_positions' : 'F' in mode_string } self . _cache [ 'map' ] = { 'id' : map_id if not custom else None , 'name' : name . strip ( ) , 'size' : size , 'dimension' : dimension , 'seed' : seed , 'modes' : modes , 'custom' : custom , 'zr' : name . startswith ( 'ZR@' ) } return self . _cache [ 'map' ]
|
Get the map metadata .
|
3,181
|
def get_completed ( self ) : postgame = self . get_postgame ( ) if postgame : return postgame . complete else : return True if self . _cache [ 'resigned' ] else False
|
Determine if the game was completed .
|
3,182
|
def get_mirror ( self ) : mirror = False if self . get_diplomacy ( ) [ '1v1' ] : civs = set ( ) for data in self . get_players ( ) : civs . add ( data [ 'civilization' ] ) mirror = ( len ( civs ) == 1 ) return mirror
|
Determine mirror match .
|
3,183
|
def guess_winner ( self , i ) : for team in self . get_teams ( ) : if i not in team : continue for p in team : if p in self . _cache [ 'resigned' ] : return False return True
|
Guess if a player won .
|
3,184
|
def trigger ( self , * args , ** kwargs ) : for h in self . handlers : h ( * args , ** kwargs )
|
Execute the handlers with a message if any .
|
3,185
|
def on ( self , event , handler = None ) : if isinstance ( event , str ) and ' ' in event : self . on ( event . split ( ' ' ) , handler ) elif isinstance ( event , list ) : for each in event : self . on ( each , handler ) elif isinstance ( event , dict ) : for key , value in event . items ( ) : self . on ( key , value ) elif isinstance ( handler , list ) : for each in handler : self . on ( event , each ) elif isinstance ( handler , Event ) : self . events [ event ] = handler setattr ( self , event , self . events [ event ] ) elif event in self . events : self . events [ event ] . on ( handler ) else : self . on ( event , Event ( handler ) )
|
Create add or update an event with a handler or more attached .
|
3,186
|
def off ( self , event , handler = None ) : if handler : self . events [ event ] . off ( handler ) else : del self . events [ event ] delattr ( self , event )
|
Remove an event or a handler from it .
|
3,187
|
def trigger ( self , * args , ** kargs ) : event = args [ 0 ] if isinstance ( event , str ) and ' ' in event : event = event . split ( ' ' ) if isinstance ( event , list ) : for each in event : self . events [ each ] . trigger ( * args [ 1 : ] , ** kargs ) else : self . events [ event ] . trigger ( * args [ 1 : ] , ** kargs )
|
Execute all event handlers with optional arguments for the observable .
|
3,188
|
def _initializer_wrapper ( initializer , * args ) : signal . signal ( signal . SIGINT , signal . SIG_IGN ) if initializer is not None : initializer ( * args )
|
Ignore SIGINT . During typical keyboard interrupts the parent does the killing .
|
3,189
|
def _col_type_set ( self , col , df ) : type_set = set ( ) if df [ col ] . dtype == np . dtype ( object ) : unindexed_col = list ( df [ col ] ) for i in range ( 0 , len ( df [ col ] ) ) : if unindexed_col [ i ] == np . nan : continue else : type_set . add ( type ( unindexed_col [ i ] ) ) return type_set else : type_set . add ( df [ col ] . dtype ) return type_set
|
Determines the set of types present in a DataFrame column .
|
3,190
|
def raw ( self , drop_collections = False ) : base_df = self . _data if drop_collections is True : out_df = self . _drop_collections ( base_df ) else : out_df = base_df return out_df
|
Produces the extractor object s data as it is stored internally .
|
3,191
|
def _walk ( path , follow_links = False , maximum_depth = None ) : root_level = path . rstrip ( os . path . sep ) . count ( os . path . sep ) for root , dirs , files in os . walk ( path , followlinks = follow_links ) : yield root , dirs , files if maximum_depth is None : continue if root_level + maximum_depth <= root . count ( os . path . sep ) : del dirs [ : ]
|
A modified os . walk with support for maximum traversal depth .
|
3,192
|
def update ( self , * sources , follow_symlinks : bool = False , maximum_depth : int = 20 ) : for source in sources : if isinstance ( source , self . klass ) : self . path_map [ source . this . name . value ] = source self . class_cache [ source . this . name . value ] = source continue source = str ( source ) if source . lower ( ) . endswith ( ( '.zip' , '.jar' ) ) : zf = ZipFile ( source , 'r' ) self . path_map . update ( zip ( zf . namelist ( ) , repeat ( zf ) ) ) elif os . path . isdir ( source ) : walker = _walk ( source , follow_links = follow_symlinks , maximum_depth = maximum_depth ) for root , dirs , files in walker : for file_ in files : path_full = os . path . join ( root , file_ ) path_suffix = os . path . relpath ( path_full , source ) self . path_map [ path_suffix ] = path_full
|
Add one or more ClassFile sources to the class loader .
|
3,193
|
def open ( self , path : str , mode : str = 'r' ) -> IO : entry = self . path_map . get ( path ) if entry is None : raise FileNotFoundError ( ) if isinstance ( entry , str ) : with open ( entry , 'rb' if mode == 'r' else mode ) as source : yield source elif isinstance ( entry , ZipFile ) : yield io . BytesIO ( entry . read ( path ) ) else : raise NotImplementedError ( )
|
Open an IO - like object for path .
|
3,194
|
def load ( self , path : str ) -> ClassFile : try : r = self . class_cache . pop ( path ) except KeyError : with self . open ( f'{path}.class' ) as source : r = self . klass ( source ) r . classloader = self self . class_cache [ path ] = r if self . max_cache > 0 : to_pop = max ( len ( self . class_cache ) - self . max_cache , 0 ) for _ in repeat ( None , to_pop ) : self . class_cache . popitem ( last = False ) return r
|
Load the class at path and return it .
|
3,195
|
def dependencies ( self , path : str ) -> Set [ str ] : return set ( c . name . value for c in self . search_constant_pool ( path = path , type_ = ConstantClass ) )
|
Returns a set of all classes referenced by the ClassFile at path without reading the entire ClassFile .
|
3,196
|
def search_constant_pool ( self , * , path : str , ** options ) : with self . open ( f'{path}.class' ) as source : source . read ( 8 ) pool = ConstantPool ( ) pool . unpack ( source ) yield from pool . find ( ** options )
|
Partially load the class at path yield all matching constants from the ConstantPool .
|
3,197
|
def classes ( self ) -> Iterator [ str ] : yield from ( c [ : - 6 ] for c in self . path_map . keys ( ) if c . endswith ( '.class' ) )
|
Yield the name of all classes discovered in the path map .
|
3,198
|
def _make_object_dict ( self , obj ) : data = { } for attr in dir ( obj ) : if attr [ 0 ] is not '_' and attr is not 'status' : datum = getattr ( obj , attr ) if not isinstance ( datum , types . MethodType ) : data . update ( self . _handle_object ( attr , datum ) ) return data
|
Processes an object exporting its data as a nested dictionary .
|
3,199
|
def unpack ( self , source : IO ) : self . access_flags . unpack ( source . read ( 2 ) ) self . _name_index , self . _descriptor_index = unpack ( '>HH' , source . read ( 4 ) ) self . attributes . unpack ( source )
|
Read the Field from the file - like object fio .
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.