from __future__ import annotations
import collections
import dataclasses
import pprint
from collections.abc import Hashable, Mapping
from typing import Any, Self
import numpy as np
from immutabledict import immutabledict as idict
from pyop3.exceptions import ValueMismatchException
[docs]
class AlwaysEmptyDict(dict):
def __init__(self) -> None:
super().__init__()
def __setitem__(self, key, value, /) -> None:
pass
[docs]
def setdefault(self, key, default=None, /):
return default
[docs]
class StrictlyUniqueDict(dict):
"""A dictionary where overwriting entries will raise an error."""
def __setitem__(self, key, value, /) -> None:
if key in self and value != self[key]:
raise ValueMismatchException
return super().__setitem__(key, value)
[docs]
class StrictlyUniqueDefaultDict(collections.defaultdict):
def __setitem__(self, key, value, /) -> None:
if key in self and value != self[key]:
raise ValueMismatchException
return super().__setitem__(key, value)
# NOTE: This has a lot of scope for improvements
[docs]
class UniqueList(list):
[docs]
def append(self, value, /) -> None:
if value in self:
raise ValueMismatchException
return super().append(value)
[docs]
def extend(self, other, /) -> None:
for item in other:
self.append(item)
[docs]
class AbstractOrderedSet:
def __repr__(self) -> str:
return f"{type(self).__name__}({self._values!r})"
def __str__(self) -> str:
return f"{{{', '.join(map(str, self._values))}}}"
def __len__(self) -> int:
return len(self._values)
def __eq__(self, other, /) -> bool:
return type(other) is type(self) and other._values == self._values
[docs]
def __getitem__(self, index, /):
return self._values[index]
def __contains__(self, item, /) -> bool:
return item in self._values
def __iter__(self):
# return iter(self._values.keys())
return iter(self._values)
def __reversed__(self):
return iter(reversed(self._values))
def __or__(self, other, /) -> Self:
assert is_ordered_sequence(other)
values = list(self._values)
for item in other:
if item not in values:
values.append(item)
return type(self)(values)
[docs]
def union(self, /, *others) -> Self:
new = self
for other in others:
new |= other
return new
[docs]
def index(self, value, /) -> Any:
return self._values.index(value)
[docs]
class OrderedSet(AbstractOrderedSet):
"""A mutable ordered set."""
def __init__(self, values=None, /) -> None:
if values is None:
values = []
else:
assert is_ordered_sequence(values) or len(values) < 2
self._values = []
for item in values:
self.add(item)
[docs]
def index(self, value) -> int:
return self._values.index(value)
[docs]
def count(self, value) -> int:
# why did I write this?
raise NotImplementedError
[docs]
def copy(self) -> OrderedSet:
return OrderedSet(self._values)
[docs]
def add(self, value):
# self._values[value] = None
if value not in self._values:
self._values.append(value)
[docs]
def update(self, /, *others):
for other in others:
for item in other:
self.add(item)
[docs]
def remove(self, value):
try:
index = self._values.index(value)
except ValueError:
raise KeyError
else:
self._values.pop(index)
[docs]
def clear(self):
self._values.clear()
[docs]
class OrderedFrozenSet(AbstractOrderedSet):
def __init__(self, values: collections.abc.Sequence = (), /) -> None:
assert is_ordered_sequence(values) or len(values) < 2
self._values = unique(values)
def __hash__(self) -> int:
return hash((type(self), self._values))
# monkey patch pretty printing
pprint.PrettyPrinter._dispatch[idict.__repr__] = pprint.PrettyPrinter._pprint_dict
pprint.PrettyPrinter._dispatch[OrderedSet.__repr__] = pprint.PrettyPrinter._pprint_set
pprint.PrettyPrinter._dispatch[OrderedFrozenSet.__repr__] = pprint.PrettyPrinter._pprint_set
_ordered_mapping_types = (dict, collections.OrderedDict, idict)
_dict_keys_type = type({}.keys())
_dict_values_type = type({}.values())
_dict_items_type = type({}.items())
_ordered_sequence_types = (
list,
tuple,
_dict_keys_type,
_dict_values_type,
_dict_items_type,
np.ndarray,
AbstractOrderedSet,
)
[docs]
def as_tuple(item: Any) -> tuple[Any, ...]:
if isinstance(item, _ordered_sequence_types):
return tuple(item)
else:
return (item,)
[docs]
def is_ordered_mapping(obj: Mapping) -> bool:
return isinstance(obj, _ordered_mapping_types)
[docs]
def is_ordered_sequence(obj: collections.abc.Sequence) -> bool:
return isinstance(obj, _ordered_sequence_types)
[docs]
def unique(iterable) -> tuple[Any]:
unique_items = []
for item in iterable:
if item not in unique_items:
unique_items.append(item)
return tuple(unique_items)
[docs]
@dataclasses.dataclass(frozen=True)
class HashableSlice:
"""A hashable slice.
This class is needed because in Python <3.12 slices are not hashable.
"""
start: Hashable
stop: Hashable
step: Hashable
[docs]
@classmethod
def from_slice(cls, slice_: slice) -> Self:
return cls(slice_.start, slice_.stop, slice_.step)