omlish 0.0.0.dev1__py3-none-any.whl

omlish/iterators.py

@@ -0,0 +1,184 @@
+import collections
+import functools
+import itertools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+_MISSING = object()
+
+
+class PeekIterator(ta.Iterator[T]):
+
+    def __init__(self, it: ta.Iterator[T]) -> None:
+        super().__init__()
+
+        self._it = it
+        self._pos = -1
+        self._next_item: ta.Any = _MISSING
+
+    _item: T
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self
+
+    @property
+    def done(self) -> bool:
+        try:
+            self.peek()
+            return False
+        except StopIteration:
+            return True
+
+    def __next__(self) -> T:
+        if self._next_item is not _MISSING:
+            self._item = ta.cast(T, self._next_item)
+            self._next_item = _MISSING
+        else:
+            try:
+                self._item = next(self._it)
+            except StopIteration:
+                raise
+        self._pos += 1
+        return self._item
+
+    def peek(self) -> T:
+        if self._next_item is not _MISSING:
+            return ta.cast(T, self._next_item)
+        try:
+            self._next_item = next(self._it)
+        except StopIteration:
+            raise
+        return self._next_item
+
+    def next_peek(self) -> T:
+        next(self)
+        return self.peek()
+
+    def takewhile(self, fn):
+        while fn(self.peek()):
+            yield next(self)
+
+    def skipwhile(self, fn):
+        while fn(self.peek()):
+            next(self)
+
+    def takeuntil(self, fn):
+        return self.takewhile(lambda e: not fn(e))
+
+    def skipuntil(self, fn):
+        self.skipwhile(lambda e: not fn(e))
+
+    def takethrough(self, pos):
+        return self.takewhile(lambda _: self._pos < pos)
+
+    def skipthrough(self, pos):
+        self.skipwhile(lambda _: self._pos < pos)
+
+    def taketo(self, pos):
+        return self.takethrough(pos - 1)
+
+    def skipto(self, pos):
+        self.skipthrough(pos - 1)
+
+
+class ProxyIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        self._fn = fn
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self
+
+    def __next__(self) -> T:
+        return self._fn()
+
+
+class PrefetchIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Optional[ta.Callable[[], T]] = None) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._deque: ta.Deque[T] = collections.deque()
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self
+
+    def push(self, item) -> None:
+        self._deque.append(item)
+
+    def __next__(self) -> T:
+        try:
+            return self._deque.popleft()
+        except IndexError:
+            if self._fn is None:
+                raise StopIteration
+        return self._fn()
+
+
+class RetainIterator(ta.Iterator[T]):
+
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._deque: ta.Deque[T] = collections.deque()
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self
+
+    def pop(self) -> None:
+        self._deque.popleft()
+
+    def __next__(self) -> T:
+        item = self._fn()
+        self._deque.append(item)
+        return item
+
+
+def unzip(it: ta.Iterable[T], width: ta.Optional[int] = None) -> list:
+    if width is None:
+        if not isinstance(it, PeekIterator):
+            it = PeekIterator(iter(it))
+        try:
+            width = len(it.peek())
+        except StopIteration:
+            return []
+
+    its: list[PrefetchIterator[T]] = []
+    running = True
+
+    def next_fn(idx):
+        nonlocal running
+        if not running:
+            raise StopIteration
+        try:
+            items = next(it)  # type: ignore
+        except StopIteration:
+            running = False
+            raise
+        for item_idx, item in enumerate(items):
+            its[item_idx].push(item)
+        return next(its[idx])
+
+    its.extend(PrefetchIterator(functools.partial(next_fn, idx)) for idx in range(width))
+    return its
+
+
+def take(n: int, iterable: ta.Iterable[T]) -> list[T]:
+    return list(itertools.islice(iterable, n))
+
+
+def chunk(n: int, iterable: ta.Iterable[T], strict: bool = False) -> ta.Iterator[list[T]]:
+    iterator = iter(functools.partial(take, n, iter(iterable)), [])
+    if strict:
+        def ret():
+            for chunk in iterator:
+                if len(chunk) != n:
+                    raise ValueError('iterable is not divisible by n.')
+                yield chunk
+        return iter(ret())
+    else:
+        return iterator

omlish/json.py

