Sort utils

tablite.sort_utils

Attributes

tablite.sort_utils.uca_collator = Collator() module-attribute

tablite.sort_utils.modes = {'alphanumeric': text_sort, 'unix': unix_sort, 'excel': excel_sort} module-attribute

Classes

tablite.sort_utils.HashDict

Bases: dict

This class is just a nicity syntatic sugar for debugging. Function identically to regular dictionary, just uses tupled key.

Functions

tablite.sort_utils.HashDict.items()

Source code in tablite/sort_utils.py

def items(self):
    return [(k, v) for (_, k), v in super().items()]

tablite.sort_utils.HashDict.keys()

Source code in tablite/sort_utils.py

def keys(self):
    return [k for (_, k) in super().keys()]

tablite.sort_utils.HashDict.__iter__() -> Iterator

Source code in tablite/sort_utils.py

def __iter__(self) -> Iterator:
    return (k for (_, k) in super().keys())

tablite.sort_utils.HashDict.__getitem__(key)

Source code in tablite/sort_utils.py

def __getitem__(self, key):
    return super().__getitem__(self._get_hash(key))

tablite.sort_utils.HashDict.__setitem__(key, value)

Source code in tablite/sort_utils.py

def __setitem__(self, key, value):
    return super().__setitem__(self._get_hash(key), value)

tablite.sort_utils.HashDict.__contains__(key) -> bool

Source code in tablite/sort_utils.py

def __contains__(self, key) -> bool:
    return super().__contains__(self._get_hash(key))

tablite.sort_utils.HashDict.__delitem__(key)

Source code in tablite/sort_utils.py

def __delitem__(self, key):
    return super().__delitem__(self._get_hash(key))

tablite.sort_utils.HashDict.__repr__() -> str

Source code in tablite/sort_utils.py

def __repr__(self) -> str:
    return '{' + ", ".join([f"{k}: {v}" for k, v in self.items()]) + '}'

tablite.sort_utils.HashDict.__str__() -> str

Source code in tablite/sort_utils.py

def __str__(self) -> str:
    return repr(self)

Functions

tablite.sort_utils.text_sort(values, reverse=False)

Sorts everything as text.

Source code in tablite/sort_utils.py

def text_sort(values, reverse=False):
    """
    Sorts everything as text.
    """
    text = {str(i): i for i in values}
    L = list(text.keys())
    L.sort(key=uca_collator.sort_key, reverse=reverse)
    d = {text[value]: ix for ix, value in enumerate(L)}
    return d

tablite.sort_utils.unix_sort(values, reverse=False)

Unix sortation sorts by the following order:

| rank | type | value | +------+-----------+--------------------------------------------+ | 0 | None | floating point -infinite | | 1 | bool | 0 as False, 1 as True | | 2 | int | as numeric value | | 2 | float | as numeric value | | 3 | time | τ * seconds into the day / (24 * 60 * 60) | | 4 | date | as integer days since 1970/1/1 | | 5 | datetime | as float using date (int) + time (decimal) | | 6 | timedelta | as float using date (int) + time (decimal) | | 7 | str | using unicode | +------+-----------+--------------------------------------------+

τ = 2 * π

Source code in tablite/sort_utils.py

