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

omlish/lang/__init__.py

@@ -9,6 +9,8 @@ with _auto_proxy_init(globals(), update_exports=True):
 
         AsyncGeneratorWithReturn,
         async_generator_with_return,
+
+        sync_await,
     )
 
     from .attrstorage import (  # noqa
@@ -63,15 +65,20 @@ with _auto_proxy_init(globals(), update_exports=True):
         snake_case,
         up_snake_case,
 
+        camel_to_snake,
+        snake_to_camel,
+
         get_string_casing,
         split_string_casing,
     )
 
     from .classes.abstract import (  # noqa
-        get_abstracts,
-        is_abstract,
-        is_abstract_class,
         is_abstract_method,
+
+        is_abstract_class,
+        is_abstract,
+
+        get_abstracts,
         make_abstract,
     )
 
@@ -81,8 +88,8 @@ with _auto_proxy_init(globals(), update_exports=True):
 
     from .classes.namespaces import (  # noqa
         GenericNamespaceMeta,
-        Namespace,
         NamespaceMeta,
+        Namespace,
     )
 
     from .classes.protocols import (  # noqa
@@ -91,54 +98,65 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .classes.restrict import (  # noqa
-        AnySensitive,
-        Final,
         FinalTypeError,
-        NoBool,
+        Final,
+
+        SealedError,
+        Sealed,
+        PackageSealed,
+
         NotInstantiable,
         NotPicklable,
-        PackageSealed,
+
+        NoBool,
+        no_bool,
+
         SENSITIVE_ATTR,
-        Sealed,
-        SealedError,
         Sensitive,
-        no_bool,
+        AnySensitive,
     )
 
     from .classes.simple import (  # noqa
-        LazySingleton,
-        Marker,
         SimpleMetaDict,
+
+        Marker,
+
         Singleton,
+        LazySingleton,
     )
 
     from .classes.virtual import (  # noqa
-        Callable,
-        Descriptor,
-        Picklable,
         Virtual,
         virtual_check,
+
+        Descriptor,
+        Picklable,
+
+        Callable,
     )
 
     from .clsdct import (  # noqa
+        is_possibly_cls_dct,
+        get_caller_cls_dct,
+
         ClassDctFn,
         cls_dct_fn,
-        get_caller_cls_dct,
-        is_possibly_cls_dct,
     )
 
     from .collections import (  # noqa
-        empty_map,
-        merge_dicts,
         yield_dict_init,
+        merge_dicts,
+
+        empty_map,
     )
 
     from .comparison import (  # noqa
-        Infinity,
+        cmp,
+
         InfinityType,
-        NegativeInfinity,
+        Infinity,
         NegativeInfinityType,
-        cmp,
+        NegativeInfinity,
     )
 
     from .contextmanagers import (  # noqa
@@ -158,6 +176,7 @@ with _auto_proxy_init(globals(), update_exports=True):
 
         maybe_managing,
         async_maybe_managing,
+        async_or_sync_maybe_managing,
 
         disposing,
         breakpoint_on_exception,
@@ -181,6 +200,9 @@ with _auto_proxy_init(globals(), update_exports=True):
 
         call_with_exit_stack,
         call_with_async_exit_stack,
+
+        with_exit_stack,
+        with_async_exit_stack,
     )
 
     from .datetimes import (  # noqa
@@ -194,19 +216,26 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .descriptors import (  # noqa
-        AccessForbiddenError,
-        access_forbidden,
         attr_property,
-        classonly,
-        decorator,
-        is_method_descriptor,
         item_property,
-        unwrap_callable,
-        unwrap_callable_with_partials,
-        unwrap_func,
-        unwrap_func_with_partials,
+
+        is_method_descriptor,
         unwrap_method_descriptors,
+
+        unwrap_func_with_partials,
+        unwrap_func,
+
+        unwrap_callable_with_partials,
+        unwrap_callable,
+
         update_wrapper,
+
+        decorator,
+
+        AccessForbiddenError,
+        access_forbidden,
+
+        classonly,
     )
 
     from .enums import (  # noqa
@@ -218,43 +247,58 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .functions import (  # noqa
-        VoidError,
+        is_lambda,
+
         call_with,
-        coalesce,
-        cond_kw,
-        constant,
+        opt_call,
+        opt_fn,
+        recurse,
+
+        raise_,
+        raising,
+        try_,
         finally_,
+
         identity,
-        is_lambda,
+        constant,
+        nullary_constant,
+
         is_none,
         is_not_none,
         isinstance_of,
         issubclass_of,
-        maybe_call,
-        new_function,
-        new_function_kwargs,
-        nullary_constant,
+        strict_eq,
+
+        VoidError,
+        Void,
+        void,
+
+        periodically,
+
+        opt_getattr,
+        coalesce,
         opt_coalesce,
-        opt_fn,
+
+        cond_kw,
         opt_kw,
-        periodically,
-        raise_,
-        raising,
-        recurse,
-        strict_eq,
         truthy_kw,
-        try_,
-        void,
+
+        new_function,
+        new_function_kwargs,
+        copy_function,
     )
 
     from .generators import (  # noqa
-        GeneratorLike,
-        GeneratorMappedIterator,
+        nextgen,
         autostart,
-        capture_coroutine,
+
+        GeneratorLike,
+
         capture_generator,
+        capture_coroutine,
+
+        GeneratorMappedIterator,
         genmap,
-        nextgen,
     )
 
     from .imports.capture import (  # noqa
@@ -294,21 +338,26 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .iterables import (  # noqa
-        IteratorWithReturn,
-        asrange,
-        chunk,
-        common_prefix_len,
-        consume,
-        flatmap,
-        flatten,
         ilen,
+        take,
+        consume,
+        peek,
+        chunk,
         interleave,
+        renumerate,
+        common_prefix_len,
+
+        readiter,
+
         itergen,
-        peek,
+
+        flatten,
+        flatmap,
+
+        asrange,
         prodrange,
-        readiter,
-        renumerate,
-        take,
+
+        IteratorWithReturn,
     )
 
     from .lazyglobals import (  # noqa
@@ -330,27 +379,38 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .objects import (  # noqa
-        Identity,
-        SimpleProxy,
-        anon_object,
         arg_repr,
+        opt_repr,
+
         can_weakref,
-        deep_subclasses,
+
         new_type,
-        opt_repr,
         super_meta,
+
+        deep_subclasses,
+
+        SimpleProxy,
+
+        anon_object,
+
+        Identity,
     )
 
     from .outcomes import (  # noqa
-        Either,
-        Error,
-        Outcome,
         OutcomeAlreadyUnwrappedError,
-        Value,
-        acapture,
+
         capture,
-        error,
+        acapture,
+
+        Outcome,
+
+        Value,
         value,
+
+        Error,
+        error,
+
+        Either,
     )
 
     from .overrides import (  # noqa
@@ -363,29 +423,37 @@ with _auto_proxy_init(globals(), update_exports=True):
     )
 
     from .params import (  # noqa
+        CanParamSpec,
+
+        Param,
+
+        VarParam,
         ArgsParam,
-        KwOnlyParam,
         KwargsParam,
-        Param,
+
+        ValParam,
+        PosOnlyParam,
+        KwOnlyParam,
+
         ParamSeparator,
+
         ParamSpec,
-        PosOnlyParam,
-        ValParam,
-        VarParam,
+
         param_render,
     )
 
     from .recursion import (  # noqa
         LimitedRecursionError,
-        recursion_limiting,
         recursion_limiting_context,
+
+        recursion_limiting,
     )
 
     from .resolving import (  # noqa
-        Resolvable,
         ResolvableClassNameError,
         get_cls_fqcn,
         get_fqcn_cls,
+        Resolvable,
     )
 
     from .resources import (  # noqa
@@ -394,25 +462,39 @@ with _auto_proxy_init(globals(), update_exports=True):
         get_relative_resources,
     )
 
+    from .sequences import (  # noqa
+        iterslice,
+        iterrange,
+
+        SeqView,
+    )
+
     from .strings import (  # noqa
-        BOOL_FALSE_STRINGS,
-        BOOL_STRINGS,
-        BOOL_TRUE_STRINGS,
-        STRING_BOOL_VALUES,
-        find_any,
-        indent_lines,
-        is_dunder,
-        is_ident,
-        is_ident_cont,
-        is_ident_start,
-        is_sunder,
-        iter_pat,
         prefix_delimited,
         prefix_lines,
-        replace_many,
-        rfind_any,
+        indent_lines,
+
         strip_prefix,
         strip_suffix,
+
+        replace_many,
+
+        find_any,
+        rfind_any,
+
+        is_dunder,
+        is_sunder,
+
+        is_ident_start,
+        is_ident_cont,
+        is_ident,
+
+        BOOL_STRINGS,
+        BOOL_FALSE_STRINGS,
+        BOOL_TRUE_STRINGS,
+        STRING_BOOL_VALUES,
+
+        iter_pat,
     )
 
     from .sys import (  # noqa
@@ -456,7 +538,6 @@ with _auto_proxy_init(globals(), update_exports=True):
         async_enumerate,
 
         SyncAwaitCoroutineNotTerminatedError,
-        sync_await,
 
         sync_aiter,
         sync_async_list,

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

@@ -3,6 +3,7 @@ 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
 
 
@@ -78,3 +79,19 @@ def async_generator_with_return(
         return (x := _AsyncGeneratorWithReturn(fn(set_value, *args, **kwargs)))  # type: ignore[var-annotated]
 
     return inner
+
+
+##
+
+
+sync_await = _sync_await
+
+
+try:
+    from . import _asyncs as cext  # type: ignore
+
+except ImportError:
+    pass
+
+else:
+    sync_await = cext.sync_await

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)
+
+
 ##