@@ -0,0 +1,194 @@
+import functools
+import json as _json
+
+
+dump = _json.dump
+dumps = _json.dumps
+
+detect_encoding = _json.detect_encoding
+
+load = _json.load
+loads = _json.loads
+
+##
+
+
+PRETTY_INDENT = 2
+
+PRETTY_KWARGS = dict(
+    indent=PRETTY_INDENT,
+)
+
+dump_pretty = functools.partial(dump, **PRETTY_KWARGS)
+dumps_pretty = functools.partial(dumps, **PRETTY_KWARGS)
+
+##
+
+
+COMPACT_SEPARATORS = (',', ':')
+
+COMPACT_KWARGS = dict(
+    indent=0,
+    separators=COMPACT_SEPARATORS,
+)
+
+dump_compact = functools.partial(dump, **COMPACT_KWARGS)
+dumps_compact = functools.partial(dumps, **COMPACT_KWARGS)
+
+
+##
+
+
+# import functools
+# import typing as ta
+#
+# from . import cached
+# from . import dataclasses as dc
+#
+#
+# F = ta.TypeVar('F')
+# T = ta.TypeVar('T')
+# StrMap = ta.Mapping[str, ta.Any]
+#
+#
+# ENCODING = 'utf-8'
+# PRETTY_INDENT = 2
+# COMPACT_SEPARATORS = (',', ':')
+#
+#
+# Dumps = ta.Callable[[ta.Any], str]
+# Dumpb = ta.Callable[[ta.Any], bytes]
+# Loads = ta.Callable[[ta.Union[str, bytes, bytearray]], ta.Any]
+#
+#
+# @dc.dataclass(frozen=True)
+# class _Provider:
+#     pretty_kwargs: StrMap = dc.field(default_factory=dict)
+#     compact_kwargs: StrMap = dc.field(default_factory=dict)
+#
+#
+# class Provider:
+#
+#     def __init__(self, json: ta.Any) -> None:
+#         super().__init__()
+#         self._json = json
+#
+#     @property
+#     def json(self) -> ta.Any:
+#         return self._json
+#
+#     @cached.property
+#     def dumps(self) -> Dumps:
+#         return self.json.dumps
+#
+#     @cached.property
+#     def dumpb(self) -> Dumpb:
+#         def dumpb(*args, **kwargs):
+#             return fn(*args, **kwargs).encode(ENCODING)
+#         fn = self.json.dumps
+#         return functools.wraps(fn)(dumpb)
+#
+#     @cached.property
+#     def loads(self) -> Loads:
+#         return self.json.loads
+#
+#     @cached.property
+#     def pretty_kwargs(self) -> StrMap:
+#         return {}
+#
+#     @cached.property
+#     def compact_kwargs(self) -> StrMap:
+#         return {}
+#
+#
+# class OrjsonProvider(Provider):
+#
+#     def __init__(self) -> None:
+#         import orjson
+#         super().__init__(orjson)
+#
+#     @cached.property
+#     def pretty_kwargs(self) -> StrMap:
+#         return {
+#             'option': self.json.OPT_INDENT_2,
+#         }
+#
+#     @cached.property
+#     def dumps(self) -> Dumps:
+#         def dumps(*args, **kwargs):
+#             return fn(*args, **kwargs).decode(ENCODING)
+#         fn = self.json.dumps
+#         return functools.wraps(fn)(dumps)
+#
+#     @cached.property
+#     def dumpb(self) -> Dumpb:
+#         return self.json.dumps
+#
+#
+# class UjsonProvider(Provider):
+#
+#     def __init__(self) -> None:
+#         import ujson
+#         super().__init__(ujson)
+#
+#     @cached.property
+#     def pretty_kwargs(self) -> StrMap:
+#         return {
+#             'indent': PRETTY_INDENT,
+#         }
+#
+#     @cached.property
+#     def loads(self) -> Loads:
+#         def loads(arg, *args, **kwargs):
+#             if isinstance(arg, (bytes, bytearray)):
+#                 arg = arg.decode(ENCODING)
+#             return fn(arg, *args, **kwargs)
+#         fn = self.json.loads
+#         return functools.wraps(fn)(loads)
+#
+#
+# class BuiltinProvider(Provider):
+#
+#     def __init__(self) -> None:
+#         import json
+#         super().__init__(json)
+#
+#     @cached.property
+#     def pretty_kwargs(self) -> StrMap:
+#         return {
+#             'indent': PRETTY_INDENT,
+#         }
+#
+#     @cached.property
+#     def compact_kwargs(self) -> StrMap:
+#         return {
+#             'indent': 0,
+#             'separators': COMPACT_SEPARATORS,
+#         }
+#
+#
+# def _select_provider(typs: ta.Iterable[ta.Callable[[], Provider]]) -> Provider:
+#     for typ in typs:
+#         try:
+#             return typ()
+#         except ImportError:
+#             pass
+#     raise TypeError('No suitable json providers')
+#
+#
+# PROVIDER: Provider = _select_provider([
+#     OrjsonProvider,
+#     UjsonProvider,
+#     BuiltinProvider,
+# ])
+#
+#
+# dumps: Dumps = PROVIDER.dumps
+# dumpb: Dumpb = PROVIDER.dumpb
+# loads: Loads = PROVIDER.loads
+#
+# dumps_compact: Dumps = functools.partial(dumps, **PROVIDER.compact_kwargs)
+# dumpb_compact: Dumpb = functools.partial(dumpb, **PROVIDER.compact_kwargs)
+#
+# dumps_pretty: Dumps = functools.partial(dumps, **PROVIDER.pretty_kwargs)
+# dumpb_pretty: Dumpb = functools.partial(dumpb, **PROVIDER.pretty_kwargs)

omlish/lang/__init__.py

