omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/lang/_asyncs.cc

@@ -0,0 +1,186 @@
+// @omlish-cext
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+//
+
+#define _MODULE_NAME "_asyncs"
+#define _PACKAGE_NAME "omlish.lang"
+#define _MODULE_FULL_NAME _PACKAGE_NAME "." _MODULE_NAME
+
+//
+
+typedef struct {
+    PyObject *SyncAwaitCoroutineNotTerminatedError;
+    PyObject *str_close;
+    PyObject *str___await__;
+} module_state;
+
+static module_state *
+get_module_state(PyObject *module)
+{
+    return (module_state *) PyModule_GetState(module);
+}
+
+//
+
+static void
+suppress_close(PyObject *iter, module_state *state)
+{
+    PyObject *res = PyObject_CallMethodNoArgs(iter, state->str_close);
+    if (!res) {
+        PyErr_Clear();
+    } else {
+        Py_DECREF(res);
+    }
+}
+
+static PyObject *
+sync_await(PyObject *module, PyObject *aw)
+{
+    module_state *state = get_module_state(module);
+    PyObject *await_meth = NULL;
+    PyObject *iter = NULL;
+    PyObject *result = NULL;
+    PySendResult sres;
+
+    await_meth = PyObject_GetAttr(aw, state->str___await__);
+    if (await_meth == NULL) {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_SetString(PyExc_TypeError, "object is not awaitable (no __await__)");
+        }
+        goto error;
+    }
+
+    iter = PyObject_CallNoArgs(await_meth);
+    Py_DECREF(await_meth);
+    await_meth = NULL;
+
+    if (iter == NULL) {
+        goto error;
+    }
+
+    if (!PyIter_Check(iter)) {
+        Py_DECREF(iter);
+        PyErr_SetString(PyExc_TypeError, "__await__() must return an iterator");
+        goto error;
+    }
+
+    sres = PyIter_Send(iter, Py_None, &result);
+    if (sres == PYGEN_ERROR) {
+        Py_DECREF(iter);
+        goto error;
+    }
+    if (sres == PYGEN_NEXT) {
+        Py_XDECREF(result);
+        suppress_close(iter, state);
+        Py_DECREF(iter);
+        PyErr_SetString(state->SyncAwaitCoroutineNotTerminatedError, "Not terminated");
+        goto error;
+    }
+
+    Py_DECREF(iter);
+    return result;
+
+error:
+    return NULL;
+}
+
+//
+
+static PyMethodDef mod_methods[] = {
+    {"sync_await", sync_await, METH_O, "sync_await"},
+    {NULL, NULL, 0, NULL}
+};
+
+static int
+module_traverse(PyObject *module, visitproc visit, void *arg)
+{
+    module_state *state = get_module_state(module);
+    Py_VISIT(state->SyncAwaitCoroutineNotTerminatedError);
+    Py_VISIT(state->str_close);
+    Py_VISIT(state->str___await__);
+    return 0;
+}
+
+static int
+module_clear(PyObject *module)
+{
+    module_state *state = get_module_state(module);
+    Py_CLEAR(state->SyncAwaitCoroutineNotTerminatedError);
+    Py_CLEAR(state->str_close);
+    Py_CLEAR(state->str___await__);
+    return 0;
+}
+
+static void
+module_free(void *module)
+{
+    module_clear((PyObject *) module);
+}
+
+static int
+module_exec(PyObject *module)
+{
+    module_state *state = get_module_state(module);
+
+    state->str_close = PyUnicode_InternFromString("close");
+    if (!state->str_close) {
+        return -1;
+    }
+
+    state->str___await__ = PyUnicode_InternFromString("__await__");
+    if (!state->str___await__) {
+        return -1;
+    }
+
+    PyObject *asyncs_module = PyImport_ImportModule("omlish.lite.asyncs");
+    if (!asyncs_module) {
+        return -1;
+    }
+
+    state->SyncAwaitCoroutineNotTerminatedError = PyObject_GetAttrString(
+        asyncs_module,
+        "SyncAwaitCoroutineNotTerminatedError"
+    );
+    Py_DECREF(asyncs_module);
+
+    if (!state->SyncAwaitCoroutineNotTerminatedError) {
+        return -1;
+    }
+
+    return 0;
+}
+
+//
+
+PyDoc_STRVAR(module_doc, _MODULE_NAME);
+
+static PyModuleDef_Slot module_slots[] = {
+    {Py_mod_exec, (void *) module_exec},
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
+    {0, NULL}
+};
+
+static PyModuleDef module_def = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = _MODULE_NAME,
+    .m_doc = module_doc,
+    .m_size = sizeof(module_state),
+    .m_methods = mod_methods,
+    .m_slots = module_slots,
+    .m_traverse = module_traverse,
+    .m_clear = module_clear,
+    .m_free = module_free,
+};
+
+extern "C" {
+
+PyMODINIT_FUNC
+PyInit__asyncs(void)
+{
+    return PyModuleDef_Init(&module_def);
+}
+
+}

