Exemplo n.º 1
0
def map_copy_deep(source_map, destiny_map):
    """
    Copies the contents of the source map to the destiny map.
    This mode provides a deep copy, using a recursive approach.

    :type source_map: Dictionary
    :param source_map: The source map of the copy.
    :type destiny_map: Dictionary
    :param destiny_map: The destiny map of the copy.
    """

    # copies the current source map to the destiny map
    map_copy(source_map, destiny_map)

    # iterates over all the source map items
    for source_key, source_value in legacy.iteritems(source_map):
        # retrieves the source value type
        source_value_type = type(source_value)

        # in case the source value type is not a dictionary
        # continues the loop, nothing to be done in the
        # current iteration
        if not source_value_type == dict: continue

        # creates the destiny value map and sets the
        # destiny value in the destiny map
        destiny_value = {}
        destiny_map[source_key] = destiny_value

        # copies the source value (map) to the destiny value
        map_copy_deep(source_value, destiny_value)
Exemplo n.º 2
0
def map_copy_deep(source_map, destiny_map):
    """
    Copies the contents of the source map to the destiny map.
    This mode provides a deep copy, using a recursive approach.

    @type source_map: Dictionary
    @param source_map: The source map of the copy.
    @type destiny_map: Dictionary
    @param destiny_map: The destiny map of the copy.
    """

    # copies the current source map to the destiny map
    map_copy(source_map, destiny_map)

    # iterates over all the source map items
    for source_key, source_value in legacy.iteritems(source_map):
        # retrieves the source value type
        source_value_type = type(source_value)

        # in case the source value type is not a dictionary
        # continues the loop, nothing to be done in the
        # current iteration
        if not source_value_type == dict: continue

        # creates the destiny value map and sets the
        # destiny value in the destiny map
        destiny_value = {}
        destiny_map[source_key] = destiny_value

        # copies the source value (map) to the destiny value
        map_copy_deep(source_value, destiny_value)
Exemplo n.º 3
0
def __object_flush_topper(instances_list):
    """
    Flushes (clears) the temporary "topper"
    map in all the instances in the given list.

    @type instances_list: List
    @param instances_list: The list of instances to have
    the "topper" map cleared.
    """

    # iterates over all the instances in the
    # instances list (to clear the "topper" map)
    for instance in instances_list:
        # in case the instance does not
        # contain the topper map
        if not __object_has_attr(instance, TOPPER_VALUE):
            # continues th loop
            continue

        # retrieves the "topper" map for
        # the current instance
        _topper = __object_get_attr(instance, TOPPER_VALUE)

        # iterates over all the "topper" map
        # items (to set them in the instance)
        for key, value in legacy.iteritems(_topper):
            # sets the item in the instance
            __object_set_attr(instance, key, value)

        # deletes the (temporary) "topper"
        # map value
        __object_del_attr(instance, TOPPER_VALUE)
Exemplo n.º 4
0
def url_encode(attributes_map=None, attributes_list=None, plus_encoding=False):
    """
    Encodes the given attributes into url encoding. The
    attributes may be either provided as a map or alternatively
    as a sequence of key value tuples.

    @type attributes_map: Dictionary
    @param attributes_map: The map of attributes to be encoded
    using url encoding, if this value is defined the attributes
    list is not going to be used.
    @type attributes_list: List
    @param attributes_list: The list of key and value tuples
    that are going to be processed as the attributes.
    @type plus_encoding: bool
    @param plus_encoding: If the plus encoding should be used.
    @rtype: String
    @return: The encoded attributes string.
    """

    # retrieves the quote method to be used
    quote_method = plus_encoding and quote_plus or quote

    # creates a string buffer to hold the encoded attribute values
    string_buffer = string_buffer_util.StringBuffer()

    # retrieves the reference to the proper items sequence to be used
    # notice that the attributes map has preference to the list version
    items = legacy.iteritems(
        attributes_map) if attributes_map else attributes_list

    # sets the is first flag, that is going to be used in the iteration
    # cycle to define the first iteration (exceptional iteration)
    is_first = True

    # iterates over all the attribute keys and values to be able to
    # quote their values and append the value to the buffer
    for attribute_key, attribute_value in items:
        # quotes both the attribute key and value
        attribute_key_quoted = quote_method(attribute_key)
        attribute_value_quoted = quote_method(attribute_value)

        # in case it's is the first iteration
        if is_first:
            # unsets the is first flag
            is_first = False
        else:
            # writes the and continuation in the string buffer
            string_buffer.write("&")

        # adds the quoted key and value strings to the
        # string buffer
        string_buffer.write(attribute_key_quoted)
        string_buffer.write("=")
        string_buffer.write(attribute_value_quoted)

    # retrieves the encoded attributes from the string buffer
    encoded_attributes = string_buffer.get_value()

    # returns the encoded attributes
    return encoded_attributes
