omlish 0.0.0.dev0__tar.gz → 0.0.0.dev1__tar.gz

omlish-0.0.0.dev1/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude **/conftest.py

{omlish-0.0.0.dev0/omlish.egg-info → omlish-0.0.0.dev1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev0
+Version: 0.0.0.dev1
 Summary: omlish
-Home-page: https://github.com/wrmsr/omlish
 Author: wrmsr
-License: BSD
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

omlish-0.0.0.dev1/omlish/__about__.py

@@ -0,0 +1,7 @@
+__name__ = 'omlish'
+__author__ = 'wrmsr'
+__url__ = 'https://github.com/wrmsr/omlish'
+__license__ = 'BSD-3-Clause'
+__requires_python__ = '>=3.11'
+
+__version__ = '0.0.0.dev1'

{omlish-0.0.0.dev0 → omlish-0.0.0.dev1}/omlish/asyncs/__init__.py

@@ -1,12 +1,17 @@
 from .asyncs import (  # noqa
-    AsyncTimeoutException,
-    FutureException,
-    ImmediateExecutor,
     SyncableIterable,
     async_list,
-    await_dependent_futures,
-    await_futures,
     sync_await,
     sync_list,
     syncable_iterable,
 )
+
+
+from .futures import (  # noqa
+    FutureException,
+    FutureTimeoutException,
+    ImmediateExecutor,
+    new_thread_or_immediate_executor,
+    wait_dependent_futures,
+    wait_futures,
+)

omlish-0.0.0.dev1/omlish/asyncs/anyio.py

@@ -0,0 +1,23 @@
+"""
+lookit:
+ - https://github.com/davidbrochart/sqlite-anyio/blob/a3ba4c6ef0535b14a5a60071fcd6ed565a514963/sqlite_anyio/sqlite.py
+ - https://github.com/rafalkrupinski/ratelimit-anyio/blob/2910a8a3d6fa54ed17ee6ba457686c9f7a4c4beb/src/ratelimit_anyio/__init__.py
+ - https://github.com/nekitdev/async-extensions/tree/main/async_extensions
+ - https://github.com/kinnay/anynet/tree/master/anynet
+ - https://github.com/M-o-a-T/asyncscope
+ - https://github.com/M-o-a-T/aevent
+ - https://github.com/florimondmanca/aiometer
+"""  # noqa
+import typing as ta
+
+import anyio
+
+
+T = ta.TypeVar('T')
+
+
+async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.Any, **kwargs: ta.Any) -> T | bytes:
+    try:
+        return await fn(*args, **kwargs)
+    except anyio.EndOfStream:
+        return b''

omlish-0.0.0.dev1/omlish/asyncs/asyncs.py

@@ -0,0 +1,76 @@
+"""
+TODO:
+ - async<->sync greeenlet bridge
+  In [5]: %timeit greenlet.greenlet(f).switch()
+  517 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
+  - injected io provider - sync vs greenlet aio trampolined
+ - push/pull bridge?
+
+https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
+"""
+import contextlib
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
+    ret: ta.Any
+    ret = missing = object()
+
+    async def gate():
+        nonlocal ret
+        ret = await fn(*args, **kwargs)  # type: ignore
+
+    cr = gate()
+    with contextlib.closing(cr):
+        try:
+            cr.send(None)
+        except StopIteration:
+            pass
+        if ret is missing or cr.cr_await is not None or cr.cr_running:
+            raise TypeError('Not terminated')
+
+    return ta.cast(T, ret)
+
+
+def sync_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
+    lst = None
+
+    async def inner():
+        nonlocal lst
+        lst = [v async for v in fn(*args, **kwargs)]
+
+    sync_await(inner)
+    if not isinstance(lst, list):
+        raise TypeError(lst)
+    return lst
+
+
+async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
+    return [v async for v in fn(*args, **kwargs)]
+
+
+class SyncableIterable(ta.Generic[T]):
+
+    def __init__(self, obj) -> None:
+        super().__init__()
+        self._obj = obj
+
+    def __iter__(self) -> ta.Iterator[T]:
+        async def inner():
+            async for i in self._obj:
+                yield i
+        return iter(sync_list(inner))
+
+    def __aiter__(self) -> ta.AsyncIterator[T]:
+        return self._obj.__aiter__()
+
+
+def syncable_iterable(fn: ta.Callable[..., ta.AsyncIterator[T]]) -> ta.Callable[..., SyncableIterable[T]]:
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        return SyncableIterable(fn(*args, **kwargs))
+    return inner

omlish-0.0.0.dev0/omlish/asyncs/asyncs.py → omlish-0.0.0.dev1/omlish/asyncs/futures.py

@@ -1,104 +1,13 @@
-"""
-TODO:
- - async<->sync greeenlet bridge
-  In [5]: %timeit greenlet.greenlet(f).switch()
-  517 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
-  - injected io provider - sync vs greenlet aio trampolined
- - push/pull bridge?
-
-https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
-"""
 import concurrent.futures as cf
 import contextlib