omlish/lang/asyncs.py

@@ -1,73 +1,97 @@
+import abc
+import functools
 import typing as ta
 
+from ..lite.abstract import Abstract
+from ..lite.asyncs import sync_await as _sync_await
+from ..lite.maybes import Maybe
 
+
+O = ta.TypeVar('O')
+I = ta.TypeVar('I')
+R = ta.TypeVar('R')
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
 
 
 ##
 
 
-async def async_list(
-        ai: ta.AsyncIterable[T],
-) -> list[T]:
-    """Simply eagerly reads the full contents of a function call returning an async iterator."""
+def as_async(fn: ta.Callable[P, T], *, wrap: bool = False) -> ta.Callable[P, ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
 
-    return [v async for v in ai]
+    return functools.wraps(fn)(inner) if wrap else inner
 
 
 ##
 
 
-def sync_await(
-        aw: ta.Awaitable[T],
-) -> T:
-    """
-    Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
-    functions are allowed to await any number of other functions - including contextmanagers and generators - so long as
-    nothing ever actually 'leaks' out of the function, presumably to an event loop.
-    """
+class AsyncGeneratorWithReturn(ta.AsyncGenerator[O, I], Abstract, ta.Generic[O, I, R]):
+    @property
+    @abc.abstractmethod
+    def value(self) -> Maybe[R]:
+        raise NotImplementedError
+
+
+@ta.final
+class _AsyncGeneratorWithReturn(AsyncGeneratorWithReturn[O, I, R]):
+    def __init__(self, ag: ta.AsyncGenerator[O, I]) -> None:
+        if isinstance(ag, _AsyncGeneratorWithReturn):
+            raise TypeError(ag)
+        self._ag = ag
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._ag!r})'
+
+    _v: Maybe[R] = Maybe.empty()
 
-    ret = missing = object()
+    @property
+    def value(self) -> Maybe[R]:
+        return self._v
 
-    async def gate():
-        nonlocal ret
+    def _set_value(self, v: R) -> None:
+        if self._v.present:
+            raise TypeError('Return value already set')
+        self._v = Maybe.just(v)
 
-        ret = await aw
+    def __anext__(self):
+        return self._ag.__anext__()
 
-    cr = gate()
-    try:
-        try:
-            cr.send(None)
-        except StopIteration:
-            pass
+    def asend(self, value):
+        return self._ag.asend(value)
 
-        if ret is missing or cr.cr_await is not None or cr.cr_running:
-            raise TypeError('Not terminated')
+    def athrow(self, typ, val=None, tb=None):
+        return self._ag.athrow(typ, val, tb)
 
-    finally:
-        cr.close()
+    def aclose(self):
+        return self._ag.aclose()
 
-    return ta.cast(T, ret)
 
+def async_generator_with_return(
+        fn: ta.Callable[ta.Concatenate[ta.Callable[[R], None], P], ta.AsyncGenerator[O, I]],
+) -> ta.Callable[P, AsyncGeneratorWithReturn[O, I, R]]:
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        def set_value(v):
+            x._set_value(v)  # noqa
 
-def sync_async_list(
-        ai: ta.AsyncIterable[T],
-) -> list[T]:
-    """
-    Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
-    the function never externally awaits anything.
-    """
+        return (x := _AsyncGeneratorWithReturn(fn(set_value, *args, **kwargs)))  # type: ignore[var-annotated]
+
+    return inner
+
+
+##
 
-    lst: list[T] | None = None
 
-    async def inner():
-        nonlocal lst
+sync_await = _sync_await
 
-        lst = [v async for v in ai]
 
-    sync_await(inner())
+try:
+    from . import _asyncs as cext  # type: ignore
 
-    if not isinstance(lst, list):
-        raise TypeError(lst)
+except ImportError:
+    pass
 
-    return lst
+else:
+    sync_await = cext.sync_await

omlish/lang/{attrs.py → attrstorage.py}