Exemplo n.º 5
0
def _map_flatten_pairs(map):
    """
    Retrieves the complete set of linear key to value pairs
    of the attributes of the provided map.

    Any dictionary based value of the provided map will be
    linearized using an extra recursion step.

    :type map: Dictionary
    :param map: The map that is the basis of the recursion
    step for the retrieval of the key value pairs.
    :rtype: Generator
    :return: A generator that yields the various key to value
    linear relations, using a recursive approach.
    """

    # iterates over the complete set of key value pairs of the
    # provided map to verify if the pair is map based and if
    # that's the case run a new depth of recursion with a new
    # composite name, so that all relations are linearized
    for key, value in legacy.iteritems(map):
        is_class = hasattr(value, "__class__")
        is_map = is_class and issubclass(value.__class__, dict)
        if not is_map:
            yield key, value
            continue
        pairs = _map_flatten_pairs(value)
        for _key, _value in pairs:
            yield key + "." + _key, _value
Exemplo n.º 6
0
def __object_flush_topper(instances_list):
    """
    Flushes (clears) the temporary "topper"
    map in all the instances in the given list.

    :type instances_list: List
    :param instances_list: The list of instances to have
    the "topper" map cleared.
    """

    # iterates over all the instances in the
    # instances list (to clear the "topper" map)
    for instance in instances_list:
        # in case the instance does not
        # contain the topper map
        if not __object_has_attr(instance, TOPPER_VALUE):
            # continues th loop
            continue

        # retrieves the "topper" map for
        # the current instance
        _topper = __object_get_attr(instance, TOPPER_VALUE)

        # iterates over all the "topper" map
        # items (to set them in the instance)
        for key, value in legacy.iteritems(_topper):
            # sets the item in the instance
            __object_set_attr(instance, key, value)

        # deletes the (temporary) "topper"
        # map value
        __object_del_attr(instance, TOPPER_VALUE)
Exemplo n.º 7
0
def _map_flatten_pairs(map):
    """
    Retrieves the complete set of linear key to value pairs
    of the attributes of the provided map.

    Any dictionary based value of the provided map will be
    linearized using an extra recursion step.

    @type map: Dictionary
    @param map: The map that is the basis of the recursion
    step for the retrieval of the key value pairs.
    @rtype: Generator
    @return: A generator that yields the various key to value
    linear relations, using a recursive approach.
    """

    # iterates over the complete set of key value pairs of the
    # provided map to verify if the pair is map based and if
    # that's the case run a new depth of recursion with a new
    # composite name, so that all relations are linearized
    for key, value in legacy.iteritems(map):
        is_class = hasattr(value, "__class__")
        is_map = is_class and issubclass(value.__class__, dict)
        if not is_map: yield key, value; continue
        pairs = _map_flatten_pairs(value)
        for _key, _value in pairs: yield key + "." + _key, _value
Exemplo n.º 8
0
def url_encode(attributes_map = None, attributes_list = None, plus_encoding = False):
    """
    Encodes the given attributes into url encoding. The
    attributes may be either provided as a map or alternatively
    as a sequence of key value tuples.

    @type attributes_map: Dictionary
    @param attributes_map: The map of attributes to be encoded
    using url encoding, if this value is defined the attributes
    list is not going to be used.
    @type attributes_list: List
    @param attributes_list: The list of key and value tuples
    that are going to be processed as the attributes.
    @type plus_encoding: bool
    @param plus_encoding: If the plus encoding should be used.
    @rtype: String
    @return: The encoded attributes string.
    """

    # retrieves the quote method to be used
    quote_method = plus_encoding and quote_plus or quote

    # creates a string buffer to hold the encoded attribute values
    string_buffer = string_buffer_util.StringBuffer()

    # retrieves the reference to the proper items sequence to be used
    # notice that the attributes map has preference to the list version
    items = legacy.iteritems(attributes_map) if attributes_map else attributes_list

    # sets the is first flag, that is going to be used in the iteration
    # cycle to define the first iteration (exceptional iteration)
    is_first = True

    # iterates over all the attribute keys and values to be able to
    # quote their values and append the value to the buffer
    for attribute_key, attribute_value in items:
        # quotes both the attribute key and value
        attribute_key_quoted = quote_method(attribute_key)
        attribute_value_quoted = quote_method(attribute_value)

        # in case it's is the first iteration
        if is_first:
            # unsets the is first flag
            is_first = False
        else:
            # writes the and continuation in the string buffer
            string_buffer.write("&")

        # adds the quoted key and value strings to the
        # string buffer
        string_buffer.write(attribute_key_quoted)
        string_buffer.write("=")
        string_buffer.write(attribute_value_quoted)

    # retrieves the encoded attributes from the string buffer
    encoded_attributes = string_buffer.get_value()

    # returns the encoded attributes
    return encoded_attributes