@@ -0,0 +1,112 @@
+from .cached import cached_function  # noqa
+from .cached import cached_property  # noqa
+from .classes import Abstract # noqa
+from .classes import Callable  # noqa
+from .classes import Descriptor  # noqa
+from .classes import Final  # noqa
+from .classes import FinalException  # noqa
+from .classes import LazySingleton  # noqa
+from .classes import Marker  # noqa
+from .classes import Namespace  # noqa
+from .classes import NoBool  # noqa
+from .classes import NotInstantiable  # noqa
+from .classes import NotPicklable  # noqa
+from .classes import PackageSealed  # noqa
+from .classes import Picklable  # noqa
+from .classes import Sealed  # noqa
+from .classes import SealedException  # noqa
+from .classes import SimpleMetaDict  # noqa
+from .classes import Singleton  # noqa
+from .classes import Virtual  # noqa
+from .classes import is_abstract # noqa
+from .classes import is_abstract_class # noqa
+from .classes import is_abstract_method # noqa
+from .classes import make_abstract  # noqa
+from .classes import no_bool  # noqa
+from .classes import virtual_check  # noqa
+from .clsdct import ClassDctFn  # noqa
+from .clsdct import cls_dct_fn  # noqa
+from .clsdct import get_caller_cls_dct  # noqa
+from .clsdct import is_possibly_cls_dct  # noqa
+from .cmp import Infinity  # noqa
+from .cmp import InfinityType  # noqa
+from .cmp import NegativeInfinity  # noqa
+from .cmp import NegativeInfinityType  # noqa
+from .cmp import cmp  # noqa
+from .contextmanagers import ContextManaged  # noqa
+from .contextmanagers import ContextWrapped  # noqa
+from .contextmanagers import DefaultLockable  # noqa
+from .contextmanagers import ExitStacked  # noqa
+from .contextmanagers import Lockable  # noqa
+from .contextmanagers import NOP_CONTEXT_MANAGED  # noqa
+from .contextmanagers import NOP_CONTEXT_MANAGER  # noqa
+from .contextmanagers import NopContextManaged  # noqa
+from .contextmanagers import NopContextManager  # noqa
+from .contextmanagers import a_defer  # noqa
+from .contextmanagers import attr_setting  # noqa
+from .contextmanagers import breakpoint_on_exception  # noqa
+from .contextmanagers import context_var_setting  # noqa
+from .contextmanagers import context_wrapped  # noqa
+from .contextmanagers import default_lock  # noqa
+from .contextmanagers import defer  # noqa
+from .contextmanagers import disposing  # noqa
+from .contextmanagers import maybe_managing  # noqa
+from .datetimes import months_ago  # noqa
+from .datetimes import parse_date  # noqa
+from .datetimes import parse_timedelta  # noqa
+from .datetimes import to_seconds  # noqa
+from .descriptors import AccessForbiddenException  # noqa
+from .descriptors import access_forbidden  # noqa
+from .descriptors import is_method_descriptor  # noqa
+from .descriptors import unwrap_method_descriptors  # noqa
+from .functions import VoidException  # noqa
+from .functions import constant  # noqa
+from .functions import identity  # noqa
+from .functions import is_lambda  # noqa
+from .functions import is_none  # noqa
+from .functions import is_not_none  # noqa
+from .functions import maybe_call  # noqa
+from .functions import raise_  # noqa
+from .functions import recurse  # noqa
+from .functions import ticking_timeout  # noqa
+from .functions import try_  # noqa
+from .functions import unwrap_func  # noqa
+from .functions import unwrap_func_with_partials  # noqa
+from .functions import void  # noqa
+from .imports import import_all  # noqa
+from .imports import import_module  # noqa
+from .imports import import_module_attr  # noqa
+from .imports import lazy_import  # noqa
+from .imports import proxy_import  # noqa
+from .imports import try_import  # noqa
+from .imports import yield_import_all  # noqa
+from .imports import yield_importable  # noqa
+from .iterables import BUILTIN_SCALAR_ITERABLE_TYPES  # noqa
+from .iterables import asrange  # noqa
+from .iterables import exhaust  # noqa
+from .iterables import ilen  # noqa
+from .iterables import peek  # noqa
+from .iterables import prodrange  # noqa
+from .iterables import take  # noqa
+from .maybes import Maybe  # noqa
+from .maybes import empty  # noqa
+from .maybes import just  # noqa
+from .maybes import maybe  # noqa
+from .objects import SimpleProxy  # noqa
+from .objects import arg_repr  # noqa
+from .objects import attr_repr  # noqa
+from .objects import new_type  # noqa
+from .objects import super_meta  # noqa
+from .strings import camel_case  # noqa
+from .strings import indent_lines  # noqa
+from .strings import is_dunder  # noqa
+from .strings import is_ident  # noqa
+from .strings import is_ident_cont  # noqa
+from .strings import is_ident_start  # noqa
+from .strings import is_sunder  # noqa
+from .strings import prefix_lines  # noqa
+from .strings import snake_case  # noqa
+from .typing import BytesLike  # noqa
+from .typing import protocol_check  # noqa
+from .typing import typed_lambda  # noqa
+from .typing import typed_partial  # noqa