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

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__()
@@ -167,17 +164,6 @@ 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()
 
 
@@ -209,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:
@@ -257,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,
     )
 
 
@@ -277,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

@@ -0,0 +1,103 @@
+// @omlish-cext
+#include <atomic>
+
+#define PY_SSIZE_T_CLEAN
+#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+"
+#endif
+
+//
+
+#define _MODULE_NAME "_capture"
+#define _PACKAGE_NAME "omlish.lang.imports"
+#define _MODULE_FULL_NAME _PACKAGE_NAME "." _MODULE_NAME
+
+//
+
+static PyObject *
+_set_frame_builtins(PyObject *self, PyObject *args)
+{
+    PyObject *frame_obj;
+    PyObject *old_builtins;
+    PyObject *new_builtins;
+
+    if (!PyArg_ParseTuple(
+        args, "OO!O!",
+        &frame_obj,
+        &PyDict_Type, &old_builtins,
+        &PyDict_Type, &new_builtins
+    )) {
+        return NULL;
+    }
+
+    if (!PyFrame_Check(frame_obj)) {
+        PyErr_SetString(PyExc_TypeError, "first argument must be a frame object");
+        return NULL;
+    }
+
+    PyFrameObject *frame = (PyFrameObject *)frame_obj;
+    _PyInterpreterFrame *iframe = frame->f_frame;
+
+    if (!iframe) {
+        PyErr_SetString(PyExc_ValueError, "frame has no underlying interpreter frame");
+        return NULL;
+    }
+
+    std::atomic_ref<PyObject*> builtins_ref(iframe->f_builtins);
+    PyObject* expected = old_builtins;
+    if (builtins_ref.compare_exchange_strong(
+        expected,
+        new_builtins,
+        std::memory_order_acq_rel,
+        std::memory_order_acquire
+    )) {
+        Py_RETURN_TRUE;
+    } else {
+        Py_RETURN_FALSE;
+    }
+}
+
+//
+
+PyDoc_STRVAR(capture_doc, _MODULE_NAME);
+
+static PyMethodDef capture_methods[] = {
+    {"_set_frame_builtins", _set_frame_builtins, METH_VARARGS, "_set_frame_builtins"},
+    {NULL, NULL, 0, NULL}
+};
+
+static PyModuleDef_Slot capture_slots[] = {
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
+    {0, NULL}
+};
+
+static PyModuleDef capture_module = {
+    .m_base = PyModuleDef_HEAD_INIT,
+    .m_name = _MODULE_NAME,
+    .m_doc = capture_doc,
+    .m_size = 0,
+    .m_methods = capture_methods,
+    .m_slots = capture_slots,
+    .m_traverse = NULL,
+    .m_clear = NULL,
+    .m_free = NULL,
+};
+
+extern "C" {
+
+PyMODINIT_FUNC
+PyInit__capture(void)
+{
+    return PyModuleDef_Init(&capture_module);
+}
+
+}