Exemplo n.º 9
0
def map_normalize(item, operation=None):
    """
    Normalizes the provided map/item, applying the reduce
    operation to each of the items.

    In case no operation is provided, the default reduce
    map operation is used.

    This operation may be used to convert "complex" type
    based maps into simplified type based maps.

    :type item: Object
    :param item: The map/item to be normalized.
    :type operation: Method
    :param operation: The operation used for normalization
    (reduce operation).
    :rtype: Object
    :return: The normalized map, resulting from the normalization
    of each of its items.
    """

    # sets the (reduce) operation, defaulting
    # to reduce map in case none is defined
    operation = operation or _map_reduce

    # retrieves the type for the current
    # item in order to percolate it appropriately
    _type = type(item)

    # in case the current item is a sequence
    # must normalize all of its elements
    if _type in (list, tuple):
        return [map_normalize(value, operation) for value in item]

    # in case the current item is a map
    # must create a new map with the result
    # of the normalization of all the elements
    elif _type == dict:
        # creates the item map to be populated
        # with the normalized values
        _item = {}

        # iterates over all the items to normalize
        # them and sets them in the new items map
        for key, value in legacy.iteritems(item):
            _item[key] = map_normalize(value, operation)
        return _item

    # otherwise must be a "single" item and the
    # (reduce) operation must be performed on it
    else:
        return operation(item)
Exemplo n.º 10
0
def map_normalize(item, operation = None):
    """
    Normalizes the provided map/item, applying the reduce
    operation to each of the items.

    In case no operation is provided, the default reduce
    map operation is used.

    This operation may be used to convert "complex" type
    based maps into simplified type based maps.

    @type item: Object
    @param item: The map/item to be normalized.
    @type operation: Method
    @param operation: The operation used for normalization
    (reduce operation).
    @rtype: Object
    @return: The normalized map, resulting from the normalization
    of each of its items.
    """

    # sets the (reduce) operation, defaulting
    # to reduce map in case none is defined
    operation = operation or _map_reduce

    # retrieves the type for the current
    # item in order to percolate it appropriately
    _type = type(item)

    # in case the current item is a sequence
    # must normalize all of its elements
    if _type in (list, tuple):
        return [map_normalize(value, operation) for value in item]

    # in case the current item is a map
    # must create a new map with the result
    # of the normalization of all the elements
    elif _type == dict:
        # creates the item map to be populated
        # with the normalized values
        _item = {}

        # iterates over all the items to normalize
        # them and sets them in the new items map
        for key, value in legacy.iteritems(item):
            _item[key] = map_normalize(value, operation)
        return _item

    # otherwise must be a "single" item and the
    # (reduce) operation must be performed on it
    else:
        return operation(item)
Exemplo n.º 11
0
def map_duplicate(item):
    """
    Duplicates the provided item (map) creating a new
    structure with duplicated references both for sequences
    (list and tuples) and for maps.

    This function is useful in order to avoid reference
    overlapping in data structures.

    :type item: Object
    :param item: The item to be used as reference for duplication
    this should be a map at the initial call of the function.
    :rtype: item: Object
    :return: The duplicated data structure with all the references
    replicated in the sequences and maps.
    """

    # retrieves the type for the current
    # item in order to percolate it appropriately
    _type = type(item)

    # in case the current item is a sequence
    # must "copy" all of its elements
    if _type in (list, tuple):
        return [map_duplicate(value) for value in item]

    # in case the current item is a map
    # must create a new map with the result
    # of the copy of all the elements
    elif _type == dict:
        # creates the item map to be populated
        # with the copied values
        _item = {}

        # iterates over all the items to copy
        # them and sets them in the new items map
        for key, value in legacy.iteritems(item):
            _item[key] = map_duplicate(value)
        return _item

    # otherwise must be a "single" item and the
    # (reduce) operation must be performed on it
    else:
        return item
