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

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/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
 

omlish/reflect.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - callables..
  - uniform collection isinstance - items() for mappings, iter() for other
  - also check instance type in isinstance not just items lol
  - ta.Generic in mro causing trouble - omit? no longer 1:1
@@ -7,12 +8,13 @@ TODO:
   - cache __hash__ in Generic/Union
 """
 import collections.abc
-import typing as ta
 import types
+import typing as ta
 
 from . import c3
 from . import lang
 
+
 if ta.TYPE_CHECKING:
     from .collections import cache
 else:
@@ -25,6 +27,7 @@ _NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+# _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
 
@@ -155,7 +158,10 @@ def type_(obj: ta.Any) -> Type:
     if isinstance(obj, ta.NewType):  # noqa
         return NewType(oty)
 
-    if oty is _GenericAlias or oty is ta.GenericAlias:  # type: ignore  # noqa
+    if (
+            oty is _GenericAlias or
+            oty is ta.GenericAlias  # type: ignore  # noqa
+    ):
         origin = ta.get_origin(obj)
         args = ta.get_args(obj)
         if origin is ta.Generic:

omlish/sync.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - sync (lol) w/ asyncs.anyio
+ - atomics
+"""
+import threading
+import typing as ta
+
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+class Once:
+    def __init__(self) -> None:
+        super().__init__()
+        self._done = False
+        self._lock = threading.Lock()
+
+    def do(self, fn: ta.Callable[[], None]) -> bool:
+        if self._done:
+            return False
+        with self._lock:
+            if self._done:
+                return False  # type: ignore
+            try:
+                fn()
+            finally:
+                self._done = True
+            return True
+
+
+class Lazy(ta.Generic[T]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    def get(self, fn: ta.Callable[[], T]) -> T:
+        def do():
+            self._v = lang.just(fn())
+        self._once.do(do)
+        return self._v.must()
+
+
+class LazyFn(ta.Generic[T]):
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        super().__init__()
+        self._fn = fn
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    def get(self) -> T:
+        def do():
+            self._v = lang.just(self._fn())
+        self._once.do(do)
+        return self._v.must()

omlish/term.py

@@ -213,8 +213,13 @@ def main() -> None:
 
     sys.stdout.write(SGR(SGRs.RESET))
     sys.stdout.write(BG8(15) + ' ')
-    for i in [196, 160, 124, 88, 52, 16]:
+    for i in range(20):
         sys.stdout.write(BG8(i) + ' ')
+    sys.stdout.write('\n')
+    for i in range(256):
+        if i % 12 == 0:
+            sys.stdout.write('\n')
+        sys.stdout.write(BG8(i + 16) + ' ')
     sys.stdout.write(SGR(SGRs.RESET) + '\n')
 
 

omlish/testing/pytest/__init__.py

@@ -2,7 +2,12 @@ from . import plugins  # noqa
 
 from .helpers import (  # noqa
     assert_raises_star,
+)
+
+from .marks import (  # noqa
+    drain_asyncio,
     skip_if_cant_import,
+    skip_if_nogil,
     skip_if_not_on_path,
     skip_if_python_version_less_than,
 )

omlish/testing/pytest/helpers.py

@@ -1,28 +1,4 @@
 import contextlib
-import shutil
-import sys
-import typing as ta
-
-import pytest
-
-from ..testing import can_import
-
-
-def skip_if_cant_import(module: str, *args, **kwargs):
-    return pytest.mark.skipif(not can_import(module, *args, **kwargs), reason=f'requires import {module}')
-
-
-def skip_if_not_on_path(exe: str):
-    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
-
-
-def skip_if_python_version_less_than(num: ta.Sequence[int]):
-    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
-
-
-def skip_if_not_single():
-    # [resolve_collection_argument(a) for a in session.config.args]
-    raise NotImplementedError
 
 
 @contextlib.contextmanager

omlish/testing/pytest/inject/harness.py

@@ -4,10 +4,10 @@ import typing as ta
 
 import pytest
 
-from .. import plugins
 from .... import check
 from .... import inject as inj
 from .... import lang
+from .. import plugins
 
 
 T = ta.TypeVar('T')

omlish/testing/pytest/marks.py

@@ -0,0 +1,48 @@
+import shutil
+import sys
+import sysconfig
+import typing as ta
+
+import pytest
+
+from ... import lang  # noqa
+from ..testing import can_import
+from .plugins.managermarks import ManagerMark  # noqa
+
+
+if ta.TYPE_CHECKING:
+    import asyncio
+else:
+    asyncio = lang.proxy_import('asyncio')
+
+
+def skip_if_cant_import(module: str, *args, **kwargs):
+    return pytest.mark.skipif(not can_import(module, *args, **kwargs), reason=f'requires import {module}')
+
+
+def skip_if_not_on_path(exe: str):
+    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
+
+
+def skip_if_python_version_less_than(num: ta.Sequence[int]):
+    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
+
+
+def skip_if_not_single():
+    # FIXME
+    # [resolve_collection_argument(a) for a in session.config.args]
+    raise NotImplementedError
+
+
+def skip_if_nogil():
+    return pytest.mark.skipif(sysconfig.get_config_var('Py_GIL_DISABLED'), reason='requires gil build')
+
+
+class drain_asyncio(ManagerMark):  # noqa
+    def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
+        loop = asyncio.get_event_loop()
+        try:
+            yield
+        finally:
+            while loop._ready or loop._scheduled:  # type: ignore  # noqa
+                loop._run_once()  # type: ignore  # noqa

omlish/testing/pytest/plugins/__init__.py

@@ -1,11 +1,13 @@
 from . import (  # noqa
     logging,
+    managermarks,
     pydevd,
     repeat,
     skips,
     spacing,
     switches,
 )
+
 from ._registry import (  # noqa
     ALL,
     register,

omlish/testing/pytest/plugins/managermarks.py

@@ -0,0 +1,60 @@
+import abc
+import contextlib
+import typing as ta
+
+import pytest
+
+from .... import lang
+from ._registry import register
+
+
+class ManagerMark(lang.Abstract):
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+    @abc.abstractmethod
+    def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
+        raise NotImplementedError
+
+
+def _deep_subclasses(cls):
+    ret = set()
+
+    def rec(cur):
+        for nxt in cur.__subclasses__():
+            if nxt not in ret:
+                ret.add(nxt)
+                rec(nxt)
+
+    rec(cls)
+    return ret
+
+
+@register
+class ManagerMarksPlugin:
+
+    @lang.cached_function
+    def mark_classes(self) -> ta.Mapping[str, type[ManagerMark]]:
+        return {
+            cls.__name__: cls
+            for cls in _deep_subclasses(ManagerMark)
+            if not lang.is_abstract_class(cls)
+        }
+
+    def pytest_configure(self, config):
+        for n in self.mark_classes():
+            config.addinivalue_line(
+                'markers',
+                f'{n}: mark to manage {n}',
+            )
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        with contextlib.ExitStack() as es:
+            for n, cls in self.mark_classes().items():
+                if (m := item.get_closest_marker(n)) is None:
+                    continue
+                inst = cls(*m.args, **m.kwargs)
+                es.enter_context(contextlib.contextmanager(inst)(item))
+
+            yield

omlish/testing/testing.py

@@ -1,6 +1,7 @@
 import functools
 import importlib
 import os
+import sys
 import threading
 import time
 import traceback
@@ -100,3 +101,12 @@ def xfail(fn):
             traceback.print_exc()
 
     return inner
+
+
+def raise_in_thread(thr: threading.Thread, exc: BaseException | type[BaseException]) -> None:
+    if sys.implementation.name != 'cpython':
+        raise RuntimeError(sys.implementation.name)
+
+    # https://github.com/python/cpython/blob/37ba7531a59a0a2b240a86f7e2adfb1b1cd8ac0c/Lib/test/test_threading.py#L182
+    import ctypes as ct
+    ct.pythonapi.PyThreadState_SetAsyncExc(ct.c_ulong(thr.ident), ct.py_object(exc))  # type: ignore

omlish/text/delimit.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - replace with codecs.StreamReader
+"""
 import io
 import typing as ta
 

{omlish-0.0.0.dev4.dist-info → omlish-0.0.0.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev4
+Version: 0.0.0.dev5
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause