def sort_subindicators(self, subindicators, group):
        sorted_dict = subindicators

        sort_order = self._group_orders.get(group, None)

        if sort_order is not None:
            unique_sort_order = list(Counter(sort_order).keys())
            sorted_tuples = sort_list_using_order(subindicators.items(),
                                                  unique_sort_order,
                                                  operator.itemgetter(0))
            sorted_dict = OrderedDict(sorted_tuples)

        return sorted_dict
    def sort_group_subindicators(row, group_dict):
        new_dict = {}
        for group, group_subindicators_dict in group_dict.items():
            key = (group, row["dataset"])
            if key in groups_lookup:
                key_func = lambda x: x[0]
                subindicator_order = groups_lookup[key]
                sorted_group_subindicators_list = sort_list_using_order(group_subindicators_dict.items(), subindicator_order, key_func=key_func)
                sorted_group_subindicators_dict = OrderedDict(sorted_group_subindicators_list)
            else:
                logger.warning(f"Key: {key} not in groups lookup")
                sorted_group_subindicators_dict = group_subindicators_dict

            new_dict[group] = sorted_group_subindicators_dict

        return new_dict
    def sort_indicator_subindicators(row, group_dict):
        key = (row["indicator_group"][0], row["dataset"])
        key_func = lambda x: x[0]

        new_group_dict = {}
        for group, group_subindicators_dict in group_dict.items():
            new_group_subindicators_dict = {}
            for group_subindicator, indicator_subindicators_dict in group_subindicators_dict.items():
                if key in groups_lookup:
                    subindicator_order = groups_lookup[key]
                    items = indicator_subindicators_dict.items()
                    sorted_tuples = sort_list_using_order(items, subindicator_order, key_func=key_func)
                    sorted_indicator_subindicators_dict = OrderedDict(sorted_tuples)
                else:
                    sorted_indicator_subindicators_dict = indicator_subindicators_dict
                new_group_subindicators_dict[group_subindicator] = sorted_indicator_subindicators_dict
            new_group_dict[group] = new_group_subindicators_dict

        return new_group_dict
Exemple #4
0
def test_sort_using_order_with_custom_key():
    lst = [(1, "a"), (2, "b"), (3, "c")]
    order = ["b", "a", "c"]
    sorted_lst = sort_list_using_order(lst, order, key_func=lambda x: x[1])
    assert sorted_lst == [(2, "b"), (1, "a"), (3, "c")]
Exemple #5
0
def test_sort_using_order_with_missing_values():
    lst = ["a", "b", "c"]
    order = ["b", "a"]
    sorted_lst = sort_list_using_order(lst, order)
    assert sorted_lst == ["b", "a", "c"]
Exemple #6
0
def test_empty_sort_using_order():
    lst = []
    order = []

    sorted_lst = sort_list_using_order(lst, order)
    assert sorted_lst == []
Exemple #7
0
def test_sort_using_order_with_complete_order():
    lst = ["a", "b", "c"]
    order = ["b", "c", "a"]
    sorted_lst = sort_list_using_order(lst, order)
    assert sorted_lst == order
Exemple #8
0
def test_sort_using_order_with_none_order():
    lst = [2, 3, 1]
    sorted_lst = sort_list_using_order(lst, None)
    assert sorted_lst == lst
Exemple #9
0
def test_sort_using_order_with_empty_order():
    lst = [2, 3, 1]
    order = []
    sorted_lst = sort_list_using_order(lst, order)
    assert sorted_lst == lst