@@ -76,7 +76,7 @@ def set_attr(
 ##
 
 
-class AttrOps(Abstract):
+class AttrStorage(Abstract):
     class NOT_SET:  # noqa
         def __new__(cls, *args, **kwargs):  # noqa
             raise TypeError
@@ -97,9 +97,9 @@ class AttrOps(Abstract):
 #
 
 
-class StdAttrOps(AttrOps):
-    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
-        if default is AttrOps.NOT_SET:
+class StdAttrStorage(AttrStorage):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrStorage.NOT_SET) -> ta.Any:
+        if default is AttrStorage.NOT_SET:
             return getattr(obj, name)
         else:
             return getattr(obj, name, default)
@@ -111,13 +111,13 @@ class StdAttrOps(AttrOps):
         delattr(obj, name)
 
 
-STD_ATTR_OPS = StdAttrOps()
+STD_ATTR_STORAGE = StdAttrStorage()
 
 
 #
 
 
-class DictAttrOps(AttrOps):
+class DictAttrStorage(AttrStorage):
     def __init__(self, dct: ta.MutableMapping[str, ta.Any] | None = None) -> None:
         super().__init__()
 
@@ -125,11 +125,11 @@ class DictAttrOps(AttrOps):
             dct = {}
         self._dct = dct
 
-    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrStorage.NOT_SET) -> ta.Any:
         try:
             return self._dct[name]
         except KeyError:
-            if default is not AttrOps.NOT_SET:
+            if default is not AttrStorage.NOT_SET:
                 return default
             raise AttributeError(name) from None
 
@@ -205,13 +205,13 @@ def _get_object_transient_dict(obj: ta.Any) -> TransientDict:
         return obj.__dict__.setdefault(_TRANSIENT_DICT_ATTR, TransientDict())
 
 
-class TransientAttrOps(AttrOps):
-    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+class TransientAttrStorage(AttrStorage):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrStorage.NOT_SET) -> ta.Any:
         td = _get_object_transient_dict(obj)
         try:
             return td[name]
         except KeyError:
-            if default is not AttrOps.NOT_SET:
+            if default is not AttrStorage.NOT_SET:
                 return default
             raise AttributeError(name) from None
 
@@ -227,8 +227,8 @@ class TransientAttrOps(AttrOps):
             raise AttributeError(name) from None
 
 
-TRANSIENT_ATTR_OPS = TransientAttrOps()
+TRANSIENT_ATTR_STORAGE = TransientAttrStorage()
 
-transient_getattr = TRANSIENT_ATTR_OPS.getattr
-transient_setattr = TRANSIENT_ATTR_OPS.setattr
-transient_delattr = TRANSIENT_ATTR_OPS.delattr
+transient_getattr = TRANSIENT_ATTR_STORAGE.getattr
+transient_setattr = TRANSIENT_ATTR_STORAGE.setattr
+transient_delattr = TRANSIENT_ATTR_STORAGE.delattr

omlish/lang/cached/property.py

@@ -2,8 +2,8 @@ import abc
 import functools
 import typing as ta
 
-from ..attrs import transient_getattr
-from ..attrs import transient_setattr
+from ..attrstorage import transient_getattr
+from ..attrstorage import transient_setattr
 from ..classes.abstract import Abstract
 
 

omlish/lang/casing.py

@@ -50,6 +50,13 @@ class StringCasing(Abstract):
 
         raise NotImplementedError
 
+    #
+
+    def to(self, other: 'StringCasing') -> ta.Callable[[str], str]:
+        def inner(s: str) -> str:
+            return other.join(*self.split(s))
+        return inner
+
 
 #
 
@@ -167,6 +174,10 @@ snake_case = SNAKE_CASE.join
 up_snake_case = UP_SNAKE_CASE.join
 
 
+camel_to_snake = CAMEL_CASE.to(SNAKE_CASE)
+snake_to_camel = SNAKE_CASE.to(CAMEL_CASE)
+
+
 ##
 
 

omlish/lang/classes/bindable.py

@@ -7,10 +7,9 @@ T = ta.TypeVar('T')
 ##
 
 
+@ta.final
 class _ClassOrInstanceMethod:
     def __init__(self, func):
-        super().__init__()
-
         self.__func__ = func
 
     def __get__(self, instance, owner=None):
@@ -19,7 +18,7 @@ class _ClassOrInstanceMethod:
 
 class BindableClass(ta.Generic[T]):
     # FIXME: apparently can't have TypeVars in ClassVars, but could stick in a @classmethod (which gets transformed)...
-    _bound: ta.ClassVar[type[T] | None] = None  # type: ignore[misc]
+    _bound: ta.ClassVar[type[T] | None] = None
 
     def __init__(self, *, _bound):
         super().__init__()