Exemplo n.º 12
0
def map_duplicate(item):
    """
    Duplicates the provided item (map) creating a new
    structure with duplicated references both for sequences
    (list and tuples) and for maps.

    This function is useful in order to avoid reference
    overlapping in data structures.

    @type item: Object
    @param item: The item to be used as reference for duplication
    this should be a map at the initial call of the function.
    @rtype: item: Object
    @return: The duplicated data structure with all the references
    replicated in the sequences and maps.
    """

    # retrieves the type for the current
    # item in order to percolate it appropriately
    _type = type(item)

    # in case the current item is a sequence
    # must "copy" all of its elements
    if _type in (list, tuple):
        return [map_duplicate(value) for value in item]

    # in case the current item is a map
    # must create a new map with the result
    # of the copy of all the elements
    elif _type == dict:
        # creates the item map to be populated
        # with the copied values
        _item = {}

        # iterates over all the items to copy
        # them and sets them in the new items map
        for key, value in legacy.iteritems(item):
            _item[key] = map_duplicate(value)
        return _item

    # otherwise must be a "single" item and the
    # (reduce) operation must be performed on it
    else:
        return item
Exemplo n.º 13
0
def __object_flatten_to_one_map(base_map, instance, flattening_map):
    """
    Auxiliary function that provides the mechanism
    to "map" the "to-one" relations in the instance
    according to the flattening map.

    :type base_map: Dictionary
    :param base_map: The base (top level) map to
    be used to set the top level attributes.
    :type instance: Object
    :param instance: The current concrete instance in the
    recursion set.
    :type flattening_map: Dictionary
    :param flattening_map: Map describing the structure
    for flattening.
    """

    # iterates over all the keys and values
    # in the flattening map structure
    for key, value in legacy.iteritems(flattening_map):
        # retrieves the value type
        value_type = type(value)

        # tries to retrieves the instance value
        # sets the value to invalid in case there
        # is no such instance value (attribute)
        instance_value = __object_has_attr(
            instance, key) and __object_get_attr(instance, key) or None

        # in case the instance value is not set
        if instance_value == None:
            # continues the loop
            continue

        # in case the value if of type string
        # (a leaf of the flattening structure)
        if value_type == str:
            # sets the leaf value in the base map
            base_map[value] = instance_value
        # in case the value is of type dictionary
        # (defined to one relation)
        elif value_type == dict:
            # "flattens" the to one instance relation (recursion)
            __object_flatten_to_one_map(base_map, instance_value, value)
Exemplo n.º 14
0
def __object_flatten_to_one_map(base_map, instance, flattening_map):
    """
    Auxiliary function that provides the mechanism
    to "map" the "to-one" relations in the instance
    according to the flattening map.

    @type base_map: Dictionary
    @param base_map: The base (top level) map to
    be used to set the top level attributes.
    @type instance: Object
    @param instance: The current concrete instance in the
    recursion set.
    @type flattening_map: Dictionary
    @param flattening_map: Map describing the structure
    for flattening.
    """

    # iterates over all the keys and values
    # in the flattening map structure
    for key, value in legacy.iteritems(flattening_map):
        # retrieves the value type
        value_type = type(value)

        # tries to retrieves the instance value
        # sets the value to invalid in case there
        # is no such instance value (attribute)
        instance_value = __object_has_attr(instance, key) and __object_get_attr(instance, key) or None

        # in case the instance value is not set
        if instance_value == None:
            # continues the loop
            continue

        # in case the value if of type string
        # (a leaf of the flattening structure)
        if value_type == str:
            # sets the leaf value in the base map
            base_map[value] = instance_value
        # in case the value is of type dictionary
        # (defined to one relation)
        elif value_type == dict:
            # "flattens" the to one instance relation (recursion)
            __object_flatten_to_one_map(base_map, instance_value, value)
Exemplo n.º 15
0
 def extend(self, map):
     # iterates over all the map items
     for key, value in legacy.iteritems(map):
         # sets the item in the structure
         self.__setitem__(key, value)
