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

omlish/lang/contextmanagers.py

@@ -176,6 +176,18 @@ async def async_maybe_managing(obj: T) -> ta.AsyncGenerator[T]:
         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
+
+
 ##
 
 
@@ -394,8 +406,8 @@ def double_check_setdefault(
 
 def call_with_exit_stack(
         fn: ta.Callable[ta.Concatenate[contextlib.ExitStack, P], T],
-        *args: ta.Any,
-        **kwargs: ta.Any,
+        *args: P.args,
+        **kwargs: P.kwargs,
 ) -> T:
     with contextlib.ExitStack() as es:
         return fn(es, *args, **kwargs)
@@ -403,8 +415,20 @@ def call_with_exit_stack(
 
 async def call_with_async_exit_stack(
         fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
-        *args: ta.Any,
-        **kwargs: ta.Any,
+        *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)

omlish/lang/functions.py

@@ -29,7 +29,18 @@ def call_with(fn: ta.Any, *args: ta.Any, **kwargs: ta.Any) -> ta.Callable[[T], T
     return inner
 
 
-def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs: ta.Any) -> ta.Any:
+def opt_fn(fn: ta.Callable[[F], T]) -> ta.Callable[[F | None], T | None]:
+    @functools.wraps(fn)
+    def inner(v: F | None) -> T | None:
+        if v is not None:
+            return fn(v)
+        else:
+            return None
+
+    return inner
+
+
+def opt_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs: ta.Any) -> ta.Any:
     try:
         fn = getattr(obj, att)
     except AttributeError:
@@ -39,7 +50,7 @@ def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs: t
 
 
 def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
-    def rec(*args, **kwargs) -> T:
+    def rec(*args, **kwargs) -> T:  # noqa
         return fn(rec, *args, **kwargs)
 
     return rec(*args, **kwargs)
@@ -48,11 +59,11 @@ def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 ##
 
 
-def raise_(o: BaseException) -> ta.NoReturn:
+def raise_(o: BaseException | type[BaseException]) -> ta.NoReturn:
     raise o
 
 
-def raising(o: BaseException) -> ta.Callable[..., ta.NoReturn]:
+def raising(o: BaseException | type[BaseException]) -> ta.Callable[..., ta.NoReturn]:
     def inner(*args, **kwargs):
         raise o
 
@@ -91,20 +102,6 @@ def identity(obj: T) -> T:
     return obj
 
 
-def opt_fn(fn: ta.Callable[[F], T]) -> ta.Callable[[F | None], T | None]:
-    @functools.wraps(fn)
-    def inner(v: F | None) -> T | None:
-        if v is not None:
-            return fn(v)
-        else:
-            return None
-
-    return inner
-
-
-##
-
-
 class _constant(ta.Generic[T]):  # noqa
     def __init__(self, obj: T) -> None:
         super().__init__()
@@ -198,6 +195,13 @@ def periodically(
 ##
 
 
+def opt_getattr(obj: ta.Any, att: str, default: ta.Any = None) -> ta.Any:
+    try:
+        return getattr(obj, att)
+    except AttributeError:
+        return default
+
+
 def coalesce(*vs: T | None) -> T:
     for v in vs:
         if v is not None:
@@ -246,16 +250,17 @@ def new_function(
         # a tuple that supplies the bindings for free variables
         closure: tuple | None = None,
 
-        # # a dictionary that specifies the default keyword argument values
-        # kwdefaults: dict | None = None,
+        # a dictionary that specifies the default keyword argument values
+        kwdefaults: dict | None = None,
 ) -> types.FunctionType:
+    # https://github.com/python/cpython/blob/9c8eade20c6c6cc6f31dffb5e42472391d63bbf4/Objects/funcobject.c#L909
     return types.FunctionType(
         code=code,
         globals=globals,
         name=name,
         argdefs=argdefs,
         closure=closure,
-        # kwdefaults=kwdefaults,
+        kwdefaults=kwdefaults,
     )
 
 
@@ -266,5 +271,9 @@ def new_function_kwargs(f: types.FunctionType) -> dict[str, ta.Any]:
         name=f.__name__,
         argdefs=f.__defaults__,
         closure=f.__closure__,
-        # kwdefaults=f.__kwdefaults__,
+        kwdefaults=f.__kwdefaults__,
     )
+
+
+def copy_function(f: types.FunctionType) -> types.FunctionType:
+    return new_function(**new_function_kwargs(f))

omlish/lang/imports/_capture.cc

@@ -5,10 +5,13 @@
 #define Py_BUILD_CORE 1
 #include "Python.h"
 #include "internal/pycore_frame.h"
+#if PY_VERSION_HEX >= 0x030E0000
+#include "internal/pycore_interpframe.h"
+#endif
 #undef Py_BUILD_CORE
 
 #if PY_VERSION_HEX < 0x030D0000
-#  error "This extension requires CPython 3.13+"
+#error "This extension requires CPython 3.13+"
 #endif
 
 //
@@ -50,14 +53,12 @@ _set_frame_builtins(PyObject *self, PyObject *args)
 
     std::atomic_ref<PyObject*> builtins_ref(iframe->f_builtins);
     PyObject* expected = old_builtins;
-    bool success = builtins_ref.compare_exchange_strong(
+    if (builtins_ref.compare_exchange_strong(
         expected,
         new_builtins,
         std::memory_order_acq_rel,
         std::memory_order_acquire
-    );
-
-    if (success) {
+    )) {
         Py_RETURN_TRUE;
     } else {
         Py_RETURN_FALSE;
@@ -73,13 +74,13 @@ static PyMethodDef capture_methods[] = {
     {NULL, NULL, 0, NULL}
 };
 
-static struct PyModuleDef_Slot capture_slots[] = {
+static PyModuleDef_Slot capture_slots[] = {
     {Py_mod_gil, Py_MOD_GIL_NOT_USED},
-    {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED},
+    {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
     {0, NULL}
 };
 
-static struct PyModuleDef capture_module = {
+static PyModuleDef capture_module = {
     .m_base = PyModuleDef_HEAD_INIT,
     .m_name = _MODULE_NAME,
     .m_doc = capture_doc,
@@ -93,7 +94,8 @@ static struct PyModuleDef capture_module = {
 
 extern "C" {
 
-PyMODINIT_FUNC PyInit__capture(void)
+PyMODINIT_FUNC
+PyInit__capture(void)
 {
     return PyModuleDef_Init(&capture_module);
 }