-import functools
 import time
 import typing as ta
 
 
 T = ta.TypeVar('T')
-CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 
-def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
-    ret: ta.Any
-    ret = missing = object()
-
-    async def gate():
-        nonlocal ret
-        ret = await fn(*args, **kwargs)  # type: ignore
-
-    cr = gate()
-    with contextlib.closing(cr):
-        try:
-            cr.send(None)
-        except StopIteration:
-            pass
-        if ret is missing or cr.cr_await is not None or cr.cr_running:
-            raise TypeError('Not terminated')
-
-    return ta.cast(T, ret)
-
-
-def sync_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
-    lst = None
-
-    async def inner():
-        nonlocal lst
-        lst = [v async for v in fn(*args, **kwargs)]
-
-    sync_await(inner)
-    if not isinstance(lst, list):
-        raise TypeError(lst)
-    return lst
-
-
-async def async_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]:
-    return [v async for v in fn(*args, **kwargs)]
-
-
-class SyncableIterable(ta.Generic[T]):
-
-    def __init__(self, obj) -> None:
-        super().__init__()
-        self._obj = obj
-
-    def __iter__(self) -> ta.Iterator[T]:
-        async def inner():
-            async for i in self._obj:
-                yield i
-        return iter(sync_list(inner))
-
-    def __aiter__(self) -> ta.AsyncIterator[T]:
-        return self._obj.__aiter__()
-
-
-def syncable_iterable(fn: ta.Callable[..., ta.AsyncIterator[T]]) -> ta.Callable[..., SyncableIterable[T]]:
-    @functools.wraps(fn)
-    def inner(*args, **kwargs):
-        return SyncableIterable(fn(*args, **kwargs))
-    return inner
-
-
-class ImmediateExecutor(cf.Executor):
-
-    def __init__(self, *, immediate_exceptions: bool = False) -> None:
-        super().__init__()
-        self._immediate_exceptions = immediate_exceptions
-
-    def submit(self, fn, *args, **kwargs):
-        future: ta.Any = cf.Future()
-        try:
-            result = fn(*args, **kwargs)
-            future.set_result(result)
-        except Exception as e:
-            if self._immediate_exceptions:
-                raise
-            future.set_exception(e)
-        return future
-
-
-class AsyncTimeoutException(Exception):
-    pass
+##
 
 
 class FutureException(Exception, ta.Generic[T]):
@@ -128,7 +37,11 @@ class FutureException(Exception, ta.Generic[T]):
     __str__ = __repr__
 
 
