omlish 0.0.0.dev444__tar.gz → 0.0.0.dev445__tar.gz

{omlish-0.0.0.dev444/omlish.egg-info → omlish-0.0.0.dev445}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev444
+Version: 0.0.0.dev445
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev444 → omlish-0.0.0.dev445}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev444'
-__revision__ = 'ce3fb695bf149775254b152cc6a5a761e3f5bb90'
+__version__ = '0.0.0.dev445'
+__revision__ = '68ca679313e2d1b22ba7545fe7f27bb938535ac3'
 
 
 #
@@ -185,6 +185,8 @@ class SetuptoolsBase:
 
 
 class Setuptools(SetuptoolsBase):
+    cexts = True
+
     find_packages = {
         'include': [Project.name, f'{Project.name}.*'],
         'exclude': [*SetuptoolsBase.find_packages['exclude']],

omlish-0.0.0.dev445/omlish/lang/imports/_capture.cc

@@ -0,0 +1,101 @@
+// @omlish-cext
+#include <atomic>
+
+#define PY_SSIZE_T_CLEAN
+#define Py_BUILD_CORE 1
+#include "Python.h"
+#include "internal/pycore_frame.h"
+#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;
+    bool success = 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;
+    }
+}
+
+//
+
+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 struct PyModuleDef_Slot capture_slots[] = {
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED},
+    {0, NULL}
+};
+
+static struct 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);
+}
+
+}

{omlish-0.0.0.dev444 → omlish-0.0.0.dev445}/omlish/lang/imports/capture.py

@@ -235,10 +235,31 @@ class _ImportCaptureHook:
 
         return module.module_obj
 
-    # @abc.abstractmethod
+    @ta.final
+    @contextlib.contextmanager
     def hook_context(
             self,
             mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
+    ) -> ta.Iterator[None]:
+        if self._MOD_SELF_ATTR in mod_globals:
+            raise ImportCaptureErrors.HookError
+
+        mod_globals[self._MOD_SELF_ATTR] = self
+
+        try:
+            with self._hook_context(mod_globals):
+                yield
+
+        finally:
+            if mod_globals[self._MOD_SELF_ATTR] is not self:
+                raise ImportCaptureErrors.HookError
+
+            del mod_globals[self._MOD_SELF_ATTR]
+
+    # @abc.abstractmethod
+    def _hook_context(
+            self,
+            mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> ta.ContextManager[None]:
         raise NotImplementedError
 
@@ -333,7 +354,10 @@ class _ImportCaptureHook:
         )
 
 
-class _AbstractBuiltinImportCaptureHook(_ImportCaptureHook):
+#
+
+
+class _AbstractBuiltinsImportCaptureHook(_ImportCaptureHook):
     def _new_import(
             self,
             old_import,
@@ -366,38 +390,28 @@ class _AbstractBuiltinImportCaptureHook(_ImportCaptureHook):
         )
 
 
-class _UnsafeGlobalBuiltinImportCaptureHook(_AbstractBuiltinImportCaptureHook):
+class _UnsafeGlobalBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
     @contextlib.contextmanager