omlish/lang/classes/restrict.py

@@ -32,6 +32,14 @@ class Final(Abstract):
             elif Final in base.__mro__:
                 raise FinalTypeError(base)
 
+        # Per `ta.final`:
+        try:
+            cls.__final__ = True  # type: ignore[attr-defined]
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable. AttributeError happens if the object has __slots__ or
+            # a read-only property, TypeError if it's a builtin class.
+            pass
+
 
 ##
 

omlish/lang/classes/simple.py

@@ -63,7 +63,6 @@ class Marker(NotInstantiable, metaclass=_MarkerMeta):
 
 
 _SINGLETON_INSTANCE_ATTR = '__singleton_instance__'
-_SINGLETON_LOCK = threading.RLock()
 
 
 def _set_singleton_instance(inst):
@@ -85,7 +84,24 @@ def _set_singleton_instance(inst):
     return inst
 
 
-class Singleton:
+class _AnySingleton:
+    def __init__(self) -> None:
+        try:
+            type(self).__dict__[_SINGLETON_INSTANCE_ATTR]
+        except KeyError:
+            pass
+        else:
+            raise TypeError(f'Must not re-instantiate singleton {type(self)}')
+
+        super().__init__()
+
+    @ta.final
+    def __reduce__(self):
+        return (type(self), ())
+
+
+class Singleton(_AnySingleton):
+    @ta.final
     def __new__(cls):
         return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
 
@@ -95,15 +111,21 @@ class Singleton:
         _set_singleton_instance(super().__new__(cls))  # noqa
 
 
-class LazySingleton:
+_LAZY_SINGLETON_LOCK = threading.RLock()
+
+
+class LazySingleton(_AnySingleton):
+    @ta.final
     def __new__(cls):
         try:
             return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
         except KeyError:
             pass
-        with _SINGLETON_LOCK:
+
+        with _LAZY_SINGLETON_LOCK:
             try:
                 return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
             except KeyError:
                 pass
+
             return _set_singleton_instance(super().__new__(cls))

omlish/lang/collections.py

@@ -9,7 +9,7 @@ V = ta.TypeVar('V')
 ##
 
 
-def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
+def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[tuple[ta.Any, ta.Any]]:
     if len(args) > 1:
         raise TypeError
 

omlish/lang/contextmanagers.py

@@ -20,6 +20,8 @@ T = ta.TypeVar('T')
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
+P = ta.ParamSpec('P')
+
 
 ##
 
@@ -165,6 +167,30 @@ def maybe_managing(obj: T) -> ta.Iterator[T]:
         yield obj
 
 
+@contextlib.asynccontextmanager
+async def async_maybe_managing(obj: T) -> ta.AsyncGenerator[T]:
+    if isinstance(obj, ta.AsyncContextManager):
+        async with obj:
+            yield obj
+    else:
+        yield obj
+
+
+@contextlib.asynccontextmanager
+async def async_or_sync_maybe_managing(obj: T) -> ta.AsyncGenerator[T]:
+    if isinstance(obj, ta.AsyncContextManager):
+        async with obj:
+            yield obj
+    elif isinstance(obj, ta.ContextManager):
+        with obj:
+            yield obj
+    else:
+        yield obj
+
+
+##
+
+
 @contextlib.contextmanager
 def disposing(obj: T, attr: str = 'dispose') -> ta.Iterator[T]:
     try:
@@ -194,15 +220,6 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
 ##
 
 
-@contextlib.asynccontextmanager
-async def as_async_context_manager(cm: ta.ContextManager[T]) -> ta.AsyncIterator[T]:
-    with cm as v:
-        yield v
-
-
-##
-
-
 ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.ContextManager]
 
 
@@ -382,3 +399,36 @@ def double_check_setdefault(
         v = fn()
         dct[k] = v
         return v
+
+
+##
+
+
+def call_with_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.ExitStack, P], T],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> T:
+    with contextlib.ExitStack() as es:
+        return fn(es, *args, **kwargs)
+
+
+async def call_with_async_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> T:
+    async with contextlib.AsyncExitStack() as aes:
+        return await fn(aes, *args, **kwargs)
+
+
+def with_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.ExitStack, P], T],
+) -> ta.Callable[P, T]:
+    return functools.partial(call_with_exit_stack, fn)
+
+
+def with_async_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
+) -> ta.Callable[P, ta.Awaitable[T]]:
+    return functools.partial(call_with_async_exit_stack, fn)