idx int64 0 63k | question stringlengths 61 4.03k | target stringlengths 6 1.23k |
|---|---|---|
6,100 | def prepareInsert ( self , oself , store ) : if self . relative : fspath = self . __get__ ( oself ) oself . __dirty__ [ self . attrname ] = self , self . infilter ( fspath , oself , store ) | Prepare for insertion into the database by making the dbunderlying attribute of the item a relative pathname with respect to the store rather than an absolute pathname . |
6,101 | def restore ( self , time = None ) : if self . deleted : time = time if time else self . deleted_at if time == self . deleted_at : self . deleted = False self . save ( ) return True else : return False return False | Undeletes the object . Returns True if undeleted False if it was already not deleted |
6,102 | def full_restore ( self , using = None ) : using = using or router . db_for_write ( self . __class__ , instance = self ) restore_counter = Counter ( ) if self . deleted : time = self . deleted_at else : return restore_counter self . collector = models . deletion . Collector ( using = using ) self . collector . collect ( [ self ] ) for model , instances in self . collector . data . items ( ) : instances_to_delete = sorted ( instances , key = attrgetter ( "pk" ) ) self . sort ( ) for qs in self . collector . fast_deletes : for qs_instance in qs : restore_counter . update ( [ qs_instance . _meta . model_name ] ) qs_instance . restore ( time = time ) for model , instances in self . collector . data . items ( ) : for instance in instances : restore_counter . update ( [ instance . _meta . model_name ] ) instance . restore ( time = time ) return sum ( restore_counter . values ( ) ) , dict ( restore_counter ) self . collector = models . deletion . Collector ( using = using ) self . collector . collect ( [ self ] , keep_parents = keep_parents ) | Restores itself as well as objects that might have been deleted along with it if cascade is the deletion strategy |
6,103 | def connect_to_ec2 ( region = 'us-east-1' , access_key = None , secret_key = None ) : if access_key : logger . info ( 'Connecting to AWS EC2 in {}' . format ( region ) ) connection = ec2 . connect_to_region ( region , aws_access_key_id = access_key , aws_secret_access_key = secret_key ) else : metadata = get_instance_metadata ( timeout = 1 , num_retries = 1 ) if metadata : try : region = metadata [ 'placement' ] [ 'availability-zone' ] [ : - 1 ] except KeyError : pass logger . info ( 'Connecting to AWS EC2 in {}' . format ( region ) ) connection = ec2 . connect_to_region ( region ) if not connection : logger . error ( 'An error occurred when connecting to EC2' ) sys . exit ( 1 ) return connection | Connect to AWS ec2 |
6,104 | def parse ( self , output ) : output = self . _get_lines_with_stems ( output ) words = self . _make_unique ( output ) return self . _parse_for_simple_stems ( words ) | Find stems for a given text . |
6,105 | def validlocations ( configuration = None ) : if Locations . _validlocations is None : if configuration is None : configuration = Configuration . read ( ) Locations . _validlocations = configuration . call_remoteckan ( 'group_list' , { 'all_fields' : True } ) return Locations . _validlocations | Read valid locations from HDX |
6,106 | def get_location_from_HDX_code ( code , locations = None , configuration = None ) : if locations is None : locations = Locations . validlocations ( configuration ) for locdict in locations : if code . upper ( ) == locdict [ 'name' ] . upper ( ) : return locdict [ 'title' ] return None | Get location from HDX location code |
6,107 | def CheckDirectory ( self , path , extension = 'yaml' ) : result = True if extension : glob_spec = os . path . join ( path , '*.{0:s}' . format ( extension ) ) else : glob_spec = os . path . join ( path , '*' ) for definition_file in sorted ( glob . glob ( glob_spec ) ) : if not self . CheckFile ( definition_file ) : result = False return result | Validates definition files in a directory . |
6,108 | def CheckFile ( self , path ) : print ( 'Checking: {0:s}' . format ( path ) ) definitions_registry = registry . DataTypeDefinitionsRegistry ( ) definitions_reader = reader . YAMLDataTypeDefinitionsFileReader ( ) result = False try : definitions_reader . ReadFile ( definitions_registry , path ) result = True except KeyError as exception : logging . warning ( ( 'Unable to register data type definition in file: {0:s} with ' 'error: {1:s}' ) . format ( path , exception ) ) except errors . FormatError as exception : logging . warning ( 'Unable to validate file: {0:s} with error: {1:s}' . format ( path , exception ) ) return result | Validates the definition in a file . |
6,109 | def inline_css ( html_message , encoding = 'unicode' ) : document = etree . HTML ( html_message ) converter = Conversion ( ) converter . perform ( document , html_message , '' , encoding = encoding ) return converter . convertedHTML | Inlines all CSS in an HTML string |
6,110 | def _CheckByteStreamSize ( self , byte_stream , byte_offset , data_type_size ) : try : byte_stream_size = len ( byte_stream ) except Exception as exception : raise errors . MappingError ( exception ) if byte_stream_size - byte_offset < data_type_size : raise errors . ByteStreamTooSmallError ( 'Byte stream too small requested: {0:d} available: {1:d}' . format ( data_type_size , byte_stream_size ) ) | Checks if the byte stream is large enough for the data type . |
6,111 | def _GetByteStreamOperation ( self ) : byte_order_string = self . GetStructByteOrderString ( ) format_string = self . GetStructFormatString ( ) if not format_string : return None format_string = '' . join ( [ byte_order_string , format_string ] ) return byte_operations . StructOperation ( format_string ) | Retrieves the byte stream operation . |
6,112 | def FoldValue ( self , value ) : if value is False and self . _data_type_definition . false_value is not None : return self . _data_type_definition . false_value if value is True and self . _data_type_definition . true_value is not None : return self . _data_type_definition . true_value raise ValueError ( 'No matching True and False values' ) | Folds the data type into a value . |
6,113 | def _CalculateElementsDataSize ( self , context ) : elements_data_size = None if self . _HasElementsDataSize ( ) : elements_data_size = self . _EvaluateElementsDataSize ( context ) elif self . _HasNumberOfElements ( ) : element_byte_size = self . _element_data_type_definition . GetByteSize ( ) if element_byte_size is not None : number_of_elements = self . _EvaluateNumberOfElements ( context ) elements_data_size = number_of_elements * element_byte_size return elements_data_size | Calculates the elements data size . |
6,114 | def _EvaluateElementsDataSize ( self , context ) : elements_data_size = None if self . _data_type_definition . elements_data_size : elements_data_size = self . _data_type_definition . elements_data_size elif self . _data_type_definition . elements_data_size_expression : expression = self . _data_type_definition . elements_data_size_expression namespace = { } if context and context . values : namespace . update ( context . values ) namespace [ '__builtins__' ] = { } try : elements_data_size = eval ( expression , namespace ) except Exception as exception : raise errors . MappingError ( 'Unable to determine elements data size with error: {0!s}' . format ( exception ) ) if elements_data_size is None or elements_data_size < 0 : raise errors . MappingError ( 'Invalid elements data size: {0!s}' . format ( elements_data_size ) ) return elements_data_size | Evaluates elements data size . |
6,115 | def _EvaluateNumberOfElements ( self , context ) : number_of_elements = None if self . _data_type_definition . number_of_elements : number_of_elements = self . _data_type_definition . number_of_elements elif self . _data_type_definition . number_of_elements_expression : expression = self . _data_type_definition . number_of_elements_expression namespace = { } if context and context . values : namespace . update ( context . values ) namespace [ '__builtins__' ] = { } try : number_of_elements = eval ( expression , namespace ) except Exception as exception : raise errors . MappingError ( 'Unable to determine number of elements with error: {0!s}' . format ( exception ) ) if number_of_elements is None or number_of_elements < 0 : raise errors . MappingError ( 'Invalid number of elements: {0!s}' . format ( number_of_elements ) ) return number_of_elements | Evaluates number of elements . |
6,116 | def _GetElementDataTypeDefinition ( self , data_type_definition ) : if not data_type_definition : raise errors . FormatError ( 'Missing data type definition' ) element_data_type_definition = getattr ( data_type_definition , 'element_data_type_definition' , None ) if not element_data_type_definition : raise errors . FormatError ( 'Invalid data type definition missing element' ) return element_data_type_definition | Retrieves the element data type definition . |
6,117 | def _CheckCompositeMap ( self , data_type_definition ) : if not data_type_definition : raise errors . FormatError ( 'Missing data type definition' ) members = getattr ( data_type_definition , 'members' , None ) if not members : raise errors . FormatError ( 'Invalid data type definition missing members' ) is_composite_map = False last_member_byte_order = data_type_definition . byte_order for member_definition in members : if member_definition . IsComposite ( ) : is_composite_map = True break if ( last_member_byte_order != definitions . BYTE_ORDER_NATIVE and member_definition . byte_order != definitions . BYTE_ORDER_NATIVE and last_member_byte_order != member_definition . byte_order ) : is_composite_map = True break last_member_byte_order = member_definition . byte_order return is_composite_map | Determines if the data type definition needs a composite map . |
6,118 | def _GetMemberDataTypeMaps ( self , data_type_definition , data_type_map_cache ) : if not data_type_definition : raise errors . FormatError ( 'Missing data type definition' ) members = getattr ( data_type_definition , 'members' , None ) if not members : raise errors . FormatError ( 'Invalid data type definition missing members' ) data_type_maps = [ ] members_data_size = 0 for member_definition in members : if isinstance ( member_definition , data_types . MemberDataTypeDefinition ) : member_definition = member_definition . member_data_type_definition if ( data_type_definition . byte_order != definitions . BYTE_ORDER_NATIVE and member_definition . byte_order == definitions . BYTE_ORDER_NATIVE ) : member_definition = copy . copy ( member_definition ) member_definition . name = '_{0:s}_{1:s}' . format ( data_type_definition . name , member_definition . name ) member_definition . byte_order = data_type_definition . byte_order if member_definition . name not in data_type_map_cache : data_type_map = DataTypeMapFactory . CreateDataTypeMapByType ( member_definition ) data_type_map_cache [ member_definition . name ] = data_type_map data_type_map = data_type_map_cache [ member_definition . name ] if members_data_size is not None : if not isinstance ( member_definition , data_types . PaddingDefinition ) : byte_size = member_definition . GetByteSize ( ) else : _ , byte_size = divmod ( members_data_size , member_definition . alignment_size ) if byte_size > 0 : byte_size = member_definition . alignment_size - byte_size data_type_map . byte_size = byte_size if byte_size is None : members_data_size = None else : members_data_size += byte_size data_type_maps . append ( data_type_map ) return data_type_maps | Retrieves the member data type maps . |
6,119 | def GetName ( self , number ) : value = self . _data_type_definition . values_per_number . get ( number , None ) if not value : return None return value . name | Retrieves the name of an enumeration value by number . |
6,120 | def CreateDataTypeMap ( self , definition_name ) : data_type_definition = self . _definitions_registry . GetDefinitionByName ( definition_name ) if not data_type_definition : return None return DataTypeMapFactory . CreateDataTypeMapByType ( data_type_definition ) | Creates a specific data type map by name . |
6,121 | def CreateDataTypeMapByType ( cls , data_type_definition ) : data_type_map_class = cls . _MAP_PER_DEFINITION . get ( data_type_definition . TYPE_INDICATOR , None ) if not data_type_map_class : return None return data_type_map_class ( data_type_definition ) | Creates a specific data type map by type indicator . |
6,122 | def IsComposite ( self ) : return bool ( self . condition ) or ( self . member_data_type_definition and self . member_data_type_definition . IsComposite ( ) ) | Determines if the data type is composite . |
6,123 | def AddValue ( self , name , number , aliases = None , description = None ) : if name in self . values_per_name : raise KeyError ( 'Value with name: {0:s} already exists.' . format ( name ) ) if number in self . values_per_number : raise KeyError ( 'Value with number: {0!s} already exists.' . format ( number ) ) for alias in aliases or [ ] : if alias in self . values_per_alias : raise KeyError ( 'Value with alias: {0:s} already exists.' . format ( alias ) ) enumeration_value = EnumerationValue ( name , number , aliases = aliases , description = description ) self . values . append ( enumeration_value ) self . values_per_name [ name ] = enumeration_value self . values_per_number [ number ] = enumeration_value for alias in aliases or [ ] : self . values_per_alias [ alias ] = enumeration_value | Adds an enumeration value . |
6,124 | def _ReadBooleanDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : return self . _ReadFixedSizeDataTypeDefinition ( definitions_registry , definition_values , data_types . BooleanDefinition , definition_name , self . _SUPPORTED_ATTRIBUTES_BOOLEAN , is_member = is_member , supported_size_values = ( 1 , 2 , 4 ) ) | Reads a boolean data type definition . |
6,125 | def _ReadCharacterDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : return self . _ReadFixedSizeDataTypeDefinition ( definitions_registry , definition_values , data_types . CharacterDefinition , definition_name , self . _SUPPORTED_ATTRIBUTES_FIXED_SIZE_DATA_TYPE , is_member = is_member , supported_size_values = ( 1 , 2 , 4 ) ) | Reads a character data type definition . |
6,126 | def _ReadConstantDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : error_message = 'data type not supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) value = definition_values . get ( 'value' , None ) if value is None : error_message = 'missing value' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object = self . _ReadSemanticDataTypeDefinition ( definitions_registry , definition_values , data_types . ConstantDefinition , definition_name , self . _SUPPORTED_DEFINITION_VALUES_CONSTANT ) definition_object . value = value return definition_object | Reads a constant data type definition . |
6,127 | def _ReadDataTypeDefinitionWithMembers ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supports_conditions = False ) : members = definition_values . get ( 'members' , None ) if not members : error_message = 'missing members' raise errors . DefinitionReaderError ( definition_name , error_message ) supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_STORAGE_DATA_TYPE_WITH_MEMBERS ) definition_object = self . _ReadDataTypeDefinition ( definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) attributes = definition_values . get ( 'attributes' , None ) if attributes : unsupported_attributes = set ( attributes . keys ( ) ) . difference ( self . _SUPPORTED_ATTRIBUTES_STORAGE_DATA_TYPE ) if unsupported_attributes : error_message = 'unsupported attributes: {0:s}' . format ( ', ' . join ( unsupported_attributes ) ) raise errors . DefinitionReaderError ( definition_name , error_message ) byte_order = attributes . get ( 'byte_order' , definitions . BYTE_ORDER_NATIVE ) if byte_order not in definitions . BYTE_ORDERS : error_message = 'unsupported byte-order attribute: {0!s}' . format ( byte_order ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . byte_order = byte_order for member in members : section = member . get ( 'section' , None ) if section : member_section_definition = data_types . MemberSectionDefinition ( section ) definition_object . AddSectionDefinition ( member_section_definition ) else : member_data_type_definition = self . _ReadMemberDataTypeDefinitionMember ( definitions_registry , member , definition_object . name , supports_conditions = supports_conditions ) definition_object . AddMemberDefinition ( member_data_type_definition ) return definition_object | Reads a data type definition with members . |
6,128 | def _ReadEnumerationDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : error_message = 'data type not supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) values = definition_values . get ( 'values' ) if not values : error_message = 'missing values' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object = self . _ReadSemanticDataTypeDefinition ( definitions_registry , definition_values , data_types . EnumerationDefinition , definition_name , self . _SUPPORTED_DEFINITION_VALUES_ENUMERATION ) last_name = None for enumeration_value in values : aliases = enumeration_value . get ( 'aliases' , None ) description = enumeration_value . get ( 'description' , None ) name = enumeration_value . get ( 'name' , None ) number = enumeration_value . get ( 'number' , None ) if not name or number is None : if last_name : error_location = 'after: {0:s}' . format ( last_name ) else : error_location = 'at start' error_message = '{0:s} missing name or number' . format ( error_location ) raise errors . DefinitionReaderError ( definition_name , error_message ) else : try : definition_object . AddValue ( name , number , aliases = aliases , description = description ) except KeyError as exception : error_message = '{0!s}' . format ( exception ) raise errors . DefinitionReaderError ( definition_name , error_message ) last_name = name return definition_object | Reads an enumeration data type definition . |
6,129 | def _ReadElementSequenceDataTypeDefinition ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) : unsupported_definition_values = set ( definition_values . keys ( ) ) . difference ( supported_definition_values ) if unsupported_definition_values : error_message = 'unsupported definition values: {0:s}' . format ( ', ' . join ( unsupported_definition_values ) ) raise errors . DefinitionReaderError ( definition_name , error_message ) element_data_type = definition_values . get ( 'element_data_type' , None ) if not element_data_type : error_message = 'missing element data type' raise errors . DefinitionReaderError ( definition_name , error_message ) elements_data_size = definition_values . get ( 'elements_data_size' , None ) elements_terminator = definition_values . get ( 'elements_terminator' , None ) number_of_elements = definition_values . get ( 'number_of_elements' , None ) size_values = ( elements_data_size , elements_terminator , number_of_elements ) size_values = [ value for value in size_values if value is not None ] if not size_values : error_message = ( 'missing element data size, elements terminator and number of ' 'elements' ) raise errors . DefinitionReaderError ( definition_name , error_message ) if len ( size_values ) > 1 : error_message = ( 'element data size, elements terminator and number of elements ' 'not allowed to be set at the same time' ) raise errors . DefinitionReaderError ( definition_name , error_message ) element_data_type_definition = definitions_registry . GetDefinitionByName ( element_data_type ) if not element_data_type_definition : error_message = 'undefined element data type: {0:s}.' . format ( element_data_type ) raise errors . DefinitionReaderError ( definition_name , error_message ) element_byte_size = element_data_type_definition . GetByteSize ( ) element_type_indicator = element_data_type_definition . TYPE_INDICATOR if not element_byte_size and element_type_indicator != ( definitions . TYPE_INDICATOR_STRING ) : error_message = ( 'unsupported variable size element data type: {0:s}' . format ( element_data_type ) ) raise errors . DefinitionReaderError ( definition_name , error_message ) aliases = definition_values . get ( 'aliases' , None ) description = definition_values . get ( 'description' , None ) urls = definition_values . get ( 'urls' , None ) definition_object = data_type_definition_class ( definition_name , element_data_type_definition , aliases = aliases , data_type = element_data_type , description = description , urls = urls ) if elements_data_size is not None : try : definition_object . elements_data_size = int ( elements_data_size ) except ValueError : definition_object . elements_data_size_expression = elements_data_size elif elements_terminator is not None : if isinstance ( elements_terminator , py2to3 . UNICODE_TYPE ) : elements_terminator = elements_terminator . encode ( 'ascii' ) definition_object . elements_terminator = elements_terminator elif number_of_elements is not None : try : definition_object . number_of_elements = int ( number_of_elements ) except ValueError : definition_object . number_of_elements_expression = number_of_elements return definition_object | Reads an element sequence data type definition . |
6,130 | def _ReadFixedSizeDataTypeDefinition ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supported_attributes , default_size = definitions . SIZE_NATIVE , default_units = 'bytes' , is_member = False , supported_size_values = None ) : definition_object = self . _ReadStorageDataTypeDefinition ( definitions_registry , definition_values , data_type_definition_class , definition_name , supported_attributes , is_member = is_member ) attributes = definition_values . get ( 'attributes' , None ) if attributes : size = attributes . get ( 'size' , default_size ) if size != definitions . SIZE_NATIVE : try : int ( size ) except ValueError : error_message = 'unuspported size attribute: {0!s}' . format ( size ) raise errors . DefinitionReaderError ( definition_name , error_message ) if supported_size_values and size not in supported_size_values : error_message = 'unuspported size value: {0!s}' . format ( size ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . size = size definition_object . units = attributes . get ( 'units' , default_units ) return definition_object | Reads a fixed - size data type definition . |
6,131 | def _ReadFloatingPointDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : return self . _ReadFixedSizeDataTypeDefinition ( definitions_registry , definition_values , data_types . FloatingPointDefinition , definition_name , self . _SUPPORTED_ATTRIBUTES_FIXED_SIZE_DATA_TYPE , is_member = is_member , supported_size_values = ( 4 , 8 ) ) | Reads a floating - point data type definition . |
6,132 | def _ReadFormatDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : error_message = 'data type not supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object = self . _ReadLayoutDataTypeDefinition ( definitions_registry , definition_values , data_types . FormatDefinition , definition_name , self . _SUPPORTED_DEFINITION_VALUES_FORMAT ) definition_object . metadata = definition_values . get ( 'metadata' , { } ) attributes = definition_values . get ( 'attributes' , None ) if attributes : unsupported_attributes = set ( attributes . keys ( ) ) . difference ( self . _SUPPORTED_ATTRIBUTES_FORMAT ) if unsupported_attributes : error_message = 'unsupported attributes: {0:s}' . format ( ', ' . join ( unsupported_attributes ) ) raise errors . DefinitionReaderError ( definition_name , error_message ) byte_order = attributes . get ( 'byte_order' , definitions . BYTE_ORDER_NATIVE ) if byte_order not in definitions . BYTE_ORDERS : error_message = 'unsupported byte-order attribute: {0!s}' . format ( byte_order ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . byte_order = byte_order return definition_object | Reads a format data type definition . |
6,133 | def _ReadIntegerDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : definition_object = self . _ReadFixedSizeDataTypeDefinition ( definitions_registry , definition_values , data_types . IntegerDefinition , definition_name , self . _SUPPORTED_ATTRIBUTES_INTEGER , is_member = is_member , supported_size_values = ( 1 , 2 , 4 , 8 ) ) attributes = definition_values . get ( 'attributes' , None ) if attributes : format_attribute = attributes . get ( 'format' , definitions . FORMAT_SIGNED ) if format_attribute not in self . _INTEGER_FORMAT_ATTRIBUTES : error_message = 'unsupported format attribute: {0!s}' . format ( format_attribute ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . format = format_attribute return definition_object | Reads an integer data type definition . |
6,134 | def _ReadLayoutDataTypeDefinition ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) : return self . _ReadDataTypeDefinition ( definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) | Reads a layout data type definition . |
6,135 | def _ReadPaddingDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if not is_member : error_message = 'data type only supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object = self . _ReadDataTypeDefinition ( definitions_registry , definition_values , data_types . PaddingDefinition , definition_name , self . _SUPPORTED_DEFINITION_VALUES_PADDING ) alignment_size = definition_values . get ( 'alignment_size' , None ) if not alignment_size : error_message = 'missing alignment_size' raise errors . DefinitionReaderError ( definition_name , error_message ) try : int ( alignment_size ) except ValueError : error_message = 'unuspported alignment size attribute: {0!s}' . format ( alignment_size ) raise errors . DefinitionReaderError ( definition_name , error_message ) if alignment_size not in ( 2 , 4 , 8 , 16 ) : error_message = 'unuspported alignment size value: {0!s}' . format ( alignment_size ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . alignment_size = alignment_size return definition_object | Reads a padding data type definition . |
6,136 | def _ReadSemanticDataTypeDefinition ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) : return self . _ReadDataTypeDefinition ( definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) | Reads a semantic data type definition . |
6,137 | def _ReadSequenceDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_ELEMENTS_MEMBER_DATA_TYPE ) else : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_ELEMENTS_DATA_TYPE ) return self . _ReadElementSequenceDataTypeDefinition ( definitions_registry , definition_values , data_types . SequenceDefinition , definition_name , supported_definition_values ) | Reads a sequence data type definition . |
6,138 | def _ReadStorageDataTypeDefinition ( self , definitions_registry , definition_values , data_type_definition_class , definition_name , supported_attributes , is_member = False ) : if is_member : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_MEMBER_DATA_TYPE ) else : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_STORAGE_DATA_TYPE ) definition_object = self . _ReadDataTypeDefinition ( definitions_registry , definition_values , data_type_definition_class , definition_name , supported_definition_values ) attributes = definition_values . get ( 'attributes' , None ) if attributes : unsupported_attributes = set ( attributes . keys ( ) ) . difference ( supported_attributes ) if unsupported_attributes : error_message = 'unsupported attributes: {0:s}' . format ( ', ' . join ( unsupported_attributes ) ) raise errors . DefinitionReaderError ( definition_name , error_message ) byte_order = attributes . get ( 'byte_order' , definitions . BYTE_ORDER_NATIVE ) if byte_order not in definitions . BYTE_ORDERS : error_message = 'unsupported byte-order attribute: {0!s}' . format ( byte_order ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . byte_order = byte_order return definition_object | Reads a storage data type definition . |
6,139 | def _ReadStreamDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_ELEMENTS_MEMBER_DATA_TYPE ) else : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_ELEMENTS_DATA_TYPE ) return self . _ReadElementSequenceDataTypeDefinition ( definitions_registry , definition_values , data_types . StreamDefinition , definition_name , supported_definition_values ) | Reads a stream data type definition . |
6,140 | def _ReadStringDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : supported_definition_values = ( self . _SUPPORTED_DEFINITION_VALUES_STRING_MEMBER ) else : supported_definition_values = self . _SUPPORTED_DEFINITION_VALUES_STRING definition_object = self . _ReadElementSequenceDataTypeDefinition ( definitions_registry , definition_values , data_types . StringDefinition , definition_name , supported_definition_values ) encoding = definition_values . get ( 'encoding' , None ) if not encoding : error_message = 'missing encoding' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . encoding = encoding return definition_object | Reads a string data type definition . |
6,141 | def _ReadStructureDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : error_message = 'data type not supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) return self . _ReadDataTypeDefinitionWithMembers ( definitions_registry , definition_values , data_types . StructureDefinition , definition_name , supports_conditions = True ) | Reads a structure data type definition . |
6,142 | def _ReadStructureFamilyDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : if is_member : error_message = 'data type not supported as member' raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object = self . _ReadLayoutDataTypeDefinition ( definitions_registry , definition_values , data_types . StructureFamilyDefinition , definition_name , self . _SUPPORTED_DEFINITION_VALUES_STRUCTURE_FAMILY ) runtime = definition_values . get ( 'runtime' , None ) if not runtime : error_message = 'missing runtime' raise errors . DefinitionReaderError ( definition_name , error_message ) runtime_data_type_definition = definitions_registry . GetDefinitionByName ( runtime ) if not runtime_data_type_definition : error_message = 'undefined runtime: {0:s}.' . format ( runtime ) raise errors . DefinitionReaderError ( definition_name , error_message ) if runtime_data_type_definition . family_definition : error_message = 'runtime: {0:s} already part of a family.' . format ( runtime ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . AddRuntimeDefinition ( runtime_data_type_definition ) members = definition_values . get ( 'members' , None ) if not members : error_message = 'missing members' raise errors . DefinitionReaderError ( definition_name , error_message ) for member in members : member_data_type_definition = definitions_registry . GetDefinitionByName ( member ) if not member_data_type_definition : error_message = 'undefined member: {0:s}.' . format ( member ) raise errors . DefinitionReaderError ( definition_name , error_message ) if member_data_type_definition . family_definition : error_message = 'member: {0:s} already part of a family.' . format ( member ) raise errors . DefinitionReaderError ( definition_name , error_message ) definition_object . AddMemberDefinition ( member_data_type_definition ) return definition_object | Reads a structure family data type definition . |
6,143 | def _ReadUnionDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : return self . _ReadDataTypeDefinitionWithMembers ( definitions_registry , definition_values , data_types . UnionDefinition , definition_name , supports_conditions = False ) | Reads an union data type definition . |
6,144 | def _ReadUUIDDataTypeDefinition ( self , definitions_registry , definition_values , definition_name , is_member = False ) : return self . _ReadFixedSizeDataTypeDefinition ( definitions_registry , definition_values , data_types . UUIDDefinition , definition_name , self . _SUPPORTED_ATTRIBUTES_FIXED_SIZE_DATA_TYPE , default_size = 16 , is_member = is_member , supported_size_values = ( 16 , ) ) | Reads an UUID data type definition . |
6,145 | def ReadFile ( self , definitions_registry , path ) : with open ( path , 'r' ) as file_object : self . ReadFileObject ( definitions_registry , file_object ) | Reads data type definitions from a file into the registry . |
6,146 | def _GetFormatErrorLocation ( self , yaml_definition , last_definition_object ) : name = yaml_definition . get ( 'name' , None ) if name : error_location = 'in: {0:s}' . format ( name or '<NAMELESS>' ) elif last_definition_object : error_location = 'after: {0:s}' . format ( last_definition_object . name ) else : error_location = 'at start' return error_location | Retrieves a format error location . |
6,147 | def ReadFileObject ( self , definitions_registry , file_object ) : last_definition_object = None error_location = None error_message = None try : yaml_generator = yaml . safe_load_all ( file_object ) for yaml_definition in yaml_generator : definition_object = self . _ReadDefinition ( definitions_registry , yaml_definition ) if not definition_object : error_location = self . _GetFormatErrorLocation ( yaml_definition , last_definition_object ) error_message = '{0:s} Missing definition object.' . format ( error_location ) raise errors . FormatError ( error_message ) definitions_registry . RegisterDefinition ( definition_object ) last_definition_object = definition_object except errors . DefinitionReaderError as exception : error_message = 'in: {0:s} {1:s}' . format ( exception . name or '<NAMELESS>' , exception . message ) raise errors . FormatError ( error_message ) except ( yaml . reader . ReaderError , yaml . scanner . ScannerError ) as exception : error_location = self . _GetFormatErrorLocation ( { } , last_definition_object ) error_message = '{0:s} {1!s}' . format ( error_location , exception ) raise errors . FormatError ( error_message ) | Reads data type definitions from a file - like object into the registry . |
6,148 | def read_from_hdx ( identifier , configuration = None ) : organization = Organization ( configuration = configuration ) result = organization . _load_from_hdx ( 'organization' , identifier ) if result : return organization return None | Reads the organization given by identifier from HDX and returns Organization object |
6,149 | def get_users ( self , capacity = None ) : users = list ( ) usersdicts = self . data . get ( 'users' ) if usersdicts is not None : for userdata in usersdicts : if capacity is not None and userdata [ 'capacity' ] != capacity : continue id = userdata . get ( 'id' ) if id is None : id = userdata [ 'name' ] user = hdx . data . user . User . read_from_hdx ( id , configuration = self . configuration ) user [ 'capacity' ] = userdata [ 'capacity' ] users . append ( user ) return users | Returns the organization s users . |
6,150 | def get_datasets ( self , query = '*:*' , ** kwargs ) : return hdx . data . dataset . Dataset . search_in_hdx ( query = query , configuration = self . configuration , fq = 'organization:%s' % self . data [ 'name' ] , ** kwargs ) | Get list of datasets in organization |
6,151 | def get_all_organization_names ( configuration = None , ** kwargs ) : organization = Organization ( configuration = configuration ) organization [ 'id' ] = 'all organizations' return organization . _write_to_hdx ( 'list' , kwargs , 'id' ) | Get all organization names in HDX |
6,152 | def _read_from_hdx ( self , object_type , value , fieldname = 'id' , action = None , ** kwargs ) : if not fieldname : raise HDXError ( 'Empty %s field name!' % object_type ) if action is None : action = self . actions ( ) [ 'show' ] data = { fieldname : value } data . update ( kwargs ) try : result = self . configuration . call_remoteckan ( action , data ) return True , result except NotFound : return False , '%s=%s: not found!' % ( fieldname , value ) except Exception as e : raisefrom ( HDXError , 'Failed when trying to read: %s=%s! (POST)' % ( fieldname , value ) , e ) | Makes a read call to HDX passing in given parameter . |
6,153 | def _load_from_hdx ( self , object_type , id_field ) : success , result = self . _read_from_hdx ( object_type , id_field ) if success : self . old_data = self . data self . data = result return True logger . debug ( result ) return False | Helper method to load the HDX object given by identifier from HDX |
6,154 | def _check_load_existing_object ( self , object_type , id_field_name , operation = 'update' ) : self . _check_existing_object ( object_type , id_field_name ) if not self . _load_from_hdx ( object_type , self . data [ id_field_name ] ) : raise HDXError ( 'No existing %s to %s!' % ( object_type , operation ) ) | Check metadata exists and contains HDX object identifier and if so load HDX object |
6,155 | def _check_required_fields ( self , object_type , ignore_fields ) : for field in self . configuration [ object_type ] [ 'required_fields' ] : if field not in self . data and field not in ignore_fields : raise HDXError ( 'Field %s is missing in %s!' % ( field , object_type ) ) | Helper method to check that metadata for HDX object is complete |
6,156 | def _merge_hdx_update ( self , object_type , id_field_name , file_to_upload = None , ** kwargs ) : merge_two_dictionaries ( self . data , self . old_data ) if 'batch_mode' in kwargs : self . data [ 'batch_mode' ] = kwargs [ 'batch_mode' ] if 'skip_validation' in kwargs : self . data [ 'skip_validation' ] = kwargs [ 'skip_validation' ] ignore_field = self . configuration [ '%s' % object_type ] . get ( 'ignore_on_update' ) self . check_required_fields ( ignore_fields = [ ignore_field ] ) operation = kwargs . get ( 'operation' , 'update' ) self . _save_to_hdx ( operation , id_field_name , file_to_upload ) | Helper method to check if HDX object exists and update it |
6,157 | def _update_in_hdx ( self , object_type , id_field_name , file_to_upload = None , ** kwargs ) : self . _check_load_existing_object ( object_type , id_field_name ) self . _merge_hdx_update ( object_type , id_field_name , file_to_upload , ** kwargs ) | Helper method to check if HDX object exists in HDX and if so update it |
6,158 | def _write_to_hdx ( self , action , data , id_field_name , file_to_upload = None ) : file = None try : if file_to_upload : file = open ( file_to_upload , 'rb' ) files = [ ( 'upload' , file ) ] else : files = None return self . configuration . call_remoteckan ( self . actions ( ) [ action ] , data , files = files ) except Exception as e : raisefrom ( HDXError , 'Failed when trying to %s %s! (POST)' % ( action , data [ id_field_name ] ) , e ) finally : if file_to_upload and file : file . close ( ) | Creates or updates an HDX object in HDX and return HDX object metadata dict |
6,159 | def _save_to_hdx ( self , action , id_field_name , file_to_upload = None ) : result = self . _write_to_hdx ( action , self . data , id_field_name , file_to_upload ) self . old_data = self . data self . data = result | Creates or updates an HDX object in HDX saving current data and replacing with returned HDX object data from HDX |
6,160 | def _create_in_hdx ( self , object_type , id_field_name , name_field_name , file_to_upload = None ) : self . check_required_fields ( ) if id_field_name in self . data and self . _load_from_hdx ( object_type , self . data [ id_field_name ] ) : logger . warning ( '%s exists. Updating %s' % ( object_type , self . data [ id_field_name ] ) ) self . _merge_hdx_update ( object_type , id_field_name , file_to_upload ) else : self . _save_to_hdx ( 'create' , name_field_name , file_to_upload ) | Helper method to check if resource exists in HDX and if so update it otherwise create it |
6,161 | def _delete_from_hdx ( self , object_type , id_field_name ) : if id_field_name not in self . data : raise HDXError ( 'No %s field (mandatory) in %s!' % ( id_field_name , object_type ) ) self . _save_to_hdx ( 'delete' , id_field_name ) | Helper method to deletes a resource from HDX |
6,162 | def _addupdate_hdxobject ( self , hdxobjects , id_field , new_hdxobject ) : for hdxobject in hdxobjects : if hdxobject [ id_field ] == new_hdxobject [ id_field ] : merge_two_dictionaries ( hdxobject , new_hdxobject ) return hdxobject hdxobjects . append ( new_hdxobject ) return new_hdxobject | Helper function to add a new HDX object to a supplied list of HDX objects or update existing metadata if the object already exists in the list |
6,163 | def _remove_hdxobject ( self , objlist , obj , matchon = 'id' , delete = False ) : if objlist is None : return False if isinstance ( obj , six . string_types ) : obj_id = obj elif isinstance ( obj , dict ) or isinstance ( obj , HDXObject ) : obj_id = obj . get ( matchon ) else : raise HDXError ( 'Type of object not a string, dict or T<=HDXObject' ) if not obj_id : return False for i , objdata in enumerate ( objlist ) : objid = objdata . get ( matchon ) if objid and objid == obj_id : if delete : objlist [ i ] . delete_from_hdx ( ) del objlist [ i ] return True return False | Remove an HDX object from a list within the parent HDX object |
6,164 | def _convert_hdxobjects ( self , hdxobjects ) : newhdxobjects = list ( ) for hdxobject in hdxobjects : newhdxobjects . append ( hdxobject . data ) return newhdxobjects | Helper function to convert supplied list of HDX objects to a list of dict |
6,165 | def _copy_hdxobjects ( self , hdxobjects , hdxobjectclass , attribute_to_copy = None ) : newhdxobjects = list ( ) for hdxobject in hdxobjects : newhdxobjectdata = copy . deepcopy ( hdxobject . data ) newhdxobject = hdxobjectclass ( newhdxobjectdata , configuration = self . configuration ) if attribute_to_copy : value = getattr ( hdxobject , attribute_to_copy ) setattr ( newhdxobject , attribute_to_copy , value ) newhdxobjects . append ( newhdxobject ) return newhdxobjects | Helper function to make a deep copy of a supplied list of HDX objects |
6,166 | def _separate_hdxobjects ( self , hdxobjects , hdxobjects_name , id_field , hdxobjectclass ) : new_hdxobjects = self . data . get ( hdxobjects_name , list ( ) ) if new_hdxobjects : hdxobject_names = set ( ) for hdxobject in hdxobjects : hdxobject_name = hdxobject [ id_field ] hdxobject_names . add ( hdxobject_name ) for new_hdxobject in new_hdxobjects : if hdxobject_name == new_hdxobject [ id_field ] : merge_two_dictionaries ( hdxobject , new_hdxobject ) break for new_hdxobject in new_hdxobjects : if not new_hdxobject [ id_field ] in hdxobject_names : hdxobjects . append ( hdxobjectclass ( new_hdxobject , configuration = self . configuration ) ) del self . data [ hdxobjects_name ] | Helper function to take a list of HDX objects contained in the internal dictionary and add them to a supplied list of HDX objects or update existing metadata if any objects already exist in the list . The list in the internal dictionary is then deleted . |
6,167 | def _get_tags ( self ) : tags = self . data . get ( 'tags' , None ) if not tags : return list ( ) return [ x [ 'name' ] for x in tags ] | Return the dataset s list of tags |
6,168 | def _add_tag ( self , tag ) : tags = self . data . get ( 'tags' , None ) if tags : if tag in [ x [ 'name' ] for x in tags ] : return False else : tags = list ( ) tags . append ( { 'name' : tag } ) self . data [ 'tags' ] = tags return True | Add a tag |
6,169 | def _add_tags ( self , tags ) : alltagsadded = True for tag in tags : if not self . _add_tag ( tag ) : alltagsadded = False return alltagsadded | Add a list of tag |
6,170 | def _get_stringlist_from_commastring ( self , field ) : strings = self . data . get ( field ) if strings : return strings . split ( ',' ) else : return list ( ) | Return list of strings from comma separated list |
6,171 | def _add_string_to_commastring ( self , field , string ) : if string in self . _get_stringlist_from_commastring ( field ) : return False strings = '%s,%s' % ( self . data . get ( field , '' ) , string ) if strings [ 0 ] == ',' : strings = strings [ 1 : ] self . data [ field ] = strings return True | Add a string to a comma separated list of strings |
6,172 | def _add_strings_to_commastring ( self , field , strings ) : allstringsadded = True for string in strings : if not self . _add_string_to_commastring ( field , string ) : allstringsadded = False return allstringsadded | Add a list of strings to a comma separated list of strings |
6,173 | def _remove_string_from_commastring ( self , field , string ) : commastring = self . data . get ( field , '' ) if string in commastring : self . data [ field ] = commastring . replace ( string , '' ) return True return False | Remove a string from a comma separated list of strings |
6,174 | def read_from_hdx ( identifier , configuration = None ) : if is_valid_uuid ( identifier ) is False : raise HDXError ( '%s is not a valid resource id!' % identifier ) resource = Resource ( configuration = configuration ) result = resource . _load_from_hdx ( 'resource' , identifier ) if result : return resource return None | Reads the resource given by identifier from HDX and returns Resource object |
6,175 | def set_file_to_upload ( self , file_to_upload ) : if 'url' in self . data : del self . data [ 'url' ] self . file_to_upload = file_to_upload | Delete any existing url and set the file uploaded to the local path provided |
6,176 | def check_url_filetoupload ( self ) : if self . file_to_upload is None : if 'url' in self . data : if 'resource_type' not in self . data : self . data [ 'resource_type' ] = 'api' if 'url_type' not in self . data : self . data [ 'url_type' ] = 'api' else : raise HDXError ( 'Either a url or a file to upload must be supplied!' ) else : if 'url' in self . data : if self . data [ 'url' ] != hdx . data . dataset . Dataset . temporary_url : raise HDXError ( 'Either a url or a file to upload must be supplied not both!' ) if 'resource_type' not in self . data : self . data [ 'resource_type' ] = 'file.upload' if 'url_type' not in self . data : self . data [ 'url_type' ] = 'upload' if 'tracking_summary' in self . data : del self . data [ 'tracking_summary' ] | Check if url or file to upload provided for resource and add resource_type and url_type if not supplied |
6,177 | def update_in_hdx ( self , ** kwargs ) : self . _check_load_existing_object ( 'resource' , 'id' ) if self . file_to_upload and 'url' in self . data : del self . data [ 'url' ] self . _merge_hdx_update ( 'resource' , 'id' , self . file_to_upload , ** kwargs ) | Check if resource exists in HDX and if so update it |
6,178 | def create_in_hdx ( self ) : self . check_required_fields ( ) id = self . data . get ( 'id' ) if id and self . _load_from_hdx ( 'resource' , id ) : logger . warning ( '%s exists. Updating %s' % ( 'resource' , id ) ) if self . file_to_upload and 'url' in self . data : del self . data [ 'url' ] self . _merge_hdx_update ( 'resource' , 'id' , self . file_to_upload ) else : self . _save_to_hdx ( 'create' , 'name' , self . file_to_upload ) | Check if resource exists in HDX and if so update it otherwise create it |
6,179 | def get_dataset ( self ) : package_id = self . data . get ( 'package_id' ) if package_id is None : raise HDXError ( 'Resource has no package id!' ) return hdx . data . dataset . Dataset . read_from_hdx ( package_id ) | Return dataset containing this resource |
6,180 | def download ( self , folder = None ) : url = self . data . get ( 'url' , None ) if not url : raise HDXError ( 'No URL to download!' ) logger . debug ( 'Downloading %s' % url ) filename = self . data [ 'name' ] format = '.%s' % self . data [ 'format' ] if format not in filename : filename = '%s%s' % ( filename , format ) with Download ( full_agent = self . configuration . get_user_agent ( ) ) as downloader : path = downloader . download_file ( url , folder , filename ) return url , path | Download resource store to provided folder or temporary folder if no folder supplied |
6,181 | def get_all_resource_ids_in_datastore ( configuration = None ) : resource = Resource ( configuration = configuration ) success , result = resource . _read_from_hdx ( 'datastore' , '_table_metadata' , 'resource_id' , Resource . actions ( ) [ 'datastore_search' ] , limit = 10000 ) resource_ids = list ( ) if not success : logger . debug ( result ) else : for record in result [ 'records' ] : resource_ids . append ( record [ 'name' ] ) return resource_ids | Get list of resources that have a datastore returning their ids . |
6,182 | def has_datastore ( self ) : success , result = self . _read_from_hdx ( 'datastore' , self . data [ 'id' ] , 'resource_id' , self . actions ( ) [ 'datastore_search' ] ) if not success : logger . debug ( result ) else : if result : return True return False | Check if the resource has a datastore . |
6,183 | def delete_datastore ( self ) : success , result = self . _read_from_hdx ( 'datastore' , self . data [ 'id' ] , 'resource_id' , self . actions ( ) [ 'datastore_delete' ] , force = True ) if not success : logger . debug ( result ) | Delete a resource from the HDX datastore |
6,184 | def create_datastore ( self , schema = None , primary_key = None , delete_first = 0 , path = None ) : if delete_first == 0 : pass elif delete_first == 1 : self . delete_datastore ( ) elif delete_first == 2 : if primary_key is None : self . delete_datastore ( ) else : raise HDXError ( 'delete_first must be 0, 1 or 2! (0 = No, 1 = Yes, 2 = Delete if no primary key)' ) if path is None : url , path = self . download ( ) delete_after_download = True else : url = path delete_after_download = False def convert_to_text ( extended_rows ) : for number , headers , row in extended_rows : for i , val in enumerate ( row ) : row [ i ] = str ( val ) yield ( number , headers , row ) with Download ( full_agent = self . configuration . get_user_agent ( ) ) as downloader : try : stream = downloader . get_tabular_stream ( path , headers = 1 , post_parse = [ convert_to_text ] , bytes_sample_size = 1000000 ) nonefieldname = False if schema is None : schema = list ( ) for fieldname in stream . headers : if fieldname is not None : schema . append ( { 'id' : fieldname , 'type' : 'text' } ) else : nonefieldname = True data = { 'resource_id' : self . data [ 'id' ] , 'force' : True , 'fields' : schema , 'primary_key' : primary_key } self . _write_to_hdx ( 'datastore_create' , data , 'resource_id' ) if primary_key is None : method = 'insert' else : method = 'upsert' logger . debug ( 'Uploading data from %s to datastore' % url ) offset = 0 chunksize = 100 rowset = stream . read ( keyed = True , limit = chunksize ) while len ( rowset ) != 0 : if nonefieldname : for row in rowset : del row [ None ] data = { 'resource_id' : self . data [ 'id' ] , 'force' : True , 'method' : method , 'records' : rowset } self . _write_to_hdx ( 'datastore_upsert' , data , 'resource_id' ) rowset = stream . read ( keyed = True , limit = chunksize ) logger . debug ( 'Uploading: %s' % offset ) offset += chunksize except Exception as e : raisefrom ( HDXError , 'Upload to datastore of %s failed!' % url , e ) finally : if delete_after_download : remove ( path ) | For tabular data create a resource in the HDX datastore which enables data preview in HDX . If no schema is provided all fields are assumed to be text . If path is not supplied the file is first downloaded from HDX . |
6,185 | def create_datastore_for_topline ( self , delete_first = 0 , path = None ) : data = load_yaml ( script_dir_plus_file ( join ( '..' , 'hdx_datasource_topline.yml' ) , Resource ) ) self . create_datastore_from_dict_schema ( data , delete_first , path = path ) | For tabular data create a resource in the HDX datastore which enables data preview in HDX using the built in YAML definition for a topline . If path is not supplied the file is first downloaded from HDX . |
6,186 | def update_datastore ( self , schema = None , primary_key = None , path = None ) : self . create_datastore ( schema , primary_key , 2 , path = path ) | For tabular data update a resource in the HDX datastore which enables data preview in HDX . If no schema is provided all fields are assumed to be text . If path is not supplied the file is first downloaded from HDX . |
6,187 | def _get_resource_view ( self , resource_view ) : if isinstance ( resource_view , dict ) : resource_view = ResourceView ( resource_view , configuration = self . configuration ) if isinstance ( resource_view , ResourceView ) : return resource_view raise HDXError ( 'Type %s is not a valid resource view!' % type ( resource_view ) . __name__ ) | Get resource view id |
6,188 | def add_update_resource_views ( self , resource_views ) : if not isinstance ( resource_views , list ) : raise HDXError ( 'ResourceViews should be a list!' ) for resource_view in resource_views : self . add_update_resource_view ( resource_view ) | Add new or update existing resource views in resource with new metadata . |
6,189 | def reorder_resource_views ( self , resource_views ) : if not isinstance ( resource_views , list ) : raise HDXError ( 'ResourceViews should be a list!' ) ids = list ( ) for resource_view in resource_views : if isinstance ( resource_view , str ) : resource_view_id = resource_view else : resource_view_id = resource_view [ 'id' ] if is_valid_uuid ( resource_view_id ) is False : raise HDXError ( '%s is not a valid resource view id!' % resource_view ) ids . append ( resource_view_id ) _ , result = self . _read_from_hdx ( 'resource view' , self . data [ 'id' ] , 'id' , ResourceView . actions ( ) [ 'reorder' ] , order = ids ) | Order resource views in resource . |
6,190 | def delete_resource_view ( self , resource_view ) : if isinstance ( resource_view , str ) : if is_valid_uuid ( resource_view ) is False : raise HDXError ( '%s is not a valid resource view id!' % resource_view ) resource_view = ResourceView ( { 'id' : resource_view } , configuration = self . configuration ) else : resource_view = self . _get_resource_view ( resource_view ) if 'id' not in resource_view : found = False title = resource_view . get ( 'title' ) for rv in self . get_resource_views ( ) : if resource_view [ 'title' ] == rv [ 'title' ] : resource_view = rv found = True break if not found : raise HDXError ( 'No resource views have title %s in this resource!' % title ) resource_view . delete_from_hdx ( ) | Delete a resource view from the resource and HDX |
6,191 | def parse_for_simple_stems ( output , skip_empty = False , skip_same_stems = True ) : lines_with_stems = _get_lines_with_stems ( output ) stems = list ( ) last_word = None for line in lines_with_stems : word , stem , _ = line . split ( "\t" ) stem = stem if stem != '-' else None if skip_empty and ( stem is None ) : continue if last_word != word : stems . append ( ( word , [ ] ) ) stem = None if skip_same_stems and stem in stems [ - 1 ] [ 1 ] else stem if stem is not None : stems [ - 1 ] [ 1 ] . append ( stem ) last_word = word return stems | Parses the output stem lines to produce a list with possible stems for each word in the output . |
6,192 | def _CreateClassTemplate ( cls , data_type_definition ) : type_name = data_type_definition . name type_description = data_type_definition . description or type_name while type_description . endswith ( '.' ) : type_description = type_description [ : - 1 ] class_attributes_description = [ ] init_arguments = [ ] instance_attributes = [ ] for member_definition in data_type_definition . members : attribute_name = member_definition . name description = member_definition . description or attribute_name while description . endswith ( '.' ) : description = description [ : - 1 ] member_data_type = getattr ( member_definition , 'member_data_type' , '' ) if isinstance ( member_definition , data_types . MemberDataTypeDefinition ) : member_definition = member_definition . member_data_type_definition member_type_indicator = member_definition . TYPE_INDICATOR if member_type_indicator == definitions . TYPE_INDICATOR_SEQUENCE : element_type_indicator = member_definition . element_data_type member_type_indicator = 'tuple[{0:s}]' . format ( element_type_indicator ) else : member_type_indicator = cls . _PYTHON_NATIVE_TYPES . get ( member_type_indicator , member_data_type ) argument = '{0:s}=None' . format ( attribute_name ) definition = ' self.{0:s} = {0:s}' . format ( attribute_name ) description = ' {0:s} ({1:s}): {2:s}.' . format ( attribute_name , member_type_indicator , description ) class_attributes_description . append ( description ) init_arguments . append ( argument ) instance_attributes . append ( definition ) class_attributes_description = '\n' . join ( sorted ( class_attributes_description ) ) init_arguments = ', ' . join ( init_arguments ) instance_attributes = '\n' . join ( sorted ( instance_attributes ) ) template_values = { 'class_attributes_description' : class_attributes_description , 'init_arguments' : init_arguments , 'instance_attributes' : instance_attributes , 'type_description' : type_description , 'type_name' : type_name } return cls . _CLASS_TEMPLATE . format ( ** template_values ) | Creates the class template . |
6,193 | def _IsIdentifier ( cls , string ) : return ( string and not string [ 0 ] . isdigit ( ) and all ( character . isalnum ( ) or character == '_' for character in string ) ) | Checks if a string contains an identifier . |
6,194 | def _ValidateDataTypeDefinition ( cls , data_type_definition ) : if not cls . _IsIdentifier ( data_type_definition . name ) : raise ValueError ( 'Data type definition name: {0!s} not a valid identifier' . format ( data_type_definition . name ) ) if keyword . iskeyword ( data_type_definition . name ) : raise ValueError ( 'Data type definition name: {0!s} matches keyword' . format ( data_type_definition . name ) ) members = getattr ( data_type_definition , 'members' , None ) if not members : raise ValueError ( 'Data type definition name: {0!s} missing members' . format ( data_type_definition . name ) ) defined_attribute_names = set ( ) for member_definition in members : attribute_name = member_definition . name if not cls . _IsIdentifier ( attribute_name ) : raise ValueError ( 'Attribute name: {0!s} not a valid identifier' . format ( attribute_name ) ) if attribute_name . startswith ( '_' ) : raise ValueError ( 'Attribute name: {0!s} starts with underscore' . format ( attribute_name ) ) if keyword . iskeyword ( attribute_name ) : raise ValueError ( 'Attribute name: {0!s} matches keyword' . format ( attribute_name ) ) if attribute_name in defined_attribute_names : raise ValueError ( 'Attribute name: {0!s} already defined' . format ( attribute_name ) ) defined_attribute_names . add ( attribute_name ) | Validates the data type definition . |
6,195 | def CreateClass ( cls , data_type_definition ) : cls . _ValidateDataTypeDefinition ( data_type_definition ) class_definition = cls . _CreateClassTemplate ( data_type_definition ) namespace = { '__builtins__' : { 'object' : builtins . object , 'super' : builtins . super } , '__name__' : '{0:s}' . format ( data_type_definition . name ) } if sys . version_info [ 0 ] >= 3 : namespace [ '__builtins__' ] [ '__build_class__' ] = builtins . __build_class__ exec ( class_definition , namespace ) return namespace [ data_type_definition . name ] | Creates a new structure values class . |
6,196 | def DeregisterDefinition ( self , data_type_definition ) : name = data_type_definition . name . lower ( ) if name not in self . _definitions : raise KeyError ( 'Definition not set for name: {0:s}.' . format ( data_type_definition . name ) ) del self . _definitions [ name ] | Deregisters a data type definition . |
6,197 | def GetDefinitionByName ( self , name ) : lookup_name = name . lower ( ) if lookup_name not in self . _definitions : lookup_name = self . _aliases . get ( name , None ) return self . _definitions . get ( lookup_name , None ) | Retrieves a specific data type definition by name . |
6,198 | def RegisterDefinition ( self , data_type_definition ) : name_lower = data_type_definition . name . lower ( ) if name_lower in self . _definitions : raise KeyError ( 'Definition already set for name: {0:s}.' . format ( data_type_definition . name ) ) if data_type_definition . name in self . _aliases : raise KeyError ( 'Alias already set for name: {0:s}.' . format ( data_type_definition . name ) ) for alias in data_type_definition . aliases : if alias in self . _aliases : raise KeyError ( 'Alias already set for name: {0:s}.' . format ( alias ) ) self . _definitions [ name_lower ] = data_type_definition for alias in data_type_definition . aliases : self . _aliases [ alias ] = name_lower if data_type_definition . TYPE_INDICATOR == definitions . TYPE_INDICATOR_FORMAT : self . _format_definitions . append ( name_lower ) | Registers a data type definition . |
6,199 | def apply_on_csv_string ( rules_str , func ) : splitted = rules_str . split ( "," ) for str in splitted : func ( str . strip ( ) ) | Splits a given string by comma trims whitespace on the resulting strings and applies a given func to each item . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.