idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
242,700 | def _clear_config ( self ) : # type: () -> None for section in self . _config . sections ( ) : self . _config . remove_section ( section ) | Clearout config object in memory . | 38 | 7 |
242,701 | def format_parameters ( self , params ) : # type: (Dict[str, str]) -> None query = urlparse ( self . url ) . query if query : self . url = self . url . partition ( '?' ) [ 0 ] existing_params = { p [ 0 ] : p [ - 1 ] for p in [ p . partition ( '=' ) for p in query . split ( '&' ) ] } params . update ( existing_params ) query_params = [ "{}={}" . format ( k , v ) for k , v in params . items ( ) ] query = '?' + '&' . join ( query_params ) self . url = self . url + query | Format parameters into a valid query string . It s assumed all parameters have already been quoted as valid URL strings . | 152 | 22 |
242,702 | def _format_data ( data ) : # type: (Union[str, IO]) -> Union[Tuple[None, str], Tuple[Optional[str], IO, str]] if hasattr ( data , 'read' ) : data = cast ( IO , data ) data_name = None try : if data . name [ 0 ] != '<' and data . name [ - 1 ] != '>' : data_name = os . path . basename ( data . name ) except ( AttributeError , TypeError ) : pass return ( data_name , data , "application/octet-stream" ) return ( None , cast ( str , data ) ) | Format field data according to whether it is a stream or a string for a form - data request . | 144 | 20 |
242,703 | def add_formdata ( self , content = None ) : # type: (Optional[Dict[str, str]]) -> None if content is None : content = { } content_type = self . headers . pop ( 'Content-Type' , None ) if self . headers else None if content_type and content_type . lower ( ) == 'application/x-www-form-urlencoded' : # Do NOT use "add_content" that assumes input is JSON self . data = { f : d for f , d in content . items ( ) if d is not None } else : # Assume "multipart/form-data" self . files = { f : self . _format_data ( d ) for f , d in content . items ( ) if d is not None } | Add data as a multipart form - data request to the request . | 173 | 14 |
242,704 | def raise_with_traceback ( exception , message = "" , * args , * * kwargs ) : # type: (Callable, str, Any, Any) -> None exc_type , exc_value , exc_traceback = sys . exc_info ( ) # If not called inside a "except", exc_type will be None. Assume it will not happen exc_msg = "{}, {}: {}" . format ( message , exc_type . __name__ , exc_value ) # type: ignore error = exception ( exc_msg , * args , * * kwargs ) try : raise error . with_traceback ( exc_traceback ) except AttributeError : error . __traceback__ = exc_traceback raise error | Raise exception with a specified traceback . | 162 | 9 |
242,705 | def _patch_redirect ( session ) : # type: (requests.Session) -> None def enforce_http_spec ( resp , request ) : if resp . status_code in ( 301 , 302 ) and request . method not in [ 'GET' , 'HEAD' ] : return False return True redirect_logic = session . resolve_redirects def wrapped_redirect ( resp , req , * * kwargs ) : attempt = enforce_http_spec ( resp , req ) return redirect_logic ( resp , req , * * kwargs ) if attempt else [ ] wrapped_redirect . is_msrest_patched = True # type: ignore session . resolve_redirects = wrapped_redirect | Whether redirect policy should be applied based on status code . | 157 | 11 |
242,706 | def _init_session ( self , session ) : # type: (requests.Session) -> None _patch_redirect ( session ) # Change max_retries in current all installed adapters max_retries = self . config . retry_policy ( ) for protocol in self . _protocols : session . adapters [ protocol ] . max_retries = max_retries | Init session level configuration of requests . | 82 | 7 |
242,707 | def _configure_send ( self , request , * * kwargs ) : # type: (ClientRequest, Any) -> Dict[str, str] requests_kwargs = { } # type: Any session = kwargs . pop ( 'session' , self . session ) # If custom session was not create here if session is not self . session : self . _init_session ( session ) session . max_redirects = int ( self . config . redirect_policy ( ) ) session . trust_env = bool ( self . config . proxies . use_env_settings ) # Initialize requests_kwargs with "config" value requests_kwargs . update ( self . config . connection ( ) ) requests_kwargs [ 'allow_redirects' ] = bool ( self . config . redirect_policy ) requests_kwargs [ 'headers' ] = self . config . headers . copy ( ) proxies = self . config . proxies ( ) if proxies : requests_kwargs [ 'proxies' ] = proxies # Replace by operation level kwargs # We allow some of them, since some like stream or json are controled by msrest for key in kwargs : if key in self . _REQUESTS_KWARGS : requests_kwargs [ key ] = kwargs [ key ] # Hooks. Deprecated, should be a policy def make_user_hook_cb ( user_hook , session ) : def user_hook_cb ( r , * args , * * kwargs ) : kwargs . setdefault ( "msrest" , { } ) [ 'session' ] = session return user_hook ( r , * args , * * kwargs ) return user_hook_cb hooks = [ ] for user_hook in self . config . hooks : hooks . append ( make_user_hook_cb ( user_hook , self . session ) ) if hooks : requests_kwargs [ 'hooks' ] = { 'response' : hooks } # Configuration callback. Deprecated, should be a policy output_kwargs = self . config . session_configuration_callback ( session , self . config , kwargs , * * requests_kwargs ) if output_kwargs is not None : requests_kwargs = output_kwargs # If custom session was not create here if session is not self . session : requests_kwargs [ 'session' ] = session ### Autorest forced kwargs now ### # If Autorest needs this response to be streamable. True for compat. requests_kwargs [ 'stream' ] = kwargs . get ( 'stream' , True ) if request . files : requests_kwargs [ 'files' ] = request . files elif request . data : requests_kwargs [ 'data' ] = request . data requests_kwargs [ 'headers' ] . update ( request . headers ) return requests_kwargs | Configure the kwargs to use with requests . | 626 | 11 |
242,708 | def full_restapi_key_transformer ( key , attr_desc , value ) : keys = _FLATTEN . split ( attr_desc [ 'key' ] ) return ( [ _decode_attribute_map_key ( k ) for k in keys ] , value ) | A key transformer that returns the full RestAPI key path . | 63 | 12 |
242,709 | def last_restapi_key_transformer ( key , attr_desc , value ) : key , value = full_restapi_key_transformer ( key , attr_desc , value ) return ( key [ - 1 ] , value ) | A key transformer that returns the last RestAPI key . | 54 | 11 |
242,710 | def _create_xml_node ( tag , prefix = None , ns = None ) : if prefix and ns : ET . register_namespace ( prefix , ns ) if ns : return ET . Element ( "{" + ns + "}" + tag ) else : return ET . Element ( tag ) | Create a XML node . | 62 | 5 |
242,711 | def _create_xml_node ( cls ) : try : xml_map = cls . _xml_map except AttributeError : raise ValueError ( "This model has no XML definition" ) return _create_xml_node ( xml_map . get ( 'name' , cls . __name__ ) , xml_map . get ( "prefix" , None ) , xml_map . get ( "ns" , None ) ) | Create XML node from _xml_map . | 95 | 9 |
242,712 | def validate ( self ) : validation_result = [ ] for attr_name , value in [ ( attr , getattr ( self , attr ) ) for attr in self . _attribute_map ] : attr_desc = self . _attribute_map [ attr_name ] if attr_name == "additional_properties" and attr_desc [ "key" ] == '' : # Do NOT validate additional_properties continue attr_type = attr_desc [ 'type' ] try : debug_name = "{}.{}" . format ( self . __class__ . __name__ , attr_name ) Serializer . validate ( value , debug_name , * * self . _validation . get ( attr_name , { } ) ) except ValidationError as validation_error : validation_result . append ( validation_error ) validation_result += _recursive_validate ( attr_name , attr_type , value ) return validation_result | Validate this model recursively and return a list of ValidationError . | 214 | 16 |
242,713 | def serialize ( self , keep_readonly = False ) : serializer = Serializer ( self . _infer_class_models ( ) ) return serializer . _serialize ( self , keep_readonly = keep_readonly ) | Return the JSON that would be sent to azure from this model . | 52 | 14 |
242,714 | def as_dict ( self , keep_readonly = True , key_transformer = attribute_transformer ) : serializer = Serializer ( self . _infer_class_models ( ) ) return serializer . _serialize ( self , key_transformer = key_transformer , keep_readonly = keep_readonly ) | Return a dict that can be JSONify using json . dump . | 73 | 13 |
242,715 | def deserialize ( cls , data , content_type = None ) : deserializer = Deserializer ( cls . _infer_class_models ( ) ) return deserializer ( cls . __name__ , data , content_type = content_type ) | Parse a str using the RestAPI syntax and return a model . | 60 | 14 |
242,716 | def from_dict ( cls , data , key_extractors = None , content_type = None ) : deserializer = Deserializer ( cls . _infer_class_models ( ) ) deserializer . key_extractors = [ rest_key_case_insensitive_extractor , attribute_key_case_insensitive_extractor , last_rest_key_case_insensitive_extractor ] if key_extractors is None else key_extractors return deserializer ( cls . __name__ , data , content_type = content_type ) | Parse a dict using given key extractor return a model . | 131 | 13 |
242,717 | def _classify ( cls , response , objects ) : for subtype_key in cls . __dict__ . get ( '_subtype_map' , { } ) . keys ( ) : subtype_value = None rest_api_response_key = cls . _get_rest_key_parts ( subtype_key ) [ - 1 ] subtype_value = response . pop ( rest_api_response_key , None ) or response . pop ( subtype_key , None ) if subtype_value : # Try to match base class. Can be class name only # (bug to fix in Autorest to support x-ms-discriminator-name) if cls . __name__ == subtype_value : return cls flatten_mapping_type = cls . _flatten_subtype ( subtype_key , objects ) try : return objects [ flatten_mapping_type [ subtype_value ] ] except KeyError : _LOGGER . warning ( "Subtype value %s has no mapping, use base class %s." , subtype_value , cls . __name__ , ) break else : _LOGGER . warning ( "Discriminator %s is absent or null, use base class %s." , subtype_key , cls . __name__ ) break return cls | Check the class _subtype_map for any child classes . We want to ignore any inherited _subtype_maps . Remove the polymorphic key from the initial data . | 291 | 35 |
242,718 | def body ( self , data , data_type , * * kwargs ) : if data is None : raise ValidationError ( "required" , "body" , True ) # Just in case this is a dict internal_data_type = data_type . strip ( '[]{}' ) internal_data_type = self . dependencies . get ( internal_data_type , None ) if internal_data_type and not isinstance ( internal_data_type , Enum ) : try : deserializer = Deserializer ( self . dependencies ) # Since it's on serialization, it's almost sure that format is not JSON REST # We're not able to deal with additional properties for now. deserializer . additional_properties_detection = False if issubclass ( internal_data_type , Model ) and internal_data_type . is_xml_model ( ) : deserializer . key_extractors = [ attribute_key_case_insensitive_extractor , ] else : deserializer . key_extractors = [ rest_key_case_insensitive_extractor , attribute_key_case_insensitive_extractor , last_rest_key_case_insensitive_extractor ] data = deserializer . _deserialize ( data_type , data ) except DeserializationError as err : raise_with_traceback ( SerializationError , "Unable to build a model: " + str ( err ) , err ) if self . client_side_validation : errors = _recursive_validate ( data_type , data_type , data ) if errors : raise errors [ 0 ] return self . _serialize ( data , data_type , * * kwargs ) | Serialize data intended for a request body . | 374 | 9 |
242,719 | def url ( self , name , data , data_type , * * kwargs ) : if self . client_side_validation : data = self . validate ( data , name , required = True , * * kwargs ) try : output = self . serialize_data ( data , data_type , * * kwargs ) if data_type == 'bool' : output = json . dumps ( output ) if kwargs . get ( 'skip_quote' ) is True : output = str ( output ) else : output = quote ( str ( output ) , safe = '' ) except SerializationError : raise TypeError ( "{} must be type {}." . format ( name , data_type ) ) else : return output | Serialize data intended for a URL path . | 157 | 9 |
242,720 | def header ( self , name , data , data_type , * * kwargs ) : if self . client_side_validation : data = self . validate ( data , name , required = True , * * kwargs ) try : if data_type in [ '[str]' ] : data = [ "" if d is None else d for d in data ] output = self . serialize_data ( data , data_type , * * kwargs ) if data_type == 'bool' : output = json . dumps ( output ) except SerializationError : raise TypeError ( "{} must be type {}." . format ( name , data_type ) ) else : return str ( output ) | Serialize data intended for a request header . | 149 | 9 |
242,721 | def validate ( cls , data , name , * * kwargs ) : required = kwargs . get ( 'required' , False ) if required and data is None : raise ValidationError ( "required" , name , True ) elif data is None : return elif kwargs . get ( 'readonly' ) : return try : for key , value in kwargs . items ( ) : validator = cls . validation . get ( key , lambda x , y : False ) if validator ( data , value ) : raise ValidationError ( key , name , value ) except TypeError : raise ValidationError ( "unknown" , name , "unknown" ) else : return data | Validate that a piece of data meets certain conditions | 150 | 10 |
242,722 | def serialize_data ( self , data , data_type , * * kwargs ) : if data is None : raise ValueError ( "No value for given attribute" ) try : if data_type in self . basic_types . values ( ) : return self . serialize_basic ( data , data_type , * * kwargs ) elif data_type in self . serialize_type : return self . serialize_type [ data_type ] ( data , * * kwargs ) # If dependencies is empty, try with current data class # It has to be a subclass of Enum anyway enum_type = self . dependencies . get ( data_type , data . __class__ ) if issubclass ( enum_type , Enum ) : return Serializer . serialize_enum ( data , enum_obj = enum_type ) iter_type = data_type [ 0 ] + data_type [ - 1 ] if iter_type in self . serialize_type : return self . serialize_type [ iter_type ] ( data , data_type [ 1 : - 1 ] , * * kwargs ) except ( ValueError , TypeError ) as err : msg = "Unable to serialize value: {!r} as type: {!r}." raise_with_traceback ( SerializationError , msg . format ( data , data_type ) , err ) else : return self . _serialize ( data , * * kwargs ) | Serialize generic data according to supplied data type . | 318 | 10 |
242,723 | def serialize_basic ( self , data , data_type , * * kwargs ) : custom_serializer = self . _get_custom_serializers ( data_type , * * kwargs ) if custom_serializer : return custom_serializer ( data ) if data_type == 'str' : return self . serialize_unicode ( data ) return eval ( data_type ) ( data ) | Serialize basic builting data type . Serializes objects to str int float or bool . | 90 | 19 |
242,724 | def serialize_unicode ( self , data ) : try : return data . value except AttributeError : pass try : if isinstance ( data , unicode ) : return data . encode ( encoding = 'utf-8' ) except NameError : return str ( data ) else : return str ( data ) | Special handling for serializing unicode strings in Py2 . Encode to UTF - 8 if unicode otherwise handle as a str . | 65 | 27 |
242,725 | def serialize_iter ( self , data , iter_type , div = None , * * kwargs ) : if isinstance ( data , str ) : raise SerializationError ( "Refuse str type as a valid iter type." ) serialization_ctxt = kwargs . get ( "serialization_ctxt" , { } ) serialized = [ ] for d in data : try : serialized . append ( self . serialize_data ( d , iter_type , * * kwargs ) ) except ValueError : serialized . append ( None ) if div : serialized = [ '' if s is None else str ( s ) for s in serialized ] serialized = div . join ( serialized ) if 'xml' in serialization_ctxt : # XML serialization is more complicated xml_desc = serialization_ctxt [ 'xml' ] xml_name = xml_desc [ 'name' ] # Create a wrap node if necessary (use the fact that Element and list have "append") is_wrapped = "wrapped" in xml_desc and xml_desc [ "wrapped" ] node_name = xml_desc . get ( "itemsName" , xml_name ) if is_wrapped : final_result = _create_xml_node ( xml_name , xml_desc . get ( 'prefix' , None ) , xml_desc . get ( 'ns' , None ) ) else : final_result = [ ] # All list elements to "local_node" for el in serialized : if isinstance ( el , ET . Element ) : el_node = el else : el_node = _create_xml_node ( node_name , xml_desc . get ( 'prefix' , None ) , xml_desc . get ( 'ns' , None ) ) if el is not None : # Otherwise it writes "None" :-p el_node . text = str ( el ) final_result . append ( el_node ) return final_result return serialized | Serialize iterable . | 433 | 5 |
242,726 | def serialize_dict ( self , attr , dict_type , * * kwargs ) : serialization_ctxt = kwargs . get ( "serialization_ctxt" , { } ) serialized = { } for key , value in attr . items ( ) : try : serialized [ self . serialize_unicode ( key ) ] = self . serialize_data ( value , dict_type , * * kwargs ) except ValueError : serialized [ self . serialize_unicode ( key ) ] = None if 'xml' in serialization_ctxt : # XML serialization is more complicated xml_desc = serialization_ctxt [ 'xml' ] xml_name = xml_desc [ 'name' ] final_result = _create_xml_node ( xml_name , xml_desc . get ( 'prefix' , None ) , xml_desc . get ( 'ns' , None ) ) for key , value in serialized . items ( ) : ET . SubElement ( final_result , key ) . text = value return final_result return serialized | Serialize a dictionary of objects . | 237 | 7 |
242,727 | def serialize_base64 ( attr , * * kwargs ) : encoded = b64encode ( attr ) . decode ( 'ascii' ) return encoded . strip ( '=' ) . replace ( '+' , '-' ) . replace ( '/' , '_' ) | Serialize str into base - 64 string . | 64 | 9 |
242,728 | def serialize_date ( attr , * * kwargs ) : if isinstance ( attr , str ) : attr = isodate . parse_date ( attr ) t = "{:04}-{:02}-{:02}" . format ( attr . year , attr . month , attr . day ) return t | Serialize Date object into ISO - 8601 formatted string . | 76 | 12 |
242,729 | def serialize_duration ( attr , * * kwargs ) : if isinstance ( attr , str ) : attr = isodate . parse_duration ( attr ) return isodate . duration_isoformat ( attr ) | Serialize TimeDelta object into ISO - 8601 formatted string . | 53 | 13 |
242,730 | def serialize_rfc ( attr , * * kwargs ) : try : if not attr . tzinfo : _LOGGER . warning ( "Datetime with no tzinfo will be considered UTC." ) utc = attr . utctimetuple ( ) except AttributeError : raise TypeError ( "RFC1123 object must be valid Datetime object." ) return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT" . format ( Serializer . days [ utc . tm_wday ] , utc . tm_mday , Serializer . months [ utc . tm_mon ] , utc . tm_year , utc . tm_hour , utc . tm_min , utc . tm_sec ) | Serialize Datetime object into RFC - 1123 formatted string . | 178 | 13 |
242,731 | def serialize_iso ( attr , * * kwargs ) : if isinstance ( attr , str ) : attr = isodate . parse_datetime ( attr ) try : if not attr . tzinfo : _LOGGER . warning ( "Datetime with no tzinfo will be considered UTC." ) utc = attr . utctimetuple ( ) if utc . tm_year > 9999 or utc . tm_year < 1 : raise OverflowError ( "Hit max or min date" ) microseconds = str ( attr . microsecond ) . rjust ( 6 , '0' ) . rstrip ( '0' ) . ljust ( 3 , '0' ) if microseconds : microseconds = '.' + microseconds date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}" . format ( utc . tm_year , utc . tm_mon , utc . tm_mday , utc . tm_hour , utc . tm_min , utc . tm_sec ) return date + microseconds + 'Z' except ( ValueError , OverflowError ) as err : msg = "Unable to serialize datetime object." raise_with_traceback ( SerializationError , msg , err ) except AttributeError as err : msg = "ISO-8601 object must be valid Datetime object." raise_with_traceback ( TypeError , msg , err ) | Serialize Datetime object into ISO - 8601 formatted string . | 335 | 13 |
242,732 | def _deserialize ( self , target_obj , data ) : # This is already a model, go recursive just in case if hasattr ( data , "_attribute_map" ) : constants = [ name for name , config in getattr ( data , '_validation' , { } ) . items ( ) if config . get ( 'constant' ) ] try : for attr , mapconfig in data . _attribute_map . items ( ) : if attr in constants : continue value = getattr ( data , attr ) if value is None : continue local_type = mapconfig [ 'type' ] internal_data_type = local_type . strip ( '[]{}' ) if internal_data_type not in self . dependencies or isinstance ( internal_data_type , Enum ) : continue setattr ( data , attr , self . _deserialize ( local_type , value ) ) return data except AttributeError : return response , class_name = self . _classify_target ( target_obj , data ) if isinstance ( response , basestring ) : return self . deserialize_data ( data , response ) elif isinstance ( response , type ) and issubclass ( response , Enum ) : return self . deserialize_enum ( data , response ) if data is None : return data try : attributes = response . _attribute_map d_attrs = { } for attr , attr_desc in attributes . items ( ) : # Check empty string. If it's not empty, someone has a real "additionalProperties"... if attr == "additional_properties" and attr_desc [ "key" ] == '' : continue raw_value = None # Enhance attr_desc with some dynamic data attr_desc = attr_desc . copy ( ) # Do a copy, do not change the real one internal_data_type = attr_desc [ "type" ] . strip ( '[]{}' ) if internal_data_type in self . dependencies : attr_desc [ "internalType" ] = self . dependencies [ internal_data_type ] for key_extractor in self . key_extractors : found_value = key_extractor ( attr , attr_desc , data ) if found_value is not None : if raw_value is not None and raw_value != found_value : raise KeyError ( 'Use twice the key: "{}"' . format ( attr ) ) raw_value = found_value value = self . deserialize_data ( raw_value , attr_desc [ 'type' ] ) d_attrs [ attr ] = value except ( AttributeError , TypeError , KeyError ) as err : msg = "Unable to deserialize to object: " + class_name raise_with_traceback ( DeserializationError , msg , err ) else : additional_properties = self . _build_additional_properties ( attributes , data ) return self . _instantiate_model ( response , d_attrs , additional_properties ) | Call the deserializer on a model . | 669 | 9 |
242,733 | def _classify_target ( self , target , data ) : if target is None : return None , None if isinstance ( target , basestring ) : try : target = self . dependencies [ target ] except KeyError : return target , target try : target = target . _classify ( data , self . dependencies ) except AttributeError : pass # Target is not a Model, no classify return target , target . __class__ . __name__ | Check to see whether the deserialization target object can be classified into a subclass . Once classification has been determined initialize object . | 95 | 25 |
242,734 | def _unpack_content ( raw_data , content_type = None ) : # This avoids a circular dependency. We might want to consider RawDesializer is more generic # than the pipeline concept, and put it in a toolbox, used both here and in pipeline. TBD. from . pipeline . universal import RawDeserializer # Assume this is enough to detect a Pipeline Response without importing it context = getattr ( raw_data , "context" , { } ) if context : if RawDeserializer . CONTEXT_NAME in context : return context [ RawDeserializer . CONTEXT_NAME ] raise ValueError ( "This pipeline didn't have the RawDeserializer policy; can't deserialize" ) #Assume this is enough to recognize universal_http.ClientResponse without importing it if hasattr ( raw_data , "body" ) : return RawDeserializer . deserialize_from_http_generics ( raw_data . text ( ) , raw_data . headers ) # Assume this enough to recognize requests.Response without importing it. if hasattr ( raw_data , '_content_consumed' ) : return RawDeserializer . deserialize_from_http_generics ( raw_data . text , raw_data . headers ) if isinstance ( raw_data , ( basestring , bytes ) ) or hasattr ( raw_data , 'read' ) : return RawDeserializer . deserialize_from_text ( raw_data , content_type ) return raw_data | Extract the correct structure for deserialization . | 329 | 10 |
242,735 | def _instantiate_model ( self , response , attrs , additional_properties = None ) : if callable ( response ) : subtype = getattr ( response , '_subtype_map' , { } ) try : readonly = [ k for k , v in response . _validation . items ( ) if v . get ( 'readonly' ) ] const = [ k for k , v in response . _validation . items ( ) if v . get ( 'constant' ) ] kwargs = { k : v for k , v in attrs . items ( ) if k not in subtype and k not in readonly + const } response_obj = response ( * * kwargs ) for attr in readonly : setattr ( response_obj , attr , attrs . get ( attr ) ) if additional_properties : response_obj . additional_properties = additional_properties return response_obj except TypeError as err : msg = "Unable to deserialize {} into model {}. " . format ( kwargs , response ) raise DeserializationError ( msg + str ( err ) ) else : try : for attr , value in attrs . items ( ) : setattr ( response , attr , value ) return response except Exception as exp : msg = "Unable to populate response model. " msg += "Type: {}, Error: {}" . format ( type ( response ) , exp ) raise DeserializationError ( msg ) | Instantiate a response model passing in deserialized args . | 318 | 12 |
242,736 | def deserialize_data ( self , data , data_type ) : if data is None : return data try : if not data_type : return data if data_type in self . basic_types . values ( ) : return self . deserialize_basic ( data , data_type ) if data_type in self . deserialize_type : if isinstance ( data , self . deserialize_expected_types . get ( data_type , tuple ( ) ) ) : return data is_a_text_parsing_type = lambda x : x not in [ "object" , "[]" , r"{}" ] if isinstance ( data , ET . Element ) and is_a_text_parsing_type ( data_type ) and not data . text : return None data_val = self . deserialize_type [ data_type ] ( data ) return data_val iter_type = data_type [ 0 ] + data_type [ - 1 ] if iter_type in self . deserialize_type : return self . deserialize_type [ iter_type ] ( data , data_type [ 1 : - 1 ] ) obj_type = self . dependencies [ data_type ] if issubclass ( obj_type , Enum ) : if isinstance ( data , ET . Element ) : data = data . text return self . deserialize_enum ( data , obj_type ) except ( ValueError , TypeError , AttributeError ) as err : msg = "Unable to deserialize response data." msg += " Data: {}, {}" . format ( data , data_type ) raise_with_traceback ( DeserializationError , msg , err ) else : return self . _deserialize ( obj_type , data ) | Process data for deserialization according to data type . | 385 | 11 |
242,737 | def deserialize_iter ( self , attr , iter_type ) : if attr is None : return None if isinstance ( attr , ET . Element ) : # If I receive an element here, get the children attr = list ( attr ) if not isinstance ( attr , ( list , set ) ) : raise DeserializationError ( "Cannot deserialize as [{}] an object of type {}" . format ( iter_type , type ( attr ) ) ) return [ self . deserialize_data ( a , iter_type ) for a in attr ] | Deserialize an iterable . | 130 | 7 |
242,738 | def deserialize_dict ( self , attr , dict_type ) : if isinstance ( attr , list ) : return { x [ 'key' ] : self . deserialize_data ( x [ 'value' ] , dict_type ) for x in attr } if isinstance ( attr , ET . Element ) : # Transform <Key>value</Key> into {"Key": "value"} attr = { el . tag : el . text for el in attr } return { k : self . deserialize_data ( v , dict_type ) for k , v in attr . items ( ) } | Deserialize a dictionary . | 136 | 6 |
242,739 | def deserialize_object ( self , attr , * * kwargs ) : if attr is None : return None if isinstance ( attr , ET . Element ) : # Do no recurse on XML, just return the tree as-is return attr if isinstance ( attr , basestring ) : return self . deserialize_basic ( attr , 'str' ) obj_type = type ( attr ) if obj_type in self . basic_types : return self . deserialize_basic ( attr , self . basic_types [ obj_type ] ) if obj_type is _long_type : return self . deserialize_long ( attr ) if obj_type == dict : deserialized = { } for key , value in attr . items ( ) : try : deserialized [ key ] = self . deserialize_object ( value , * * kwargs ) except ValueError : deserialized [ key ] = None return deserialized if obj_type == list : deserialized = [ ] for obj in attr : try : deserialized . append ( self . deserialize_object ( obj , * * kwargs ) ) except ValueError : pass return deserialized else : error = "Cannot deserialize generic object with type: " raise TypeError ( error + str ( obj_type ) ) | Deserialize a generic object . This will be handled as a dictionary . | 298 | 15 |
242,740 | def deserialize_basic ( self , attr , data_type ) : # If we're here, data is supposed to be a basic type. # If it's still an XML node, take the text if isinstance ( attr , ET . Element ) : attr = attr . text if not attr : if data_type == "str" : # None or '', node <a/> is empty string. return '' else : # None or '', node <a/> with a strong type is None. # Don't try to model "empty bool" or "empty int" return None if data_type == 'bool' : if attr in [ True , False , 1 , 0 ] : return bool ( attr ) elif isinstance ( attr , basestring ) : if attr . lower ( ) in [ 'true' , '1' ] : return True elif attr . lower ( ) in [ 'false' , '0' ] : return False raise TypeError ( "Invalid boolean value: {}" . format ( attr ) ) if data_type == 'str' : return self . deserialize_unicode ( attr ) return eval ( data_type ) ( attr ) | Deserialize baisc builtin data type from string . Will attempt to convert to str int float and bool . This function will also accept 1 0 true and false as valid bool values . | 261 | 38 |
242,741 | def deserialize_unicode ( data ) : # We might be here because we have an enum modeled as string, # and we try to deserialize a partial dict with enum inside if isinstance ( data , Enum ) : return data # Consider this is real string try : if isinstance ( data , unicode ) : return data except NameError : return str ( data ) else : return str ( data ) | Preserve unicode objects in Python 2 otherwise return data as a string . | 87 | 15 |
242,742 | def deserialize_enum ( data , enum_obj ) : if isinstance ( data , enum_obj ) : return data if isinstance ( data , Enum ) : data = data . value if isinstance ( data , int ) : # Workaround. We might consider remove it in the future. # https://github.com/Azure/azure-rest-api-specs/issues/141 try : return list ( enum_obj . __members__ . values ( ) ) [ data ] except IndexError : error = "{!r} is not a valid index for enum {!r}" raise DeserializationError ( error . format ( data , enum_obj ) ) try : return enum_obj ( str ( data ) ) except ValueError : for enum_value in enum_obj : if enum_value . value . lower ( ) == str ( data ) . lower ( ) : return enum_value # We don't fail anymore for unknown value, we deserialize as a string _LOGGER . warning ( "Deserializer is not able to find %s as valid enum in %s" , data , enum_obj ) return Deserializer . deserialize_unicode ( data ) | Deserialize string into enum object . | 256 | 8 |
242,743 | def deserialize_bytearray ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text return bytearray ( b64decode ( attr ) ) | Deserialize string into bytearray . | 48 | 10 |
242,744 | def deserialize_base64 ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text padding = '=' * ( 3 - ( len ( attr ) + 3 ) % 4 ) attr = attr + padding encoded = attr . replace ( '-' , '+' ) . replace ( '_' , '/' ) return b64decode ( encoded ) | Deserialize base64 encoded string into string . | 90 | 10 |
242,745 | def deserialize_decimal ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text try : return decimal . Decimal ( attr ) except decimal . DecimalException as err : msg = "Invalid decimal {}" . format ( attr ) raise_with_traceback ( DeserializationError , msg , err ) | Deserialize string into Decimal object . | 80 | 9 |
242,746 | def deserialize_duration ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text try : duration = isodate . parse_duration ( attr ) except ( ValueError , OverflowError , AttributeError ) as err : msg = "Cannot deserialize duration object." raise_with_traceback ( DeserializationError , msg , err ) else : return duration | Deserialize ISO - 8601 formatted string into TimeDelta object . | 92 | 14 |
242,747 | def deserialize_date ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text if re . search ( r"[^\W\d_]" , attr , re . I + re . U ) : raise DeserializationError ( "Date must have only digits and -. Received: %s" % attr ) # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. return isodate . parse_date ( attr , defaultmonth = None , defaultday = None ) | Deserialize ISO - 8601 formatted string into Date object . | 122 | 13 |
242,748 | def deserialize_rfc ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text try : date_obj = datetime . datetime . strptime ( attr , "%a, %d %b %Y %H:%M:%S %Z" ) if not date_obj . tzinfo : date_obj = date_obj . replace ( tzinfo = TZ_UTC ) except ValueError as err : msg = "Cannot deserialize to rfc datetime object." raise_with_traceback ( DeserializationError , msg , err ) else : return date_obj | Deserialize RFC - 1123 formatted string into Datetime object . | 143 | 14 |
242,749 | def deserialize_iso ( attr ) : if isinstance ( attr , ET . Element ) : attr = attr . text try : attr = attr . upper ( ) match = Deserializer . valid_date . match ( attr ) if not match : raise ValueError ( "Invalid datetime string: " + attr ) check_decimal = attr . split ( '.' ) if len ( check_decimal ) > 1 : decimal_str = "" for digit in check_decimal [ 1 ] : if digit . isdigit ( ) : decimal_str += digit else : break if len ( decimal_str ) > 6 : attr = attr . replace ( decimal_str , decimal_str [ 0 : 6 ] ) date_obj = isodate . parse_datetime ( attr ) test_utc = date_obj . utctimetuple ( ) if test_utc . tm_year > 9999 or test_utc . tm_year < 1 : raise OverflowError ( "Hit max or min date" ) except ( ValueError , OverflowError , AttributeError ) as err : msg = "Cannot deserialize datetime object." raise_with_traceback ( DeserializationError , msg , err ) else : return date_obj | Deserialize ISO - 8601 formatted string into Datetime object . | 282 | 14 |
242,750 | def raw ( self ) : # type: () -> ClientRawResponse raw = ClientRawResponse ( self . current_page , self . _response ) if self . _raw_headers : raw . add_headers ( self . _raw_headers ) return raw | Get current page as ClientRawResponse . | 54 | 8 |
242,751 | def advance_page ( self ) : # type: () -> List[Model] if self . next_link is None : raise StopIteration ( "End of paging" ) self . _current_page_iter_index = 0 self . _response = self . _get_next ( self . next_link ) self . _derserializer ( self , self . _response ) return self . current_page | Force moving the cursor to the next azure call . | 89 | 11 |
242,752 | def _ensureAtomicity ( fn ) : @ ensureScoopStartedProperly def wrapper ( * args , * * kwargs ) : """setConst(**kwargs) Set a constant that will be shared to every workers. This call blocks until the constant has propagated to at least one worker. :param \*\*kwargs: One or more combination(s) key=value. Key being the variable name and value the object to share. :returns: None. Usage: setConst(name=value) """ # Note that the docstring is the one of setConst. # This is because of the documentation framework (sphinx) limitations. from . import _control # Enforce retrieval of currently awaiting constants _control . execQueue . socket . pumpInfoSocket ( ) for key , value in kwargs . items ( ) : # Object name existence check if key in itertools . chain ( * ( elem . keys ( ) for elem in elements . values ( ) ) ) : raise TypeError ( "This constant already exists: {0}." . format ( key ) ) # Retry element propagation until it is returned while all ( key in elements . get ( scoop . worker , [ ] ) for key in kwargs . keys ( ) ) is not True : scoop . logger . debug ( "Sending global variables {0}..." . format ( list ( kwargs . keys ( ) ) ) ) # Call the function fn ( * args , * * kwargs ) # Enforce retrieval of currently awaiting constants _control . execQueue . socket . pumpInfoSocket ( ) # TODO: Make previous blocking instead of sleep time . sleep ( 0.1 ) # Atomicity check elementNames = list ( itertools . chain ( * ( elem . keys ( ) for elem in elements . values ( ) ) ) ) if len ( elementNames ) != len ( set ( elementNames ) ) : raise TypeError ( "This constant already exists: {0}." . format ( key ) ) return wrapper | Ensure atomicity of passed elements on the whole worker pool | 434 | 12 |
242,753 | def getConst ( name , timeout = 0.1 ) : from . import _control import time timeStamp = time . time ( ) while True : # Enforce retrieval of currently awaiting constants _control . execQueue . socket . pumpInfoSocket ( ) # Constants concatenation constants = dict ( reduce ( lambda x , y : x + list ( y . items ( ) ) , elements . values ( ) , [ ] ) ) timeoutHappened = time . time ( ) - timeStamp > timeout if constants . get ( name ) is not None or timeoutHappened : return constants . get ( name ) time . sleep ( 0.01 ) | Get a shared constant . | 138 | 5 |
242,754 | def launchBootstraps ( ) : global processes worker_amount , verbosity , args = getArgs ( ) was_origin = False if verbosity >= 1 : sys . stderr . write ( "Launching {0} worker(s) using {1}.\n" . format ( worker_amount , os . environ [ 'SHELL' ] if 'SHELL' in os . environ else "an unknown shell" , ) ) sys . stderr . flush ( ) processes = [ ] for _ in range ( worker_amount ) : command = [ sys . executable , "-m" , BOOTSTRAP_MODULE ] + args if verbosity >= 3 : sys . stderr . write ( "Executing '{0}'...\n" . format ( command ) ) sys . stderr . flush ( ) processes . append ( Popen ( command ) ) # Only have a single origin try : args . remove ( "--origin" ) except ValueError : pass else : was_origin = True if was_origin : # Only wait on the origin, this will return and notify the launcher # the the job has finished and start the cleanup phase try : processes [ 0 ] . wait ( ) except KeyboardInterrupt : pass else : for p in processes : p . wait ( ) | Launch the bootstrap instances in separate subprocesses | 277 | 10 |
242,755 | def resolve ( self , s ) : name = s . split ( '.' ) used = name . pop ( 0 ) try : found = self . importer ( used ) for frag in name : used += '.' + frag try : found = getattr ( found , frag ) except AttributeError : self . importer ( used ) found = getattr ( found , frag ) return found except ImportError : e , tb = sys . exc_info ( ) [ 1 : ] v = ValueError ( 'Cannot resolve %r: %s' % ( s , e ) ) v . __cause__ , v . __traceback__ = e , tb raise v | Resolve strings to objects using standard import and attribute syntax . | 142 | 12 |
242,756 | def as_tuple ( self , value ) : if isinstance ( value , list ) : value = tuple ( value ) return value | Utility function which converts lists to tuples . | 28 | 10 |
242,757 | def configure_formatter ( self , config ) : if '()' in config : factory = config [ '()' ] # for use in exception handler try : result = self . configure_custom ( config ) except TypeError , te : if "'format'" not in str ( te ) : raise #Name of parameter changed from fmt to format. #Retry with old name. #This is so that code can be used with older Python versions #(e.g. by Django) config [ 'fmt' ] = config . pop ( 'format' ) config [ '()' ] = factory result = self . configure_custom ( config ) else : fmt = config . get ( 'format' , None ) dfmt = config . get ( 'datefmt' , None ) result = logging . Formatter ( fmt , dfmt ) return result | Configure a formatter from a dictionary . | 178 | 9 |
242,758 | def configure_filter ( self , config ) : if '()' in config : result = self . configure_custom ( config ) else : name = config . get ( 'name' , '' ) result = logging . Filter ( name ) return result | Configure a filter from a dictionary . | 51 | 8 |
242,759 | def configure_logger ( self , name , config , incremental = False ) : logger = logging . getLogger ( name ) self . common_logger_config ( logger , config , incremental ) propagate = config . get ( 'propagate' , None ) if propagate is not None : logger . propagate = propagate | Configure a non - root logger from a dictionary . | 66 | 11 |
242,760 | def configure_root ( self , config , incremental = False ) : root = logging . getLogger ( ) self . common_logger_config ( root , config , incremental ) | Configure a root logger from a dictionary . | 38 | 9 |
242,761 | def sliceImage ( image , divWidth , divHeight ) : w , h = image . size tiles = [ ] for y in range ( 0 , h - 1 , h / divHeight ) : my = min ( y + h / divHeight , h ) for x in range ( 0 , w - 1 , w / divWidth ) : mx = min ( x + w / divWidth , w ) tiles . append ( image . crop ( ( x , y , mx , my ) ) ) return tiles | Divide the received image in multiple tiles | 107 | 8 |
242,762 | def resizeTile ( index , size ) : resized = tiles [ index ] . resize ( size , Image . ANTIALIAS ) return sImage ( resized . tostring ( ) , resized . size , resized . mode ) | Apply Antialiasing resizing to tile | 50 | 9 |
242,763 | def initLogging ( verbosity = 0 , name = "SCOOP" ) : global loggingConfig verbose_levels = { - 2 : "CRITICAL" , - 1 : "ERROR" , 0 : "WARNING" , 1 : "INFO" , 2 : "DEBUG" , 3 : "DEBUG" , 4 : "NOSET" , } log_handlers = { "console" : { "class" : "logging.StreamHandler" , "formatter" : "{name}Formatter" . format ( name = name ) , "stream" : "ext://sys.stderr" , } , } loggingConfig . update ( { "{name}Logger" . format ( name = name ) : { "handlers" : [ "console" ] , "level" : verbose_levels [ verbosity ] , } , } ) dict_log_config = { "version" : 1 , "handlers" : log_handlers , "loggers" : loggingConfig , "formatters" : { "{name}Formatter" . format ( name = name ) : { "format" : "[%(asctime)-15s] %(module)-9s " "%(levelname)-7s %(message)s" , } , } , } dictConfig ( dict_log_config ) return logging . getLogger ( "{name}Logger" . format ( name = name ) ) | Creates a logger . | 307 | 5 |
242,764 | def externalHostname ( hosts ) : hostname = hosts [ 0 ] [ 0 ] if hostname in localHostnames and len ( hosts ) > 1 : hostname = socket . getfqdn ( ) . split ( "." ) [ 0 ] try : socket . getaddrinfo ( hostname , None ) except socket . gaierror : raise Exception ( "\nThe first host (containing a broker) is not" " routable.\nMake sure the address is correct." ) return hostname | Ensure external hostname is routable . | 106 | 9 |
242,765 | def getHosts ( filename = None , hostlist = None ) : if filename : return getHostsFromFile ( filename ) elif hostlist : return getHostsFromList ( hostlist ) elif getEnv ( ) == "SLURM" : return getHostsFromSLURM ( ) elif getEnv ( ) == "PBS" : return getHostsFromPBS ( ) elif getEnv ( ) == "SGE" : return getHostsFromSGE ( ) else : return getDefaultHosts ( ) | Return a list of hosts depending on the environment | 119 | 9 |
242,766 | def getHostsFromFile ( filename ) : valid_hostname = r"^[^ /\t=\n]+" workers = r"\d+" hostname_re = re . compile ( valid_hostname ) worker_re = re . compile ( workers ) hosts = [ ] with open ( filename ) as f : for line in f : # check to see if it is a SLURM grouping instead of a # regular list of hosts if re . search ( '[\[\]]' , line ) : hosts = hosts + parseSLURM ( line . strip ( ) ) else : host = hostname_re . search ( line . strip ( ) ) if host : hostname = host . group ( ) n = worker_re . search ( line [ host . end ( ) : ] ) if n : n = n . group ( ) else : # Automatically assign based on CPU count n = 0 hosts . append ( ( hostname , int ( n ) ) ) return hosts | Parse a file to return a list of hosts . | 212 | 11 |
242,767 | def getHostsFromList ( hostlist ) : # check to see if it is a SLURM grouping instead of a # regular list of hosts if any ( re . search ( '[\[\]]' , x ) for x in hostlist ) : return parseSLURM ( str ( hostlist ) ) # Counter would be more efficient but: # 1. Won't be Python 2.6 compatible # 2. Won't be ordered hostlist = groupTogether ( hostlist ) retVal = [ ] for key , group in groupby ( hostlist ) : retVal . append ( ( key , len ( list ( group ) ) ) ) return retVal | Return the hosts from the command line | 138 | 7 |
242,768 | def parseSLURM ( string ) : # Use scontrol utility to get the hosts list import subprocess , os hostsstr = subprocess . check_output ( [ "scontrol" , "show" , "hostnames" , string ] ) if sys . version_info . major > 2 : hostsstr = hostsstr . decode ( ) # Split using endline hosts = hostsstr . split ( os . linesep ) # Take out last empty host hosts = filter ( None , hosts ) # Create the desired pair of host and number of hosts hosts = [ ( host , 1 ) for host in hosts ] return hosts | Return a host list from a SLURM string | 131 | 10 |
242,769 | def getHostsFromPBS ( ) : # See above comment about Counter with open ( os . environ [ "PBS_NODEFILE" ] , 'r' ) as hosts : hostlist = groupTogether ( hosts . read ( ) . split ( ) ) retVal = [ ] for key , group in groupby ( hostlist ) : retVal . append ( ( key , len ( list ( group ) ) ) ) return retVal | Return a host list in a PBS environment | 94 | 8 |
242,770 | def getHostsFromSGE ( ) : with open ( os . environ [ "PE_HOSTFILE" ] , 'r' ) as hosts : return [ ( host . split ( ) [ 0 ] , int ( host . split ( ) [ 1 ] ) ) for host in hosts ] | Return a host list in a SGE environment | 63 | 9 |
242,771 | def getWorkerQte ( hosts ) : if "SLURM_NTASKS" in os . environ : return int ( os . environ [ "SLURM_NTASKS" ] ) elif "PBS_NP" in os . environ : return int ( os . environ [ "PBS_NP" ] ) elif "NSLOTS" in os . environ : return int ( os . environ [ "NSLOTS" ] ) else : return sum ( host [ 1 ] for host in hosts ) | Return the number of workers to launch depending on the environment | 117 | 11 |
242,772 | def functionFactory ( in_code , name , defaults , globals_ , imports ) : def generatedFunction ( ) : pass generatedFunction . __code__ = marshal . loads ( in_code ) generatedFunction . __name__ = name generatedFunction . __defaults = defaults generatedFunction . __globals__ . update ( pickle . loads ( globals_ ) ) for key , value in imports . items ( ) : imported_module = __import__ ( value ) scoop . logger . debug ( "Dynamically loaded module {0}" . format ( value ) ) generatedFunction . __globals__ . update ( { key : imported_module } ) return generatedFunction | Creates a function at runtime using binary compiled inCode | 143 | 11 |
242,773 | def makeLambdaPicklable ( lambda_function ) : if isinstance ( lambda_function , type ( lambda : None ) ) and lambda_function . __name__ == '<lambda>' : def __reduce_ex__ ( proto ) : # TODO: argdefs, closure return unpickleLambda , ( marshal . dumps ( lambda_function . __code__ ) , ) lambda_function . __reduce_ex__ = __reduce_ex__ return lambda_function | Take input lambda function l and makes it picklable . | 108 | 12 |
242,774 | def addConnector ( self , wire1 , wire2 ) : if wire1 == wire2 : return if wire1 > wire2 : wire1 , wire2 = wire2 , wire1 try : last_level = self [ - 1 ] except IndexError : # Empty network, create new level and connector self . append ( [ ( wire1 , wire2 ) ] ) return for wires in last_level : if wires [ 1 ] >= wire1 and wires [ 0 ] <= wire2 : self . append ( [ ( wire1 , wire2 ) ] ) return last_level . append ( ( wire1 , wire2 ) ) | Add a connector between wire1 and wire2 in the network . | 131 | 13 |
242,775 | def sort ( self , values ) : for level in self : for wire1 , wire2 in level : if values [ wire1 ] > values [ wire2 ] : values [ wire1 ] , values [ wire2 ] = values [ wire2 ] , values [ wire1 ] | Sort the values in - place based on the connectors in the network . | 58 | 14 |
242,776 | def draw ( self ) : str_wires = [ [ "-" ] * 7 * self . depth ] str_wires [ 0 ] [ 0 ] = "0" str_wires [ 0 ] [ 1 ] = " o" str_spaces = [ ] for i in range ( 1 , self . dimension ) : str_wires . append ( [ "-" ] * 7 * self . depth ) str_spaces . append ( [ " " ] * 7 * self . depth ) str_wires [ i ] [ 0 ] = str ( i ) str_wires [ i ] [ 1 ] = " o" for index , level in enumerate ( self ) : for wire1 , wire2 in level : str_wires [ wire1 ] [ ( index + 1 ) * 6 ] = "x" str_wires [ wire2 ] [ ( index + 1 ) * 6 ] = "x" for i in range ( wire1 , wire2 ) : str_spaces [ i ] [ ( index + 1 ) * 6 + 1 ] = "|" for i in range ( wire1 + 1 , wire2 ) : str_wires [ i ] [ ( index + 1 ) * 6 ] = "|" network_draw = "" . join ( str_wires [ 0 ] ) for line , space in zip ( str_wires [ 1 : ] , str_spaces ) : network_draw += "\n" network_draw += "" . join ( space ) network_draw += "\n" network_draw += "" . join ( line ) return network_draw | Return an ASCII representation of the network . | 341 | 8 |
242,777 | def getWorkersName ( data ) : names = [ fichier for fichier in data . keys ( ) ] names . sort ( ) try : names . remove ( "broker" ) except ValueError : pass return names | Returns the list of the names of the workers sorted alphabetically | 49 | 12 |
242,778 | def importData ( directory ) : dataTask = OrderedDict ( ) dataQueue = OrderedDict ( ) for fichier in sorted ( os . listdir ( directory ) ) : try : with open ( "{directory}/{fichier}" . format ( * * locals ( ) ) , 'rb' ) as f : fileName , fileType = fichier . rsplit ( '-' , 1 ) if fileType == "QUEUE" : dataQueue [ fileName ] = pickle . load ( f ) else : dataTask [ fileName ] = pickle . load ( f ) except : # Can be a directory pass return dataTask , dataQueue | Parse the input files and return two dictionnaries | 144 | 11 |
242,779 | def getTimes ( dataTasks ) : global begin_time start_time , end_time = float ( 'inf' ) , 0 for fichier , vals in dataTask . items ( ) : try : if hasattr ( vals , 'values' ) : tmp_start_time = min ( [ a [ 'start_time' ] for a in vals . values ( ) ] ) [ 0 ] if tmp_start_time < start_time : start_time = tmp_start_time tmp_end_time = max ( [ a [ 'end_time' ] for a in vals . values ( ) ] ) [ 0 ] if tmp_end_time > end_time : end_time = tmp_end_time except ValueError : continue begin_time = 1000 * start_time return 1000 * start_time , 1000 * end_time | Get the start time and the end time of data in milliseconds | 186 | 12 |
242,780 | def WorkersDensity ( dataTasks ) : start_time , end_time = getTimes ( dataTasks ) graphdata = [ ] for name in getWorkersName ( dataTasks ) : vals = dataTasks [ name ] if hasattr ( vals , 'values' ) : # Data from worker workerdata = [ ] print ( "Plotting density map for {}" . format ( name ) ) # We only have 800 pixels try : for graphtime in timeRange ( start_time , end_time , DENSITY_MAP_TIME_AXIS_LENGTH ) : for a in vals . values ( ) : if not all ( ( a [ 'start_time' ] , a [ 'end_time' ] ) ) : print ( "Invalid data:" , a [ 'start_time' ] , a [ 'end_time' ] ) #print(a['start_time'], a['end_time']) workerdata . append ( sum ( [ a [ 'start_time' ] [ 0 ] <= float ( graphtime ) / 1000. <= a [ 'end_time' ] [ 0 ] for a in vals . values ( ) if a [ 'start_time' ] and a [ 'end_time' ] ] ) ) except OverflowError : print ( "Error processing {0} or {1}" . format ( start_time , end_time ) ) graphdata . append ( workerdata ) if args . binarydensity : # Normalize [...] maxval = max ( graphdata [ - 1 ] ) if maxval > 1 : maxval = maxval - 1 graphdata [ - 1 ] = [ x - maxval for x in graphdata [ - 1 ] ] return graphdata | Return the worker density data for the graph . | 371 | 9 |
242,781 | def plotDensity ( dataTask , filename ) : #def format_worker(x, pos=None): # """Formats the worker name""" # #workers = filter (lambda a: a[:6] != "broker", dataTask.keys()) # workers = [a for a in dataTask.keys() if a[:6] != "broker"] # return workers[x] def format_time ( x , pos = None ) : """Formats the time""" start_time , end_time = [ ( a - begin_time ) / 1000 for a in getTimes ( dataTask ) ] return int ( end_time * x / DENSITY_MAP_TIME_AXIS_LENGTH ) graphdata = WorkersDensity ( dataTask ) if len ( graphdata ) : fig = plt . figure ( ) ax = fig . add_subplot ( 111 ) box = ax . get_position ( ) ax . set_position ( [ box . x0 + 0.15 * box . width , box . y0 , box . width , box . height ] ) #cax = ax.imshow(graphdata, interpolation='nearest', aspect='auto') if args . binarydensity : cmap = ListedColormap ( [ 'r' , 'g' ] ) norm = BoundaryNorm ( [ 0 , 0.5 , 1 ] , cmap . N ) cax = ax . imshow ( graphdata , interpolation = 'nearest' , aspect = 'auto' , cmap = cmap , norm = norm ) else : cax = ax . imshow ( graphdata , interpolation = 'nearest' , aspect = 'auto' ) plt . xlabel ( 'time (s)' ) plt . ylabel ( 'Worker' ) ax . set_title ( 'Work density' ) ax . yaxis . set_ticks ( range ( len ( graphdata ) ) ) ax . tick_params ( axis = 'both' , which = 'major' , labelsize = 6 ) #ax.yaxis.set_major_formatter(ticker.FuncFormatter(format_worker)) interval_size = DENSITY_MAP_TIME_AXIS_LENGTH // 4 ax . xaxis . set_ticks ( range ( 0 , DENSITY_MAP_TIME_AXIS_LENGTH + interval_size , interval_size ) ) ax . xaxis . set_major_formatter ( ticker . FuncFormatter ( format_time ) ) if args . binarydensity : cax . set_clim ( 0 , 1 ) cbar = fig . colorbar ( cax , ticks = [ 0 , 1 ] ) else : cbar = fig . colorbar ( cax ) fig . savefig ( filename ) | Plot the worker density graph | 602 | 5 |
242,782 | def plotBrokerQueue ( dataTask , filename ) : print ( "Plotting broker queue length for {0}." . format ( filename ) ) plt . figure ( ) # Queue length plt . subplot ( 211 ) for fichier , vals in dataTask . items ( ) : if type ( vals ) == list : timestamps = list ( map ( datetime . fromtimestamp , map ( int , list ( zip ( * vals ) ) [ 0 ] ) ) ) # Data is from broker plt . plot_date ( timestamps , list ( zip ( * vals ) ) [ 2 ] , linewidth = 1.0 , marker = 'o' , markersize = 2 , label = fichier ) plt . title ( 'Broker queue length' ) plt . ylabel ( 'Tasks' ) # Requests received plt . subplot ( 212 ) for fichier , vals in dataTask . items ( ) : if type ( vals ) == list : timestamps = list ( map ( datetime . fromtimestamp , map ( int , list ( zip ( * vals ) ) [ 0 ] ) ) ) # Data is from broker plt . plot_date ( timestamps , list ( zip ( * vals ) ) [ 3 ] , linewidth = 1.0 , marker = 'o' , markersize = 2 , label = fichier ) plt . title ( 'Broker pending requests' ) plt . xlabel ( 'time (s)' ) plt . ylabel ( 'Requests' ) plt . savefig ( filename ) | Generates the broker queue length graphic . | 351 | 8 |
242,783 | def getWorkerInfo ( dataTask ) : workertime = [ ] workertasks = [ ] for fichier , vals in dataTask . items ( ) : if hasattr ( vals , 'values' ) : #workers_names.append(fichier) # Data from worker totaltime = sum ( [ a [ 'executionTime' ] for a in vals . values ( ) ] ) totaltasks = sum ( [ 1 for a in vals . values ( ) ] ) workertime . append ( totaltime ) workertasks . append ( totaltasks ) return workertime , workertasks | Returns the total execution time and task quantity by worker | 135 | 10 |
242,784 | def timelines ( fig , y , xstart , xstop , color = 'b' ) : fig . hlines ( y , xstart , xstop , color , lw = 4 ) fig . vlines ( xstart , y + 0.03 , y - 0.03 , color , lw = 2 ) fig . vlines ( xstop , y + 0.03 , y - 0.03 , color , lw = 2 ) | Plot timelines at y from xstart to xstop with given color . | 94 | 14 |
242,785 | def plotTimeline ( dataTask , filename ) : fig = plt . figure ( ) ax = fig . gca ( ) worker_names = [ x for x in dataTask . keys ( ) if "broker" not in x ] min_time = getMinimumTime ( dataTask ) ystep = 1. / ( len ( worker_names ) + 1 ) y = 0 for worker , vals in dataTask . items ( ) : if "broker" in worker : continue y += ystep if hasattr ( vals , 'values' ) : for future in vals . values ( ) : start_time = [ future [ 'start_time' ] [ 0 ] - min_time ] end_time = [ future [ 'end_time' ] [ 0 ] - min_time ] timelines ( ax , y , start_time , end_time ) #ax.xaxis_date() #myFmt = DateFormatter('%H:%M:%S') #ax.xaxis.set_major_formatter(myFmt) #ax.xaxis.set_major_locator(SecondLocator(0, interval=20)) #delta = (stop.max() - start.min())/10 ax . set_yticks ( np . arange ( ystep , 1 , ystep ) ) ax . set_yticklabels ( worker_names ) ax . set_ylim ( 0 , 1 ) #fig.xlim() ax . set_xlabel ( 'Time' ) fig . savefig ( filename ) | Build a timeline | 336 | 3 |
242,786 | def setWorker ( self , * args , * * kwargs ) : try : la = self . LAUNCHING_ARGUMENTS ( * args , * * kwargs ) except TypeError as e : scoop . logger . error ( ( "addWorker failed to convert args %s and kwargs %s " "to namedtuple (requires %s arguments (names %s)" ) % ( args , kwargs , len ( self . LAUNCHING_ARGUMENTS . _fields ) , self . LAUNCHING_ARGUMENTS . _fields ) ) self . workersArguments = la | Add a worker assignation Arguments and order to pass are defined in LAUNCHING_ARGUMENTS Using named args is advised . | 134 | 28 |
242,787 | def _WorkerCommand_environment ( self ) : worker = self . workersArguments c = [ ] if worker . prolog : c . extend ( [ "source" , worker . prolog , "&&" , ] ) if worker . pythonPath and not self . isLocal ( ) : # Tried to make it compliant to all shell variants. c . extend ( [ "env" , "PYTHONPATH={0}:$PYTHONPATH" . format ( worker . pythonPath ) , ] ) elif worker . pythonPath and self . isLocal ( ) : # Tried to make it compliant to all shell variants. c . extend ( [ "env" , "PYTHONPATH={0}:{1}" . format ( worker . pythonPath , os . environ . get ( "PYTHONPATH" , "" ) , ) , ] ) return c | Return list of shell commands to prepare the environment for bootstrap . | 189 | 13 |
242,788 | def _WorkerCommand_launcher ( self ) : return [ self . workersArguments . pythonExecutable , '-m' , 'scoop.launch.__main__' , str ( self . workerAmount ) , str ( self . workersArguments . verbose ) , ] | Return list commands to start the bootstrap process | 62 | 9 |
242,789 | def _WorkerCommand_options ( self ) : worker = self . workersArguments c = [ ] # If broker is on localhost if self . hostname == worker . brokerHostname : broker = "127.0.0.1" else : broker = worker . brokerHostname if worker . nice is not None : c . extend ( [ '--nice' , str ( worker . nice ) ] ) c . extend ( [ '--size' , str ( worker . size ) ] ) if self . isLocal ( ) : c . extend ( [ '--workingDirectory' , str ( worker . path ) ] ) else : c . extend ( [ '--workingDirectory' , '"{0}"' . format ( str ( worker . path ) ) ] ) c . extend ( [ '--brokerHostname' , broker ] ) c . extend ( [ '--externalBrokerHostname' , worker . brokerHostname ] ) c . extend ( [ '--taskPort' , str ( worker . brokerPorts [ 0 ] ) ] ) c . extend ( [ '--metaPort' , str ( worker . brokerPorts [ 1 ] ) ] ) if worker . origin and worker . executable : c . append ( '--origin' ) if worker . debug : c . append ( '--debug' ) if worker . profiling : c . append ( '--profile' ) if worker . backend : c . append ( '--backend={0}' . format ( worker . backend ) ) if worker . verbose >= 1 : c . append ( '-' + 'v' * worker . verbose ) return c | Return list of options for bootstrap | 345 | 7 |
242,790 | def _WorkerCommand_executable ( self ) : worker = self . workersArguments c = [ ] if worker . executable : c . append ( worker . executable ) # This trick is used to parse correctly quotes # (ie. myScript.py 'arg1 "arg2" arg3') # Because it is parsed by a shell, every quote gets re-interpreted. # It replaces simple quotation marks with \\\" which gets evaluated to # \" by the second shell which prints it out as a double quote. if worker . args : if self . isLocal ( ) : # If local, no shell is used so no escaping needed c . extend ( [ '{0}' . format ( a ) for a in worker . args ] ) else : c . extend ( [ '"{0}"' . format ( a . replace ( '"' , '\\\"' ) ) for a in worker . args ] ) return c | Return executable and any options to be executed by bootstrap | 196 | 11 |
242,791 | def _getWorkerCommandList ( self ) : c = [ ] c . extend ( self . _WorkerCommand_environment ( ) ) c . extend ( self . _WorkerCommand_launcher ( ) ) c . extend ( self . _WorkerCommand_options ( ) ) c . extend ( self . _WorkerCommand_executable ( ) ) return c | Generate the workerCommand as list | 79 | 7 |
242,792 | def launch ( self , tunnelPorts = None ) : if self . isLocal ( ) : # Launching local workers c = self . _getWorkerCommandList ( ) self . subprocesses . append ( subprocess . Popen ( c ) ) else : # Launching remotely BASE_SSH [ 0 ] = self . ssh_executable sshCmd = BASE_SSH if not self . rsh else BASE_RSH if tunnelPorts is not None : sshCmd += [ '-R {0}:127.0.0.1:{0}' . format ( tunnelPorts [ 0 ] ) , '-R {0}:127.0.0.1:{0}' . format ( tunnelPorts [ 1 ] ) , ] self . subprocesses . append ( subprocess . Popen ( sshCmd + [ self . hostname , self . getCommand ( ) ] , bufsize = - 1 , stdout = None , stderr = None , stdin = subprocess . PIPE ) ) return self . subprocesses | Launch every worker assigned on this host . | 226 | 8 |
242,793 | def _switch ( self , future ) : scoop . _control . current = self assert self . greenlet is not None , ( "No greenlet to switch to:" "\n{0}" . format ( self . __dict__ ) ) return self . greenlet . switch ( future ) | Switch greenlet . | 60 | 4 |
242,794 | def cancel ( self ) : if self in scoop . _control . execQueue . movable : self . exceptionValue = CancelledError ( ) scoop . _control . futureDict [ self . id ] . _delete ( ) scoop . _control . execQueue . remove ( self ) return True return False | If the call is currently being executed or sent for remote execution then it cannot be cancelled and the method will return False otherwise the call will be cancelled and the method will return True . | 64 | 36 |
242,795 | def done ( self ) : # Flush the current future in the local buffer (potential deadlock # otherwise) try : scoop . _control . execQueue . remove ( self ) scoop . _control . execQueue . socket . sendFuture ( self ) except ValueError as e : # Future was not in the local queue, everything is fine pass # Process buffers scoop . _control . execQueue . updateQueue ( ) return self . _ended ( ) | Returns True if the call was successfully cancelled or finished running False otherwise . This function updates the executionQueue so it receives all the awaiting message . | 94 | 28 |
242,796 | def add_done_callback ( self , callable_ , inCallbackType = CallbackType . standard , inCallbackGroup = None ) : self . callback . append ( callbackEntry ( callable_ , inCallbackType , inCallbackGroup ) ) # If already completed or cancelled, execute it immediately if self . _ended ( ) : self . callback [ - 1 ] . func ( self ) | Attach a callable to the future that will be called when the future is cancelled or finishes running . Callable will be called with the future as its only argument . | 82 | 33 |
242,797 | def append ( self , future ) : if future . _ended ( ) and future . index is None : self . inprogress . add ( future ) elif future . _ended ( ) and future . index is not None : self . ready . append ( future ) elif future . greenlet is not None : self . inprogress . add ( future ) else : self . movable . append ( future ) # Send the oldest future in the movable deque until under the hwm over_hwm = self . timelen ( self . movable ) > self . highwatermark while over_hwm and len ( self . movable ) > 1 : sending_future = self . movable . popleft ( ) if sending_future . id [ 0 ] != scoop . worker : sending_future . _delete ( ) self . socket . sendFuture ( sending_future ) over_hwm = self . timelen ( self . movable ) > self . highwatermark | Append a future to the queue . | 208 | 8 |
242,798 | def askForPreviousFutures ( self ) : # Don't request it too often (otherwise it ping-pongs because) # the broker answer triggers the _poll of pop() if time . time ( ) < self . lastStatus + POLLING_TIME / 1000 : return self . lastStatus = time . time ( ) for future in scoop . _control . futureDict . values ( ) : # Skip the root future if scoop . IS_ORIGIN and future . id == ( scoop . worker , 0 ) : continue if future not in self . inprogress : self . socket . sendStatusRequest ( future ) | Request a status for every future to the broker . | 132 | 10 |
242,799 | def pop ( self ) : self . updateQueue ( ) # If our buffer is underflowing, request more Futures if self . timelen ( self ) < self . lowwatermark : self . requestFuture ( ) # If an unmovable Future is ready to be executed, return it if len ( self . ready ) != 0 : return self . ready . popleft ( ) # Then, use Futures in the movable queue elif len ( self . movable ) != 0 : return self . movable . popleft ( ) else : # Otherwise, block until a new task arrives self . lastStatus = time . time ( ) while len ( self ) == 0 : # Block until message arrives self . askForPreviousFutures ( ) self . socket . _poll ( POLLING_TIME ) self . updateQueue ( ) if len ( self . ready ) != 0 : return self . ready . popleft ( ) elif len ( self . movable ) != 0 : return self . movable . popleft ( ) | Pop the next future from the queue ; in progress futures have priority over those that have not yet started ; higher level futures have priority over lower level ones ; | 221 | 31 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.