graphid.util.util_group module¶

graphid.util.util_group.sortedby(item_list, key_list, reverse=False)[source]¶

sorts item_list using key_list

Parameters:

list_ (list) – list to sort
key_list (list) – list to sort by
reverse (bool) – sort order is descending (largest first) if reverse is True else acscending (smallest first)

Returns:

list_ sorted by the values of another list. defaults to ascending order

Return type:

list

SeeAlso:: sortedby2

Examples

>>> list_    = [1, 2, 3, 4, 5]
>>> key_list = [2, 5, 3, 1, 5]
>>> result = sortedby(list_, key_list, reverse=True)
>>> print(result)
[5, 2, 3, 1, 4]

graphid.util.util_group.grouping_delta(old, new, pure=True)[source]¶

Finds what happened to the old groups to form the new groups.

Parameters:

old (set of frozensets) – old grouping
new (set of frozensets) – new grouping
pure (bool) – hybrids are separated from pure merges and splits if pure is True, otherwise hybrid cases are grouped in merges and splits.

Returns:

delta: dictionary of changes containing the merges, splits,: unchanged, and hybrid cases. Except for unchanged, case a subdict with new and old keys. For splits / merges, one of these contains nested sequences to indicate what the split / merge is. Also reports elements added and removed between old and new if the flattened sets are not the same.

Return type:

dict

Notes

merges - which old groups were merged into a single new group. splits - which old groups were split into multiple new groups. hybrid - which old groups had split/merge actions applied. unchanged - which old groups are the same as new groups.

Example

>>> # xdoc: +IGNORE_WHITESPACE
>>> old = [
>>>     [20, 21, 22, 23], [1, 2], [12], [13, 14], [3, 4], [5, 6,11],
>>>     [7], [8, 9], [10], [31, 32], [33, 34, 35], [41, 42, 43, 44, 45]
>>> ]
>>> new = [
>>>   [20, 21], [22, 23], [1, 2], [12, 13, 14], [4], [5, 6, 3], [7, 8],
>>>   [9, 10, 11], [31, 32, 33, 34, 35],   [41, 42, 43, 44], [45],
>>> ]
>>> delta = grouping_delta(old, new)
>>> assert set(old[0]) in delta['splits']['old']
>>> assert set(new[3]) in delta['merges']['new']
>>> assert set(old[1]) in delta['unchanged']
>>> result = ub.urepr(delta, nl=2, sort=True, nobr=1, sk=True)
>>> print(result)
hybrid: {
    merges: [{{10}, {11}, {9}}, {{3}, {5, 6}}, {{4}}, {{7}, {8}}],
    new: {{3, 5, 6}, {4}, {7, 8}, {9, 10, 11}},
    old: {{10}, {3, 4}, {5, 6, 11}, {7}, {8, 9}},
    splits: [{{10}}, {{11}, {5, 6}}, {{3}, {4}}, {{7}}, {{8}, {9}}],
},
items: {
    added: {},
    removed: {},
},
merges: {
    new: [{12, 13, 14}, {31, 32, 33, 34, 35}],
    old: [{{12}, {13, 14}}, {{31, 32}, {33, 34, 35}}],
},
splits: {
    new: [{{20, 21}, {22, 23}}, {{41, 42, 43, 44}, {45}}],
    old: [{20, 21, 22, 23}, {41, 42, 43, 44, 45}],
},
unchanged: {
    {1, 2},
},

Example

>>> old = [
>>>     [1, 2, 3], [4], [5, 6, 7, 8, 9], [10, 11, 12]
>>> ]
>>> new = [
>>>     [1], [2], [3, 4], [5, 6, 7], [8, 9, 10, 11, 12]
>>> ]
>>> # every case here is hybrid
>>> pure_delta = grouping_delta(old, new, pure=True)
>>> assert len(list(ub.flatten(pure_delta['merges'].values()))) == 0
>>> assert len(list(ub.flatten(pure_delta['splits'].values()))) == 0
>>> delta = grouping_delta(old, new, pure=False)
>>> delta = order_dict_by(delta, ['unchanged', 'splits', 'merges'])
>>> result = ub.urepr(delta, nl=2, sort=True, sk=True)
>>> print(result)
{
    items: {
        added: {},
        removed: {},
    },
    merges: [
        [{3}, {4}],
        [{10, 11, 12}, {8, 9}],
    ],
    splits: [
        [{1}, {2}, {3}],
        [{5, 6, 7}, {8, 9}],
    ],
    unchanged: {},
}

Example

>>> delta = grouping_delta([[1, 2, 3]], [])
>>> assert len(delta['items']['removed']) == 3
>>> delta = grouping_delta([], [[1, 2, 3]])
>>> assert len(delta['items']['added']) == 3
>>> delta = grouping_delta([[1]], [[1, 2, 3]])
>>> assert len(delta['items']['added']) == 2
>>> assert len(delta['unchanged']) == 1

graphid.util.util_group.order_dict_by(dict_, key_order)[source]¶

Reorders items in a dictionary according to a custom key order

Parameters:

dict_ (dict_) – a dictionary
key_order (list) – custom key order

Returns:

sorted_dict

Return type:

OrderedDict

Example

>>> dict_ = {1: 1, 2: 2, 3: 3, 4: 4}
>>> key_order = [4, 2, 3, 1]
>>> sorted_dict = order_dict_by(dict_, key_order)
>>> result = ('sorted_dict = %s' % (ub.urepr(sorted_dict, nl=False),))
>>> print(result)
>>> assert result == 'sorted_dict = {4: 4, 2: 2, 3: 3, 1: 1}'

graphid.util.util_group.group_pairs(pair_list)[source]¶

Groups a list of items using the first element in each pair as the item and the second element as the groupid.

Parameters:: pair_list (list) – list of 2-tuples (item, groupid)
Returns:: groupid_to_items: maps a groupid to a list of items
Return type:: dict

graphid.util.util_group.sort_dict(dict_, part='keys', key=None, reverse=False)[source]¶

sorts a dictionary by its values or its keys

Parameters:

dict_ (dict_) – a dictionary
part (str) – specifies to sort by keys or values
key (Optional[func]) – a function that takes specified part and returns a sortable value
reverse (bool) – (Defaults to False) - True for descinding order. False for ascending order.

Returns:

sorted dictionary

Return type:

OrderedDict

Example

>>> dict_ = {'a': 3, 'c': 2, 'b': 1}
>>> results = []
>>> results.append(sort_dict(dict_, 'keys'))
>>> results.append(sort_dict(dict_, 'vals'))
>>> results.append(sort_dict(dict_, 'vals', lambda x: -x))
>>> result = ub.urepr(results)
>>> print(result)
[
    {'a': 3, 'b': 1, 'c': 2},
    {'b': 1, 'c': 2, 'a': 3},
    {'a': 3, 'c': 2, 'b': 1},
]