-def await_futures(
+class FutureTimeoutException(Exception):
+    pass
+
+
+def wait_futures(
         futures: ta.Sequence[cf.Future],
         *,
         timeout_s: ta.Union[int, float] = 60,
@@ -155,13 +68,13 @@ def await_futures(
             return True
 
         if time.time() >= (start + timeout_s):
-            raise AsyncTimeoutException
+            raise FutureTimeoutException
         time.sleep(tick_interval_s)
 
     return False
 
 
-def await_dependent_futures(
+def wait_dependent_futures(
         executor: cf.Executor,
         dependency_sets_by_fn: ta.Mapping[ta.Callable, ta.AbstractSet[ta.Callable]],
         *,
@@ -215,7 +128,7 @@ def await_dependent_futures(
 
         if time.time() >= (start + timeout_s):
             cancel()
-            raise AsyncTimeoutException
+            raise FutureTimeoutException
 
     remaining_fns = {fn: deps for fn, deps in remaining_dep_sets_by_fn.items() if deps}
     if remaining_fns:
@@ -223,3 +136,44 @@ def await_dependent_futures(
 
     futs_by_fn = {fn: fut for fut, fn in fns_by_fut.items()}
     return futs_by_fn
+
+
+##
+
+
+class ImmediateExecutor(cf.Executor):
+
+    def __init__(self, *, immediate_exceptions: bool = False) -> None:
+        super().__init__()
+        self._immediate_exceptions = immediate_exceptions
+
+    def submit(self, fn, *args, **kwargs):
+        future: ta.Any = cf.Future()
+        try:
+            result = fn(*args, **kwargs)
+            future.set_result(result)
+        except Exception as e:
+            if self._immediate_exceptions:
+                raise
+            future.set_exception(e)
+        return future
+
+
+@contextlib.contextmanager
+def new_thread_or_immediate_executor(
+        max_workers: int | None = None,
+        *,
+        immediate_exceptions: bool = False,
+        thread_name_prefix: str = '',
+        **kwargs: ta.Any,
+) -> ta.Generator[cf.Executor, None, None]:
+    if max_workers == 0:
+        yield ImmediateExecutor(
+            immediate_exceptions=immediate_exceptions,
+        )
+    else:
+        with cf.ThreadPoolExecutor(
+                thread_name_prefix=thread_name_prefix,
+                **kwargs,
+        ) as exe:
+            yield exe

omlish-0.0.0.dev1/omlish/asyncs/trio.py

@@ -0,0 +1,11 @@
+"""
+lookit:
+ - https://github.com/oremanj/trio-monitor
+ - https://github.com/python-trio/trio-monitor/tree/master
+ - https://github.com/python-trio/triopg
+ - https://github.com/python-trio/trio-mysql
+ - https://github.com/goodboy/tractor
+ - https://github.com/groove-x/trio-util
+ - https://github.com/oremanj/tricycle/tree/master
+ - https://github.com/linkdd/triotp
+"""

{omlish-0.0.0.dev0 → omlish-0.0.0.dev1}/omlish/dataclasses/impl/main.py

@@ -16,12 +16,12 @@ from .order import OrderProcessor
 from .params import ParamsExtras
 from .processing import Processor
 from .reflect import ClassInfo
+from .replace import ReplaceProcessor
 from .repr import ReprProcessor
 from .simple import DocProcessor
 from .simple import EqProcessor
 from .simple import MatchArgsProcessor
 from .simple import OverridesProcessor
-from .simple import ReplaceProcessor
 from .slots import add_slots
 
 if ta.TYPE_CHECKING:

{omlish-0.0.0.dev0 → omlish-0.0.0.dev1}/omlish/dataclasses/impl/replace.py

@@ -4,6 +4,9 @@ from .fields import field_type
 from .internals import FIELDS_ATTR
 from .internals import FieldType
 from .internals import is_dataclass_instance
+from .processing import Processor
+from .utils import set_new_attribute
+
 
 MISSING = dc.MISSING
 
@@ -30,3 +33,8 @@ def _replace(obj, /, **changes):
             changes[f.name] = getattr(obj, f.name)
 
     return obj.__class__(**changes)
+
+
+class ReplaceProcessor(Processor):
+    def _process(self) -> None:
+        set_new_attribute(self._cls, '__replace__', _replace)

{omlish-0.0.0.dev0 → omlish-0.0.0.dev1}/omlish/dataclasses/impl/simple.py

@@ -5,7 +5,6 @@ from .fields import field_assign
 from .init import get_init_fields
 from .params import get_field_extras
 from .processing import Processor
-from .replace import _replace
 from .utils import create_fn
 from .utils import set_new_attribute
 
@@ -91,8 +90,3 @@ class MatchArgsProcessor(Processor):
 
         ifs = get_init_fields(self._info.fields.values())
         set_new_attribute(self._cls, '__match_args__', tuple(f.name for f in ifs.std))
-
-
-class ReplaceProcessor(Processor):
-    def _process(self) -> None:
-        set_new_attribute(self._cls, '__replace__', _replace)

{omlish-0.0.0.dev0 → omlish-0.0.0.dev1}/omlish/http/consts.py

@@ -12,8 +12,9 @@ STATUS_NOT_FOUND = format_status(http.HTTPStatus.NOT_FOUND)
 STATUS_METHOD_NOT_ALLOWED = format_status(http.HTTPStatus.METHOD_NOT_ALLOWED)
 
 
-CONTENT_TYPE = 'Content-Type'
-CONTENT_TEXT = 'text/plain'
-CONTENT_JSON = 'application/json'
-CONTENT_ICON = 'image/x-icon'
-CONTENT_BYTES = 'application/octet-stream'
+HEADER_CONTENT_TYPE = b'Content-Type'
+CONTENT_TYPE_TEXT = b'text/plain'
+CONTENT_TYPE_TEXT_UTF8 = CONTENT_TYPE_TEXT + b'; charset=utf-8'
+CONTENT_TYPE_JSON = b'application/json'
+CONTENT_TYPE_ICON = b'image/x-icon'
+CONTENT_TYPE_BYTES = b'application/octet-stream'

omlish-0.0.0.dev1/omlish/http/wsgi.py

@@ -0,0 +1,34 @@
+import typing as ta
+
+from .. import lang
+
+
+Environ = ta.Mapping[str, ta.Any]
+StartResponse = ta.Callable[[str, ta.Iterable[tuple[str | bytes, str | bytes]]], ta.Callable[[lang.BytesLike], None]]
+App = ta.Callable[[Environ, StartResponse], ta.Iterable[lang.BytesLike]]
+
+
+# class App(lang.Abstract):
+#
+#     def __enter__(self: AppT) -> AppT:
+#         return self
+#
+#     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+#         return None
+#
+#     @abc.abstractmethod
+#     def __call__(self, environ: Environ, start_response: StartResponse) -> ta.Iterable[bytes]:
+#         raise NotImplementedError
+
+
+# class AsyncApp(lang.Abstract):
+#
+#     async def __aenter__(self: AppT) -> AppT:
+#         return self
+#
+#     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+#         return None
+#
+#     @abc.abstractmethod
+#     async def __call__(self, scope, receive, send) -> ta.Iterable[bytes]:
+#         raise NotImplementedError