omlish 0.0.0.dev1__py3-none-any.whl

omlish/c3.py

@@ -0,0 +1,173 @@
+"""
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement
+and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
+2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python alone or in
+any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any
+such work a brief summary of the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS
+OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
+MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture
+between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade name in a
+trademark sense to endorse or promote products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+License Agreement.
+"""
+import operator
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def merge(seqs: ta.MutableSequence[list[T]]) -> list[T]:
+    """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
+
+    Adapted from https://www.python.org/download/releases/2.3/mro/.
+    """
+
+    result: list[T] = []
+    candidate: ta.Optional[T] = None
+    while True:
+        seqs = [s for s in seqs if s]  # purge empty sequences
+        if not seqs:
+            return result
+        for s1 in seqs:  # find merge candidates among seq heads
+            candidate = s1[0]
+            for s2 in seqs:
+                if candidate in s2[1:]:
+                    candidate = None
+                    break  # reject the current head, it appears later
+            else:
+                break
+        if candidate is None:
+            raise RuntimeError('Inconsistent hierarchy')
+        result.append(candidate)
+        # remove the chosen candidate
+        for seq in seqs:
+            if seq[0] == candidate:
+                del seq[0]
+
+
+def mro(
+        cls: T,
+        abcs: ta.Optional[ta.Sequence[T]] = None,
+        *,
+        get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
+        is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
+) -> list[T]:
+    """Computes the method resolution order using extended C3 linearization.
+
+    If no *abcs* are given, the algorithm works exactly like the built-in C3 linearization used for method resolution.
+
+    If given, *abcs* is a list of abstract base classes that should be inserted into the resulting MRO. Unrelated ABCs
+    are ignored and don't end up in the result. The algorithm inserts ABCs where their functionality is introduced, i.e.
+    issubclass(cls, abc) returns True for the class itself but returns False for all its direct base classes. Implicit
+    ABCs for a given class (either registered or inferred from the presence of a special method like __len__) are
+    inserted directly after the last ABC explicitly listed in the MRO of said class. If two implicit ABCs end up next to
+    each other in the resulting MRO, their ordering depends on the order of types in *abcs*.
+    """
+
+    for i, base in enumerate(reversed(get_bases(cls))):
+        if hasattr(base, '__abstractmethods__'):
+            boundary = len(get_bases(cls)) - i
+            break  # Bases up to the last explicit ABC are considered first.
+    else:
+        boundary = 0
+    abcs = list(abcs) if abcs else []
+    explicit_bases = list(get_bases(cls)[:boundary])
+    abstract_bases = []
+    other_bases = list(get_bases(cls)[boundary:])
+    for base in abcs:
+        if (
+                is_subclass(cls, base) and  # noqa
+                not any(is_subclass(b, base) for b in get_bases(cls))  # noqa
+        ):
+            # If *cls* is the class that introduces behaviour described by an ABC *base*, insert said ABC to its MRO.
+            abstract_bases.append(base)
+    for base in abstract_bases:
+        abcs.remove(base)
+    explicit_c3_mros = [mro(base, abcs=abcs, get_bases=get_bases, is_subclass=is_subclass) for base in explicit_bases]
+    abstract_c3_mros = [mro(base, abcs=abcs, get_bases=get_bases, is_subclass=is_subclass) for base in abstract_bases]
+    other_c3_mros = [mro(base, abcs=abcs, get_bases=get_bases, is_subclass=is_subclass) for base in other_bases]
+    return merge(
+        [[cls]] +
+        explicit_c3_mros + abstract_c3_mros + other_c3_mros +
+        [explicit_bases] + [abstract_bases] + [other_bases]
+    )
+
+
+def compose_mro(
+        cls: T,
+        types: ta.Iterable[T],
+        *,
+        get_mro: ta.Callable[[T], ta.Optional[ta.Sequence[T]]] = operator.attrgetter('__mro__'),
+        get_bases: ta.Callable[[T], ta.Sequence[T]] = operator.attrgetter('__bases__'),
+        is_subclass: ta.Callable[[T, T], bool] = issubclass,  # type: ignore
+        get_subclasses: ta.Callable[[T], ta.Iterable[T]] = operator.methodcaller('__subclasses__'),
+) -> list[T]:
+    """Calculates the method resolution order for a given class *cls*.
+
+    Includes relevant abstract base classes (with their respective bases) from the *types* list. Uses a modified C3
+    linearization algorithm.
+    """
+
+    bases = set(get_mro(cls) or [])
+
+    # Remove entries which are already present in the __mro__ or unrelated.
+    def is_related(typ):
+        return typ not in bases and get_mro(typ) is not None and is_subclass(cls, typ)
+
+    types = [n for n in types if is_related(n)]
+
+    # Remove entries which are strict bases of other entries (they will end up in the MRO anyway.
+    def is_strict_base(typ):
+        for other in types:
+            if typ != other and typ in (get_mro(other) or []):
+                return True
+        return False
+
+    types = [n for n in types if not is_strict_base(n)]
+
+    # Subclasses of the ABCs in *types* which are also implemented by *cls* can be used to stabilize ABC ordering.
+    type_set = set(types)
+    _mro = []
+    for typ in types:
+        found: list[list[T]] = []
+        for sub in get_subclasses(typ):
+            if sub not in bases and is_subclass(cls, sub):  # noqa
+                found.append([s for s in (get_mro(sub) or []) if s in type_set])
+        if not found:
+            _mro.append(typ)
+            continue
+
+        # Favor subclasses with the biggest number of useful bases
+        found.sort(key=len, reverse=True)
+        for lst in found:
+            for subcls in lst:
+                if subcls not in _mro:
+                    _mro.append(subcls)
+
+    return mro(cls, abcs=_mro, get_bases=get_bases, is_subclass=is_subclass)