Exemplo n.º 16
0
def map_extend(base_map,
               extension_map,
               override=True,
               recursive=False,
               copy_base_map=True):
    """
    Extends the given map with the extension map,
    retrieving a map resulting of the merge of both maps.

    In case the override flag is set the values are overridden
    in case they already exist in the base map.

    An optional recursive flag allows the extension to be
    made recursive in case the value is a map.

    The base map may be changed or left untouched based on
    the copy base map flag.

    :type base_map: Dictionary
    :param base_map: The map to be used as base for the merge,
    should contain more values at the end of the merge.
    :type extension_map: Dictionary
    :param extension_map: The map to be used to extend the base
    one, this map may be recursively percolated if requested.
    :type override: bool
    :param override: If a value should be overridden in
    case it already exists in the base map.
    :type recursive: bool
    :param recursive: If a value should be extended in
    case it already exists in the base map (recursive
    extension).
    :type copy_base_map: bool
    :param copy_base_map: If the base map should be copied before
    being extended in order to avoid loss of data.
    :rtype: Dictionary
    :return: The map that result of the merge of both maps.
    """

    # copies the base map to create the initial result map (optional)
    result_map = copy.copy(base_map) if copy_base_map else base_map

    # iterates over all the keys and values
    # in the extension map
    for key, value in legacy.iteritems(extension_map):
        # in case the override flag is not set and
        # the key already exists in the result map
        # must skip the current iteration loop
        if not override and key in result_map:
            continue

        # retrieves the data type for the current value in
        # iteration so that it may be used to determine the
        # need for the recursive percolated copy/merge
        value_type = type(value)

        # in case the value is a map and the recursive flag
        # is set, must try to extend the current item with
        # the new one, as expected
        if recursive and value_type == dict:
            #  tries to retrieve the result map value, so
            # that it's possible to extend the current value
            # with the previously existing one, a default map
            # is created in case it does not exists so that
            # it's possible to used as the base for population
            result_map_value = result_map.get(key, {})

            # extends the map that is currently in the result
            # map with the new value (recursive step), note
            # that a new map may have been created to be used
            # as the placeholder of new map values, this avoids
            # collision between sub-maps (would cause problems)
            value = map_extend(result_map_value,
                               value,
                               override=override,
                               recursive=recursive,
                               copy_base_map=copy_base_map)

        # sets the (extension) value in the result map
        result_map[key] = value

    # returns the result map
    return result_map
Exemplo n.º 17
0
 def extend(self, map):
     # iterates over all the map items
     for key, value in legacy.iteritems(map):
         # sets the item in the structure
         self.__setitem__(key, value)
Exemplo n.º 18
0
def map_extend(
    base_map,
    extension_map,
    override = True,
    recursive = False,
    copy_base_map = True
):
    """
    Extends the given map with the extension map,
    retrieving a map resulting of the merge of both maps.

    In case the override flag is set the values are overridden
    in case they already exist in the base map.

    An optional recursive flag allows the extension to be
    made recursive in case the value is a map.

    The base map may be changed or left untouched based on
    the copy base map flag.

    @type base_map: Dictionary
    @param base_map: The map to be used as base for the merge,
    should contain more values at the end of the merge.
    @type extension_map: Dictionary
    @param extension_map: The map to be used to extend the base
    one, this map may be recursively percolated if requested.
    @type override: bool
    @param override: If a value should be overridden in
    case it already exists in the base map.
    @type recursive: bool
    @param recursive: If a value should be extended in
    case it already exists in the base map (recursive
    extension).
    @type copy_base_map: bool
    @param copy_base_map: If the base map should be copied before
    being extended in order to avoid loss of data.
    @rtype: Dictionary
    @return: The map that result of the merge of both maps.
    """

    # copies the base map to create the initial result map (optional)
    result_map = copy.copy(base_map) if copy_base_map else base_map

    # iterates over all the keys and values
    # in the extension map
    for key, value in legacy.iteritems(extension_map):
        # in case the override flag is not set and
        # the key already exists in the result map
        # must skip the current iteration loop
        if not override and key in result_map:
            continue

        # retrieves the data type for the current value in
        # iteration so that it may be used to determine the
        # need for the recursive percolated copy/merge
        value_type = type(value)

        # in case the value is a map and the recursive flag
        # is set, must try to extend the current item with
        # the new one, as expected
        if recursive and value_type == dict:
            #  tries to retrieve the result map value, so
            # that it's possible to extend the current value
            # with the previously existing one, a default map
            # is created in case it does not exists so that
            # it's possible to used as the base for population
            result_map_value = result_map.get(key, {})

            # extends the map that is currently in the result
            # map with the new value (recursive step), note
            # that a new map may have been created to be used
            # as the placeholder of new map values, this avoids
            # collision between sub-maps (would cause problems)
            value = map_extend(
                result_map_value,
                value,
                override = override,
                recursive = recursive,
                copy_base_map = copy_base_map
            )

        # sets the (extension) value in the result map
        result_map[key] = value

    # returns the result map
    return result_map