omlish 0.0.0.dev3__py3-none-any.whl → 0.0.0.dev5__py3-none-any.whl

omlish/inject/multis.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - scopes
+"""
+import collections.abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .. import reflect as rfl
+from .bindings import Binding
+from .elements import Element
+from .keys import Key
+from .keys import as_key
+from .providers import Provider
+
+
+##
+
+
+def _check_set_multi_key(mk: Key) -> bool:
+    return rfl.get_concrete_type(mk.ty) is collections.abc.Set
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class SetBinding(Element, lang.Final):
+    multi_key: Key = dc.xfield(check=_check_set_multi_key)
+    dst: Key = dc.xfield()
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SetProvider(Provider):
+    multi_key: Key = dc.xfield(check=_check_set_multi_key)
+
+    def provided_ty(self) -> rfl.Type | None:
+        return self.multi_key.ty
+
+
+def bind_set_provider(multi_key: ta.Any) -> Element:
+    multi_key = as_key(multi_key)
+    return Binding(multi_key, SetProvider(multi_key))
+
+
+##
+
+
+def _check_map_multi_key(mk: Key) -> bool:
+    return rfl.get_concrete_type(mk.ty) is collections.abc.Mapping
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class MapBinding(Element, lang.Final):
+    multi_key: Key = dc.xfield(check=_check_map_multi_key)
+    map_key: ta.Any = dc.xfield(())
+    dst: Key = dc.xfield(())
+
+
+@dc.dataclass(frozen=True, eq=False)
+class MapProvider(Provider):
+    multi_key: Key = dc.xfield(check=_check_map_multi_key)
+
+    def provided_ty(self) -> rfl.Type | None:
+        return self.multi_key.ty
+
+
+def bind_map_provider(multi_key: ta.Any) -> Element:
+    multi_key = as_key(multi_key)
+    return Binding(multi_key, MapProvider(multi_key))

omlish/inject/providers.py

@@ -4,12 +4,12 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
 from .elements import Element
 from .elements import Elements
 from .impl.inspect import signature
 from .keys import Key
 from .keys import as_key
-from .types import Cls
 
 
 class _Missing(lang.NotInstantiable):
@@ -21,7 +21,7 @@ class _Missing(lang.NotInstantiable):
 
 class Provider(lang.Abstract):
     @abc.abstractmethod
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         raise NotImplementedError
 
 
@@ -47,19 +47,19 @@ def as_provider(o: ta.Any) -> Provider:
 @dc.dataclass(frozen=True, eq=False)
 class FnProvider(Provider):
     fn: ta.Any
-    cls: Cls | None = None
+    ty: rfl.Type | None = None
 
-    def provided_cls(self) -> Cls | None:
-        return self.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.ty
 
 
-def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
+def fn(fn: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
     check.not_isinstance(fn, type)
     check.callable(fn)
-    if cls is _Missing:
+    if ty is _Missing:
         sig = signature(fn)
-        cls = check.isinstance(sig.return_annotation, type)
-    return FnProvider(fn, cls)
+        ty = check.isinstance(sig.return_annotation, type)
+    return FnProvider(fn, ty)
 
 
 ##
@@ -67,15 +67,15 @@ def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
 
 @dc.dataclass(frozen=True, eq=False)
 class CtorProvider(Provider):
-    cls: type
+    ty: type
 
-    def provided_cls(self) -> Cls:
-        return self.cls
+    def provided_ty(self) -> type:
+        return self.ty
 
 
-def ctor(cls: type) -> Provider:
-    check.isinstance(cls, type)
-    return CtorProvider(cls)
+def ctor(ty: type) -> Provider:
+    check.isinstance(ty, type)
+    return CtorProvider(ty)
 
 
 ##
@@ -84,16 +84,16 @@ def ctor(cls: type) -> Provider:
 @dc.dataclass(frozen=True, eq=False)
 class ConstProvider(Provider):
     v: ta.Any
-    cls: Cls | None = None
+    ty: rfl.Type | None = None
 
-    def provided_cls(self) -> Cls | None:
-        return self.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.ty
 
 
-def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
-    if cls is _Missing:
-        cls = type(v)
-    return ConstProvider(v, cls)
+def const(v: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
+    if ty is _Missing:
+        ty = type(v)
+    return ConstProvider(v, ty)
 
 
 ##
@@ -103,7 +103,7 @@ def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
 class LinkProvider(Provider):
     k: Key
 
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         return None
 
 

omlish/inject/scopes.py

@@ -5,21 +5,25 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
 from .bindings import Binding
 from .bindings import as_binding
 from .elements import Element
 from .keys import Key
 from .keys import as_key
 from .providers import Provider
-from .types import Cls
 from .types import Scope
 
+
 if ta.TYPE_CHECKING:
     from . import injector as injector_
 else:
     injector_ = lang.proxy_import('.injector', __package__)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
@@ -65,8 +69,8 @@ class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
-    def provided_cls(self) -> Cls | None:
-        return self.key.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.key.ty
 
 
 def bind_scope_seed(ss: SeededScope, k: ta.Any) -> Element:

omlish/inject/types.py

@@ -1,17 +1,9 @@
-import typing as ta
-
 from .. import lang
 
 
 ##
 
 
-Cls = type | ta.NewType
-
-
-##
-
-
 class Scope(lang.Abstract):
     def __repr__(self) -> str:
         return type(self).__name__

omlish/iterators.py

@@ -218,3 +218,16 @@ def expand_indexed_pairs(
         if idx < width_:
             result[idx] = value
     return result
+
+
+##
+# https://docs.python.org/3/library/itertools.html#itertools-recipes
+
+
+def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
+    # sliding_window('ABCDEFG', 4) -> ABCD BCDE CDEF DEFG
+    iterator = iter(it)
+    window = collections.deque(itertools.islice(iterator, n - 1), maxlen=n)
+    for x in iterator:
+        window.append(x)
+        yield tuple(window)

omlish/json.py

@@ -1,7 +1,143 @@
+"""
+json
+  dump
+    skipkeys=False
+    ensure_ascii=True
+    check_circular=True
+    allow_nan=True
+    cls=None
+    indent=None
+    separators=None
+    default=None
+    sort_keys=False
+  dumps
+    ^
+  load
+    cls=None
+    object_hook=None
+    parse_float=None
+    parse_int=None
+    parse_constant=None
+    object_pairs_hook=None
+  loads
+    ^
+
+ujson
+  dump
+    ensure_ascii
+    encode_html_chars
+    escape_forward_slashes
+    sort_keys
+    indent
+    allow_nan
+    reject_bytes
+    default
+    separators
+  dumps
+    ^
+  load
+  loads
+
+orjson
+  dumps
+    default
+    option
+      OPT_INDENT_2
+      OPT_NAIVE_UTC
+      OPT_NON_STR_KEYS
+      OPT_OMIT_MICROSECONDS
+      OPT_PASSTHROUGH_DATACLASS
+      OPT_PASSTHROUGH_DATETIME
+      OPT_PASSTHROUGH_SUBCLASS
+      OPT_SERIALIZE_DATACLASS
+      OPT_SERIALIZE_NUMPY
+      OPT_SERIALIZE_UUID
+      OPT_SORT_KEYS
+      OPT_STRICT_INTEGER
+      OPT_UTC_Z
+  loads
+
+rapidjson
+  dump
+    skipkeys=False,
+    ensure_ascii=True,
+    write_mode=WM_COMPACT,
+      WM_COMPACT
+      WM_PRETTY
+      WM_SINGLE_LINE_ARRAY
+    indent=4,
+    default=None,
+    sort_keys=False,
+    number_mode=None,
+      NM_NONE
+      NM_DECIMAL
+      NM_NAN
+      NM_NATIVE
+    datetime_mode=None,
+      DM_NONE
+      DM_ISO8601
+      DM_UNIX_TIME
+      DM_ONLY_SECONDS
+      DM_IGNORE_TZ
+      DM_NAIVE_IS_UTC
+      DM_SHIFT_TO_UTC
+    uuid_mode=None,
+      UM_NONE
+      UM_CANONICAL
+      UM_HEX
+    bytes_mode=BM_UTF8,
+      BM_NONE
+      BM_UTF8
+    iterable_mode=IM_ANY_ITERABLE,
+      IM_ANY_ITERABLE
+      IM_ONLY_LISTS
+    mapping_mode=MM_ANY_MAPPING,
+      MM_ANY_MAPPING
+      MM_ONLY_DICTS
+      MM_COERCE_KEYS_TO_STRINGS
+      MM_SKIP_NON_STRING_KEYS
+      MM_SORT_KEYS
+    chunk_size
+    allow_nan=True
+  dumps
+    ^
+    -chunk_size
+  load
+    object_hook=None,
+    number_mode=None,
+      ^
+    datetime_mode=None,
+      ^
+    uuid_mode=None,
+      ^
+    parse_mode=None,
+      PM_NONE
+      PM_COMMENTS
+      PM_TRAILING_COMMAS
+    chunk_size=65536,
+    allow_nan=True
+  loads
+    ^
+    -chunk_size
+
+"""
 import functools
 import json as _json
 import typing as ta
 
+from . import lang
+
+
+if ta.TYPE_CHECKING:
+    import orjson as _orjson
+    import ujson as _ujson
+else:
+    _orjson = lang.proxy_import('orjson')
+    _ujson = lang.proxy_import('ujson')
+
+
+##
+
 
 dump = _json.dump
 dumps = _json.dumps
@@ -11,6 +147,7 @@ detect_encoding = _json.detect_encoding
 load = _json.load
 loads = _json.loads
 
+
 ##
 
 
@@ -29,7 +166,7 @@ dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 COMPACT_SEPARATORS = (',', ':')
 
 COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=0,
+    indent=None,
     separators=COMPACT_SEPARATORS,
 )
 

omlish/lang/__init__.py

@@ -46,7 +46,9 @@ from .cmp import (  # noqa
 )
 
 from .contextmanagers import (  # noqa
+    AsyncContextManager,
     ContextManaged,
+    ContextManager,
     ContextWrapped,
     DefaultLockable,
     ExitStacked,
@@ -90,6 +92,7 @@ from .exceptions import (  # noqa
 from .functions import (  # noqa
     Args,
     VoidError,
+    as_async,
     constant,
     finally_,
     identity,
@@ -108,6 +111,7 @@ from .functions import (  # noqa
 )
 
 from .imports import (  # noqa
+    can_import,
     import_all,
     import_module,
     import_module_attr,
@@ -156,6 +160,10 @@ from .strings import (  # noqa
     snake_case,
 )
 
+from .sys import (  # noqa
+    is_gil_enabled,
+)
+
 from .timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

omlish/lang/classes/restrict.py

@@ -89,7 +89,7 @@ class PackageSealed:
 class NotInstantiable(Abstract):
     __slots__ = ()
 
-    def __new__(cls, *args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:  # noqa
+    def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
 

omlish/lang/classes/virtual.py

@@ -3,8 +3,8 @@ import types
 import typing as ta
 
 from .abstract import make_abstract
-from .restrict import NotInstantiable
 from .restrict import Final
+from .restrict import NotInstantiable
 
 
 T = ta.TypeVar('T')
@@ -122,7 +122,7 @@ class Callable(NotInstantiable, Final, ta.Generic[T]):
 
     @classmethod
     def __subclasscheck__(cls, subclass: type) -> bool:
-        if not hasattr(subclass, '__call__'):
+        if not hasattr(subclass, '__call__'):  # noqa
             return False
         call = subclass.__call__
         if isinstance(call, types.MethodWrapperType) and call.__self__ is subclass:

omlish/lang/contextmanagers.py

@@ -1,3 +1,4 @@
+import abc
 import contextlib
 import contextvars
 import functools
@@ -50,6 +51,69 @@ NOP_CONTEXT_MANAGER = NopContextManager()
 ##
 
 
+class ContextManager(abc.ABC, ta.Generic[T]):
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not hasattr(cls.__contextmanager__, '_is_contextmanager'):
+            cls.__contextmanager__ = contextlib.contextmanager(cls.__contextmanager__)  # type: ignore  # noqa
+            cls.__contextmanager__._is_contextmanager = True  # type: ignore  # noqa
+
+    @abc.abstractmethod
+    def __contextmanager__(self) -> ta.Iterable[T]:
+        raise NotImplementedError
+
+    __contextmanager__._is_contextmanager = True  # type: ignore  # noqa
+
+    _contextmanager: ta.Any
+
+    def __enter__(self) -> T:
+        self._contextmanager = self.__contextmanager__()
+        return self._contextmanager.__enter__()  # type: ignore
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> None:
+        return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
+
+
+class AsyncContextManager(abc.ABC, ta.Generic[T]):
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not hasattr(cls.__asynccontextmanager__, '_is_asynccontextmanager'):
+            cls.__asynccontextmanager__ = contextlib.asynccontextmanager(cls.__asynccontextmanager__)  # type: ignore  # noqa
+            cls.__asynccontextmanager__._is_asynccontextmanager = True  # type: ignore  # noqa
+
+    @abc.abstractmethod
+    def __asynccontextmanager__(self) -> ta.AsyncIterator[T]:
+        raise NotImplementedError
+
+    __asynccontextmanager__._is_asynccontextmanager = True  # type: ignore  # noqa
+
+    _asynccontextmanager: ta.Any
+
+    async def __aenter__(self) -> T:
+        self._asynccontextmanager = self.__asynccontextmanager__()
+        return await self._asynccontextmanager.__aenter__()  # type: ignore
+
+    async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> None:
+        return await self._asynccontextmanager.__aexit__(exc_type, exc_val, exc_tb)
+
+
+##
+
+
 @contextlib.contextmanager
 def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
     try:

omlish/lang/datetimes.py

@@ -18,17 +18,18 @@ def months_ago(date: datetime.date, num: int) -> datetime.date:
     return datetime.date(ago_year, ago_month, 1)
 
 
-def parse_date(s: str) -> datetime.date:
+def parse_date(s: str, tz: datetime.timezone | None = None) -> datetime.date:
+
     if s.lower() in ['today', 'now']:
-        return datetime.date.today()
+        return datetime.datetime.now(tz=tz)
     elif s.lower() == 'yesterday':
-        return datetime.date.today() - datetime.timedelta(days=1)
+        return datetime.datetime.now(tz=tz) - datetime.timedelta(days=1)
     elif s.lower().endswith(' days ago'):
         num = int(s.split(' ', 1)[0])
-        return datetime.date.today() - datetime.timedelta(days=num)
+        return datetime.datetime.now(tz=tz) - datetime.timedelta(days=num)
     elif s.lower().endswith(' months ago'):
         months = int(s.split(' ', 1)[0])
-        return months_ago(datetime.date.today(), months)
+        return months_ago(datetime.datetime.now(tz=tz), months)
     else:
         return datetime.date(*map(int, s.split('-', 3)))
 

omlish/lang/functions.py

@@ -148,6 +148,16 @@ def void(*args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
 ##
 
 
+def as_async(fn: ta.Callable[P, T]) -> ta.Callable[P, ta.Awaitable[T]]:
+    @functools.wraps(fn)
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+    return inner
+
+
+##
+
+
 _MISSING = object()
 
 

omlish/lang/imports.py

@@ -1,6 +1,6 @@
 import contextlib
 import functools
-import importlib.resources
+import importlib.util
 import sys
 import types
 import typing as ta
@@ -11,6 +11,13 @@ from .cached import cached_function
 ##
 
 
+def can_import(name: str, package: str | None = None) -> bool:
+    return importlib.util.find_spec(name, package) is not None
+
+
+##
+
+
 def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any]:
     return cached_function(functools.partial(importlib.import_module, name, package=package))
 
@@ -66,6 +73,8 @@ def yield_importable(
         filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> ta.Iterator[str]:
+    from importlib import resources
+
     def rec(cur):
         if cur.split('.')[-1] == '__pycache__':
             return
@@ -83,7 +92,7 @@ def yield_importable(
         if getattr(module, '__file__', None) is None:
             return
 
-        for file in importlib.resources.files(cur).iterdir():
+        for file in resources.files(cur).iterdir():
             if file.is_file() and file.name.endswith('.py'):
                 if not (include_special or file.name not in SPECIAL_IMPORTABLE):
                     continue

omlish/lang/sys.py

@@ -0,0 +1,7 @@
+import sys
+
+
+def is_gil_enabled() -> bool:
+    if (fn := getattr(sys, '_is_gil_enabled', None)) is not None:
+        return fn()
+    return True

omlish/lang/typing.py

@@ -3,6 +3,7 @@ TODO:
  - typed_lambda is really kinda just 'annotate'
  - TypedLambda / TypedPartial classes, picklable, reprs
   - probably need to gen types per inst
+ - typed_factory
 """
 import functools
 import inspect

omlish/logs/utils.py

@@ -12,7 +12,7 @@ def error_logging(log=log):  # noqa
             try:
                 return fn(*args, **kwargs)
             except Exception:
-                log.exception(f'Error in {fn!r}')
+                log.exception('Error in %r', fn)
                 raise
 
         return inner

omlish/marshal/datetimes.py

@@ -67,7 +67,7 @@ class DatetimeUnmarshaler(Unmarshaler):
 
         for fmt in self.fmts:
             try:
-                return datetime.datetime.strptime(v, fmt)
+                return datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
             except ValueError:
                 pass