def unix_sort(values, reverse=False):
    """
    Unix sortation sorts by the following order:

    | rank | type      | value                                      |
    +------+-----------+--------------------------------------------+
    |   0  | None      | floating point -infinite                   |
    |   1  | bool      | 0 as False, 1 as True                      |
    |   2  | int       | as numeric value                           |
    |   2  | float     | as numeric value                           |
    |   3  | time      | τ * seconds into the day / (24 * 60 * 60)  |
    |   4  | date      | as integer days since 1970/1/1             |
    |   5  | datetime  | as float using date (int) + time (decimal) |
    |   6  | timedelta | as float using date (int) + time (decimal) |
    |   7  | str       | using unicode                              |
    +------+-----------+--------------------------------------------+

    τ = 2 * π

    """
    text, non_text = [], []

    # L = []
    # text = [i for i in values if isinstance(i, str)]
    # text.sort(key=uca_collator.sort_key, reverse=reverse)
    # text_code = _unix_typecodes[str]
    # L = [(text_code, ix, v) for ix, v in enumerate(text)]

    for value in values:
        if isinstance(value, str):
            text.append(value)
        else:
            t = type(value)
            TC = _unix_typecodes[t]
            tf = _unix_value_function[t]
            VC = tf(value)
            non_text.append((TC, VC, value))
    non_text.sort(reverse=reverse)

    text.sort(key=uca_collator.sort_key, reverse=reverse)
    text_code = _unix_typecodes[str]
    text = [(text_code, ix, v) for ix, v in enumerate(text)]

    d = HashDict()
    L = non_text + text
    for ix, (_, _, value) in enumerate(L):
        d[value] = ix
    return d

tablite.sort_utils.excel_sort(values, reverse=False)

Excel sortation sorts by the following order:

| rank | type | value | +------+-----------+--------------------------------------------+ | 1 | int | as numeric value | | 1 | float | as numeric value | | 1 | time | as seconds into the day / (24 * 60 * 60) | | 1 | date | as integer days since 1900/1/1 | | 1 | datetime | as float using date (int) + time (decimal) | | (1)*| timedelta | as float using date (int) + time (decimal) | | 2 | str | using unicode | | 3 | bool | 0 as False, 1 as True | | 4 | None | floating point infinite. | +------+-----------+--------------------------------------------+

• Excel doesn't have timedelta.

Source code in tablite/sort_utils.py

def excel_sort(values, reverse=False):
    """
    Excel sortation sorts by the following order:

    | rank | type      | value                                      |
    +------+-----------+--------------------------------------------+
    |   1  | int       | as numeric value                           |
    |   1  | float     | as numeric value                           |
    |   1  | time      | as seconds into the day / (24 * 60 * 60)   |
    |   1  | date      | as integer days since 1900/1/1             |
    |   1  | datetime  | as float using date (int) + time (decimal) |
    |  (1)*| timedelta | as float using date (int) + time (decimal) |
    |   2  | str       | using unicode                              |
    |   3  | bool      | 0 as False, 1 as True                      |
    |   4  | None      | floating point infinite.                   |
    +------+-----------+--------------------------------------------+

    * Excel doesn't have timedelta.
    """

    def tup(TC, value):
        return (TC, _excel_value_function[t](value), value)

    text, numeric, booles, nones = [], [], [], []
    for value in values:
        t = type(value)
        TC = _excel_typecodes[t]

        if TC == 0:
            numeric.append(tup(TC, value))
        elif TC == 1:
            text.append(value)  # text is processed later.
        elif TC == 2:
            booles.append(tup(TC, value))
        elif TC == 3:
            booles.append(tup(TC, value))
        else:
            raise TypeError(f"no typecode for {value}")

    if text:
        text.sort(key=uca_collator.sort_key, reverse=reverse)
        text = [(2, ix, v) for ix, v in enumerate(text)]

    numeric.sort(reverse=reverse)
    booles.sort(reverse=reverse)
    nones.sort(reverse=reverse)

    if reverse:
        L = nones + booles + text + numeric
    else:
        L = numeric + text + booles + nones
    d = {value: ix for ix, (_, _, value) in enumerate(L)}
    return d

tablite.sort_utils.rank(values, reverse, mode)

values: list of values to sort. reverse: bool mode: as 'text', as 'numeric' or as 'excel' return: dict: d[value] = rank

Source code in tablite/sort_utils.py

def rank(values, reverse, mode):
    """
    values: list of values to sort.
    reverse: bool
    mode: as 'text', as 'numeric' or as 'excel'
    return: dict: d[value] = rank
    """
    if mode not in modes:
        raise ValueError(f"{mode} not in list of modes: {list(modes)}")
    f = modes.get(mode)
    return f(values, reverse)