omlish/cached.py

@@ -0,0 +1,9 @@
+from .lang.cached import cached_function
+from .lang.cached import _CachedProperty  # noqa
+
+
+function = cached_function
+
+property = property  # noqa
+
+globals()['property'] = _CachedProperty  # noqa

omlish/check.py

@@ -0,0 +1,231 @@
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+"""
+import collections
+import typing as ta
+
+
+T = ta.TypeVar('T')
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+
+Message = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]
+
+_NONE_TYPE = type(None)
+
+_isinstance = isinstance
+_issubclass = issubclass
+_callable = callable
+
+
+##
+
+
+def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exception:
+    return exc_cls(*args, **kwargs)  # noqa
+
+
+_EXCEPTION_FACTORY = _default_exception_factory
+
+
+def _raise(
+        exception_type: type[Exception],
+        default_message: str,
+        message: Message,
+        *args: ta.Any,
+        **kwargs: ta.Any
+) -> ta.NoReturn:
+    if _callable(message):
+        message = ta.cast(ta.Callable, message)(*args, **kwargs)
+        if _isinstance(message, tuple):
+            message, *args = message  # type: ignore
+    if message is None:
+        message = default_message
+    exc = _EXCEPTION_FACTORY(exception_type, message, *args, **kwargs)
+    raise exc
+
+
+##
+
+
+def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
+    if not _isinstance(spec, tuple):
+        spec = (spec,)
+    if None in spec:
+        spec = tuple(filter(None, spec)) + (_NONE_TYPE,)
+    if ta.Any in spec:
+        spec = (object,)
+    return spec
+
+
+def isinstance(v: ta.Any, spec: ta.Union[type[T], tuple], msg: Message = None) -> T:  # noqa
+    if not _isinstance(v, _unpack_isinstance_spec(spec)):
+        _raise(TypeError, 'Must be instance', msg, v, spec)
+    return v
+
+
+def of_isinstance(spec: ta.Union[type[T], tuple], msg: Message = None) -> ta.Callable[[ta.Any], T]:
+    def inner(v):
+        return isinstance(v, _unpack_isinstance_spec(spec), msg)
+
+    return inner
+
+
+def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
+    if not _isinstance(v, cls):
+        _raise(TypeError, 'Must be instance', msg, v, cls)
+    return v
+
+
+def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
+    def inner(v):
+        return isinstance(v, cls, msg)
+
+    return inner
+
+
+def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
+    if _isinstance(v, _unpack_isinstance_spec(spec)):
+        _raise(TypeError, 'Must not be instance', msg, v, spec)
+    return v
+
+
+def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
+    def inner(v):
+        return not_isinstance(v, _unpack_isinstance_spec(spec), msg)
+
+    return inner
+
+
+##
+
+
+def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
+    if not _issubclass(v, spec):
+        _raise(TypeError, 'Must be subclass', msg, v, spec)
+    return v
+
+
+def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
+    if _issubclass(v, spec):
+        _raise(TypeError, 'Must not be subclass', msg, v, spec)
+    return v
+
+
+##
+
+
+def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
+    if v not in c:
+        _raise(ValueError, 'Must be in', msg, v, c)
+    return v
+
+
+def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
+    if v in c:
+        _raise(ValueError, 'Must not be in', msg, v, c)
+    return v
+
+
+def empty(v: SizedT, msg: Message = None) -> SizedT:
+    if len(v) != 0:
+        _raise(ValueError, 'Must be empty', msg, v)
+    return v
+
+
+def not_empty(v: SizedT, msg: Message = None) -> SizedT:
+    if len(v) == 0:
+        _raise(ValueError, 'Must not be empty', msg, v)
+    return v
+
+
+def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
+    dupes = [e for e, c in collections.Counter(it).items() if c > 1]
+    if dupes:
+        _raise(ValueError, 'Must be unique', msg, it, dupes)
+    return it
+
+
+def single(obj: ta.Iterable[T], message: Message = None) -> T:
+    try:
+        [value] = obj
+    except ValueError:
+        _raise(ValueError, 'Must be single', message, obj)
+    else:
+        return value
+
+
+def optional_single(obj: ta.Iterable[T], message: Message = None) -> ta.Optional[T]:
+    it = iter(obj)
+    try:
+        value = next(it)
+    except StopIteration:
+        return None
+    try:
+        next(it)
+    except StopIteration:
+        return value  # noqa
+    _raise(ValueError, 'Must be empty or single', message, obj)
+
+
+##
+
+
+def none(v: ta.Any, msg: Message = None) -> None:
+    if v is not None:
+        _raise(ValueError, 'Must be None', msg, v)
+
+
+def not_none(v: ta.Optional[T], msg: Message = None) -> T:
+    if v is None:
+        _raise(ValueError, 'Must not be None', msg, v)
+    return v
+
+
+##
+
+
+def equal(v: T, *os: ta.Any, msg: Message = None) -> T:
+    for o in os:
+        if o != v:
+            _raise(ValueError, 'Must be equal', msg, v, os)
+    return v
+
+
+def is_(v: T, *os: ta.Any, msg: Message = None) -> T:
+    for o in os:
+        if o is not v:
+            _raise(ValueError, 'Must be the same', msg, v, os)
+    return v
+
+
+def is_not(v: T, *os: ta.Any, msg: Message = None) -> T:
+    for o in os:
+        if o is v:
+            _raise(ValueError, 'Must not be the same', msg, v, os)
+    return v
+
+
+def callable(v: T, msg: Message = None) -> T:
+    if not _callable(v):
+        _raise(TypeError, 'Must be callable', msg, v)
+    return v  # type: ignore
+
+
+def non_empty_str(v: ta.Optional[str], msg: Message = None) -> str:
+    if not _isinstance(v, str) or not v:
+        _raise(ValueError, 'Must be non-empty str', msg, v)
+    return v
+
+
+##
+
+
+def arg(v: bool, msg: Message = None) -> None:
+    if not v:
+        _raise(RuntimeError, 'Argument condition not met', msg)
+
+
+def state(v: bool, msg: Message = None) -> None:
+    if not v:
+        _raise(RuntimeError, 'State condition not met', msg)

omlish/collections/__init__.py

@@ -0,0 +1,63 @@
+from .coerce import abs_set  # noqa
+from .coerce import abs_set_of  # noqa
+from .coerce import abs_set_of_or_none  # noqa
+from .coerce import abs_set_or_none  # noqa
+from .coerce import frozenset_  # noqa
+from .coerce import frozenset_of  # noqa
+from .coerce import frozenset_of_or_none  # noqa
+from .coerce import frozenset_or_none  # noqa
+from .coerce import map  # noqa
+from .coerce import map_of  # noqa
+from .coerce import map_of_or_none  # noqa
+from .coerce import map_or_none  # noqa
+from .coerce import opt_abs_set  # noqa
+from .coerce import opt_abs_set_of  # noqa
+from .coerce import opt_frozenset  # noqa
+from .coerce import opt_frozenset_of  # noqa
+from .coerce import opt_map  # noqa
+from .coerce import opt_map_of  # noqa
+from .coerce import opt_seq  # noqa
+from .coerce import opt_seq_of  # noqa
+from .coerce import seq  # noqa
+from .coerce import seq_of  # noqa
+from .coerce import seq_of_or_none  # noqa
+from .coerce import seq_or_none  # noqa
+from .frozen import Frozen  # noqa
+from .frozen import FrozenDict  # noqa
+from .frozen import FrozenList  # noqa
+from .frozen import frozendict  # noqa
+from .frozen import frozenlist  # noqa
+from .identity import IdentityKeyDict  # noqa
+from .identity import IdentitySet  # noqa
+from .identity import IdentityWrapper  # noqa
+from .indexed import IndexedSeq  # noqa
+from .indexed import IndexedSetSeq  # noqa
+from .mappings import MissingDict  # noqa
+from .mappings import TypeMap  # noqa
+from .mappings import TypeMultiMap  # noqa
+from .mappings import guarded_map_update  # noqa
+from .mappings import multikey_dict  # noqa
+from .mappings import yield_dict_init  # noqa
+from .ordered import OrderedFrozenSet  # noqa
+from .ordered import OrderedSet  # noqa
+from .persistent import PersistentMap  # noqa
+from .skiplist import SkipList  # noqa
+from .skiplist import SkipListDict  # noqa
+from .sorted import SortedCollection  # noqa
+from .sorted import SortedListDict  # noqa
+from .sorted import SortedMapping  # noqa
+from .sorted import SortedMutableMapping  # noqa
+from .treapmap import new_treap_map  # noqa
+from .unmodifiable import Unmodifiable  # noqa
+from .unmodifiable import UnmodifiableMapping  # noqa
+from .unmodifiable import UnmodifiableSequence  # noqa
+from .unmodifiable import UnmodifiableSet  # noqa
+from .utils import all_equal  # noqa
+from .utils import all_not_equal  # noqa
+from .utils import indexes  # noqa
+from .utils import key_cmp  # noqa
+from .utils import mut_toposort  # noqa
+from .utils import partition  # noqa
+from .utils import toposort  # noqa
+from .utils import unique  # noqa
+from .utils import unique_dict  # noqa

omlish/collections/_abc.py

@@ -0,0 +1,156 @@
+class Hashable:
+    def __hash__(self): ...
+
+
+class Iterable:
+    def __iter__(self): ...
+
+
+class Iterator(Iterable):
+    def __next__(self): ...
+
+
+class Reversible(Iterable):
+    def __reversed__(self): ...
+
+
+class Sized:
+    def __len__(self): ...
+
+
+class Container:
+    def __contains__(self, x): ...
+
+
+class Collection(Sized, Iterable, Container):
+    pass
+
+
+# region Sequence
+
+
+class Sequence(Reversible, Collection):
+    def __getitem__(self, index): ...
+
+    def index(self, value, start=0, stop=None): ...
+
+    def count(self, value): ...
+
+
+class MutableSequence(Sequence):
+    def __setitem__(self, index, value): ...
+
+    def __delitem__(self, index): ...
+
+    def insert(self, index, value): ...
+
+    def append(self, value): ...
+
+    def clear(self): ...
+
+    def reverse(self): ...
+
+    def extend(self, values): ...
+
+    def pop(self, index=-1): ...
+
+    def remove(self, value): ...
+
+    def __iadd__(self, values): ...
+
+
+# endregion
+
+
+# region Set
+
+
+class Set(Collection):
+    def __le__(self, other): ...
+
+    def __lt__(self, other): ...
+
+    def __gt__(self, other): ...
+
+    def __ge__(self, other): ...
+
+    def __eq__(self, other): ...
+
+    def __and__(self, other): ...
+
+    __rand__ = __and__
+
+    def isdisjoint(self, other): ...
+
+    def __or__(self, other): ...
+
+    __ror__ = __or__
+
+    def __sub__(self, other): ...
+
+    def __rsub__(self, other): ...
+
+    def __xor__(self, other): ...
+
+    __rxor__ = __xor__
+
+
+class MutableSet(Set):
+    def add(self, value): ...
+
+    def discard(self, value): ...
+
+    def remove(self, value): ...
+
+    def pop(self): ...
+
+    def clear(self): ...
+
+    def __ior__(self, it): ...
+
+    def __iand__(self, it): ...
+
+    def __ixor__(self, it): ...
+
+    def __isub__(self, it): ...
+
+
+# endregion
+
+
+# region Mapping
+
+
+class Mapping(Collection):
+    def __getitem__(self, key): ...
+
+    def get(self, key, default=None): ...
+
+    def keys(self): ...
+
+    def items(self): ...
+
+    def values(self): ...
+
+    def __eq__(self, other): ...
+
+    __reversed__ = None
+
+
+class MutableMapping(Mapping):
+    def __setitem__(self, key, value): ...
+
+    def __delitem__(self, key): ...
+
+    def pop(self, key, default=None): ...
+
+    def popitem(self): ...
+
+    def clear(self): ...
+
+    def update(self, other=(), **kwds): ...
+
+    def setdefault(self, key, default=None): ...
+
+
+# endregion

omlish/collections/_io_abc.py

@@ -0,0 +1,78 @@
+class IOBase:
+    def seek(self, pos, whence=0): ...
+
+    def tell(self): ...
+
+    def truncate(self, pos=None): ...
+
+    def flush(self): ...
+
+    def close(self): ...
+
+    def seekable(self): ...
+
+    def readable(self): ...
+
+    def writable(self): ...
+
+    @property
+    def closed(self): ...
+
+    def __enter__(self): ...
+
+    def __exit__(self, *args): ...
+
+    def fileno(self): ...
+
+    def isatty(self): ...
+
+    def readline(self, size=-1): ...
+
+    def readlines(self, hint=None): ...
+
+    def writelines(self, lines): ...
+
+
+class RawIOBase(IOBase):
+    def read(self, size=-1): ...
+
+    def readall(self): ...
+
+    def readinto(self, b): ...
+
+    def write(self, b): ...
+
+
+class BufferedIOBase(IOBase):
+    def read(self, size=-1): ...
+
+    def read1(self, size=-1): ...
+
+    def readinto(self, b): ...
+
+    def readinto1(self, b): ...
+
+    def write(self, b): ...
+
+    def detach(self): ...
+
+
+class TextIOBase(IOBase):
+    def read(self, size=-1): ...
+
+    def write(self, s): ...
+
+    def truncate(self, pos=None): ...
+
+    def readline(self): ...
+
+    def detach(self): ...
+
+    @property
+    def encoding(self): ...
+
+    @property
+    def newlines(self): ...
+
+    @property
+    def errors(self): ...