-    def hook_context(
+    def _hook_context(
             self,
             mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> ta.Iterator[None]:
-        if self._MOD_SELF_ATTR in mod_globals:
-            raise ImportCaptureErrors.HookError
-
-        #
-
         old_import = builtins.__import__
         new_import = functools.partial(self._new_import, old_import)
 
-        mod_globals[self._MOD_SELF_ATTR] = self
         builtins.__import__ = new_import
 
         try:
             yield
 
         finally:
-            if not (
-                    mod_globals[self._MOD_SELF_ATTR] is self and
-                    builtins.__import__ is new_import
-            ):
+            if builtins.__import__ is not new_import:
                 raise ImportCaptureErrors.HookError
 
-            del mod_globals[self._MOD_SELF_ATTR]
             builtins.__import__ = old_import
 
 
-class _SomewhatThreadSafeGlobalBuiltinImportCaptureHook(_AbstractBuiltinImportCaptureHook):
+class _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
     class _AlreadyPatchedError(Exception):
         pass
 
@@ -411,23 +425,23 @@ class _SomewhatThreadSafeGlobalBuiltinImportCaptureHook(_AbstractBuiltinImportCa
             self.__uninstalled = False
 
         @classmethod
-        def _add_hook(cls, mod_globals, new_import) -> '_SomewhatThreadSafeGlobalBuiltinImportCaptureHook._Patch':
+        def _add_hook(cls, mod_globals, new_import) -> '_SomewhatThreadSafeGlobalBuiltinsImportCaptureHook._Patch':
             gi = id(mod_globals)
             for _ in range(1_000):
                 try:
                     with cls.__lock:
                         x: ta.Any = builtins.__import__
-                        p: _SomewhatThreadSafeGlobalBuiltinImportCaptureHook._Patch
+                        p: _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook._Patch
                         if x.__class__ is cls:
                             p = x
                             if p.__uninstalled:  # noqa
-                                raise _SomewhatThreadSafeGlobalBuiltinImportCaptureHook._AlreadyPatchedError  # noqa
+                                raise _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook._AlreadyPatchedError  # noqa
                         else:
                             p = cls(x)
                             builtins.__import__ = p
                         p.__hooks[gi] = (mod_globals, new_import)
                         return p
-                except _SomewhatThreadSafeGlobalBuiltinImportCaptureHook._AlreadyPatchedError:
+                except _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook._AlreadyPatchedError:
                     pass
             raise ImportCaptureErrors.HookError('Failed to install builtins hook')
 
@@ -480,17 +494,11 @@ class _SomewhatThreadSafeGlobalBuiltinImportCaptureHook(_AbstractBuiltinImportCa
             )
 
     @contextlib.contextmanager
-    def hook_context(
+    def _hook_context(
             self,
             mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> ta.Iterator[None]:
-        if self._MOD_SELF_ATTR in mod_globals:
-            raise ImportCaptureErrors.HookError
-
-        #
-
-        mod_globals[self._MOD_SELF_ATTR] = self
-        patch = _SomewhatThreadSafeGlobalBuiltinImportCaptureHook._Patch._add_hook(mod_globals, self._new_import)  # noqa
+        patch = _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook._Patch._add_hook(mod_globals, self._new_import)  # noqa
 
         try:
             yield
@@ -498,12 +506,18 @@ class _SomewhatThreadSafeGlobalBuiltinImportCaptureHook(_AbstractBuiltinImportCa
         finally:
             patch._remove_hook(mod_globals)  # noqa
 
-            if mod_globals[self._MOD_SELF_ATTR] is not self:
-                raise ImportCaptureErrors.HookError
-            del mod_globals[self._MOD_SELF_ATTR]
+
+#
+
+
+_capture: ta.Any = None
+try:
+    from . import _capture  # type: ignore
+except ImportError:
+    pass
 
 
-class _FrameBuiltinImportCaptureHook(_AbstractBuiltinImportCaptureHook):
+class _FrameBuiltinsImportCaptureHook(_AbstractBuiltinsImportCaptureHook):
     def __init__(
             self,
             *,
@@ -519,41 +533,35 @@ class _FrameBuiltinImportCaptureHook(_AbstractBuiltinImportCaptureHook):
             cls,
             frame: types.FrameType,
             new_builtins: dict[str, ta.Any],
-    ) -> None:
-        # FIXME: cext...
-        frame.f_builtins = new_builtins  # type: ignore[misc]  # noqa
+    ) -> bool:
+        return _capture._set_frame_builtins(frame, frame.f_builtins, new_builtins)  # noqa
 
     @contextlib.contextmanager
-    def hook_context(
+    def _hook_context(
             self,
             mod_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> ta.Iterator[None]:
-        if self._MOD_SELF_ATTR in mod_globals:
-            raise ImportCaptureErrors.HookError
-
-        #
-
         old_builtins = self._frame.f_builtins
         old_import = old_builtins['__import__']
         new_import = functools.partial(self._new_import, old_import)
 
-        mod_globals[self._MOD_SELF_ATTR] = self
         new_builtins = dict(old_builtins)
         new_builtins['__import__'] = new_import
-        self._set_frame_builtins(self._frame, new_builtins)
+        if not self._set_frame_builtins(self._frame, new_builtins):
+            raise ImportCaptureErrors.HookError
 
         try:
             yield
 
         finally:
-            if not (
-                    mod_globals[self._MOD_SELF_ATTR] is self and
-                    self._frame.f_builtins is new_builtins
-            ):
+            if self._frame.f_builtins is not new_builtins:
                 raise ImportCaptureErrors.HookError
 
-            del mod_globals[self._MOD_SELF_ATTR]
-            self._set_frame_builtins(self._frame, old_builtins)
+            if not self._set_frame_builtins(self._frame, old_builtins):
+                raise ImportCaptureErrors.HookError
+
+
+#
 
 
 def _new_import_capture_hook(
@@ -566,14 +574,10 @@ def _new_import_capture_hook(
     if frame is None or frame.f_globals is not mod_globals:
         raise ImportCaptureError("Can't find importing frame")
 
-    # return _FrameBuiltinImportCaptureHook(
-    #     _frame=frame,
-    #     **kwargs,
-    # )
-
-    # return _UnsafeGlobalBuiltinImportCaptureHook(**kwargs)
+    if _capture is not None:
+        return _FrameBuiltinsImportCaptureHook(_frame=frame, **kwargs)
 
-    return _SomewhatThreadSafeGlobalBuiltinImportCaptureHook(**kwargs)
+    return _SomewhatThreadSafeGlobalBuiltinsImportCaptureHook(**kwargs)
 
 
 ##

{omlish-0.0.0.dev444 → omlish-0.0.0.dev445/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev444
+Version: 0.0.0.dev445
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev444 → omlish-0.0.0.dev445}/omlish.egg-info/SOURCES.txt

@@ -457,6 +457,7 @@ omlish/lang/classes/restrict.py
 omlish/lang/classes/simple.py
 omlish/lang/classes/virtual.py
 omlish/lang/imports/__init__.py
+omlish/lang/imports/_capture.cc
 omlish/lang/imports/capture.py
 omlish/lang/imports/conditional.py
 omlish/lang/imports/lazy.py

{omlish-0.0.0.dev444 → omlish-0.0.0.dev445}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev444'
+version = '0.0.0.dev445'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',