retracesoftware-utils 0.2.5__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.2.11__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

retracesoftware/utils/__init__.py

@@ -0,0 +1,172 @@
+"""
+retracesoftware.utils - Runtime selectable release/debug builds
+
+Set RETRACE_DEBUG=1 to use the debug build with symbols and assertions.
+"""
+import os
+import weakref
+import threading
+from collections import UserDict
+from typing import Callable, Any, Dict
+from contextlib import contextmanager
+from types import ModuleType
+
+
+def _is_truthy_env(v):
+    if v is None:
+        return False
+    return v.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+_DEBUG_MODE = _is_truthy_env(os.getenv("RETRACE_DEBUG"))
+
+_backend_mod: ModuleType
+__backend__: str
+
+try:
+    if _DEBUG_MODE:
+        import _retracesoftware_utils_debug as _backend_mod  # type: ignore
+        __backend__ = "native-debug"
+    else:
+        import _retracesoftware_utils_release as _backend_mod  # type: ignore
+        __backend__ = "native-release"
+except Exception:
+    raise ImportError("Failed to load retracesoftware_utils native extension")
+
+# Expose debug mode flag
+DEBUG_MODE = _DEBUG_MODE and __backend__.startswith("native")
+
+
+def __getattr__(name: str) -> Any:
+    return getattr(_backend_mod, name)
+
+
+def _export_public(mod: ModuleType) -> None:
+    g = globals()
+    for k, v in mod.__dict__.items():
+        if k.startswith("_"):
+            continue
+        g[k] = v
+
+
+_export_public(_backend_mod)
+
+
+# ---------------------------------------------------------------------------
+# High-level API (convenience wrappers around C++ extension)
+# ---------------------------------------------------------------------------
+
+def typeflags(cls):
+    bits = _backend_mod.type_flags(cls)
+    result = set()
+    for name, value in _backend_mod.TypeFlags.items():
+        if (value & bits) != 0:
+            result.add(name)
+    return result
+
+
+def is_method_descriptor(obj):
+    return 'Py_TPFLAGS_METHOD_DESCRIPTOR' in typeflags(type(obj))
+
+
+def flags(cls: type):
+    f = _backend_mod.type_flags(cls)
+    s = set()
+    for name, value in _backend_mod.TypeFlags.items():
+        if (f & value) != 0:
+            s.add(name)
+        f = f & ~value
+    if f != 0:
+        s.add(f)
+    return s
+
+
+class WithoutFlags:
+    def __init__(self, cls, *flags):
+        self.cls = cls
+        self.flags = flags
+
+    def __enter__(self):
+        self.saved = _backend_mod.type_flags(self.cls)
+        flags = self.saved
+        for flag in self.flags:
+            flags = flags & ~_backend_mod.TypeFlags[flag]
+        _backend_mod.set_type_flags(self.cls, flags)
+        return self.cls
+
+    def __exit__(self, *args):
+        _backend_mod.set_type_flags(self.cls, self.saved)
+
+
+class WithFlags:
+    def __init__(self, cls, *flags):
+        self.cls = cls
+        self.flags = flags
+
+    def __enter__(self):
+        self.saved = _backend_mod.type_flags(self.cls)
+        flags = self.saved
+        for flag in self.flags:
+            flags |= _backend_mod.TypeFlags[flag]
+        _backend_mod.set_type_flags(self.cls, flags)
+        return self.cls
+
+    def __exit__(self, *args):
+        _backend_mod.set_type_flags(self.cls, self.saved)
+
+
+def wrap_func_with_overrides(func, **overrides):
+    """
+    Return a new function identical to `func` but with selected global names
+    overridden by keyword arguments.
+    """
+    import builtins as _builtins
+    import types
+
+    orig = getattr(func, "__func__", func)
+    g = dict(orig.__globals__)
+    g.setdefault("__builtins__", _builtins.__dict__)
+    g.update(overrides)
+
+    return types.FunctionType(
+        orig.__code__, g, orig.__name__, orig.__defaults__, orig.__closure__
+    )
+
+
+def update(obj, name, f, *args, **kwargs):
+    value = getattr(obj, name)
+    setattr(obj, name, f(value, *args, **kwargs))
+
+
+class InterceptDict(dict):
+    def __init__(self, backing: Dict, on_set: Callable[[str, Any], Any]):
+        super().__init__()
+        self.backing = backing
+        self.on_set = on_set
+        self.move_from_backing()
+
+    def move_from_backing(self):
+        for key, value in self.backing.items():
+            super().__setitem__(key, self.on_set(key, value))
+        self.backing.clear()
+
+    def __getitem__(self, key):
+        self.move_from_backing()
+        return super().__getitem__(key)
+            
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.move_from_backing()
+        super().__setitem__(key, self.on_set(key, value))
+
+
+def map_values(f, m):
+    return {k: f(v) for k, v in m.items()}
+
+
+@contextmanager
+def on_set(dict, on_set):
+    _backend_mod.intercept_dict_set(dict, on_set)
+    yield
+    _backend_mod.intercept_dict_set(dict, None)
+
+
+__all__ = sorted([k for k in globals().keys() if not k.startswith("_")])

{retracesoftware_utils-0.2.5.dist-info → retracesoftware_utils-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: retracesoftware_utils
-Version: 0.2.5
+Version: 0.2.11
 Keywords: functional,programming,c-extension,utilities,performance
 Author-Email: Retrace Software <info@retracesoftware.com>
 Maintainer-Email: Retrace Software <info@retracesoftware.com>

retracesoftware_utils-0.2.11.dist-info/RECORD

@@ -0,0 +1,6 @@
+_retracesoftware_utils_debug.cpython-312-aarch64-linux-gnu.so,sha256=7MpnxSROKB431por57q48PCo4DqQWCxCPqZkWxv8JbU,3119112
+_retracesoftware_utils_release.cpython-312-aarch64-linux-gnu.so,sha256=1zqyFD24wXPZcjmV1-jAYdohHKmdC_DQtsJiDeoU_go,380776
+retracesoftware/utils/__init__.py,sha256=qxVskvjP9nDJ922awMqFQDk2zvcoUSB47MwUk8upBws,4585
+retracesoftware_utils-0.2.11.dist-info/WHEEL,sha256=ZPInqmoV0ASPMOQ0bb26_WmRflzUKSKcBoAb2iDqeyo,139
+retracesoftware_utils-0.2.11.dist-info/METADATA,sha256=BWcByveGWxJ5qjcCd9Yx68--7QTff4UcBiDMVDh_KfY,764
+retracesoftware_utils-0.2.11.dist-info/RECORD,,

retracesoftware_utils-0.2.5.data/purelib/retracesoftware/utils.py

@@ -1,162 +0,0 @@
-import retracesoftware_utils as _utils
-from retracesoftware_utils import *
-import weakref
-import threading
-from collections import UserDict
-from typing import Callable, Any
-from contextlib import contextmanager
-
-def typeflags(cls):
-    
-    bits = _utils.type_flags(cls)
-
-    result =  set()
-
-    for name,value in _utils.TypeFlags.items():
-        if (value & bits) != 0:
-            result.add(name)
-
-    return result
-
-def is_method_descriptor(obj):
-    return 'Py_TPFLAGS_METHOD_DESCRIPTOR' in typeflags(type(obj))
-
-def flags(cls : type):
-    f = _utils.type_flags(cls)
-
-    s = set()
-
-    for name,value in _utils.TypeFlags.items():
-        if (f & value) != 0:
-            s.add(name)
-        f = f & ~value
-
-    if f != 0:
-        s.add(f)
-
-    return s
-
-class WithoutFlags:
-
-    def __init__(self, cls  , *flags):
-        self.cls = cls
-        self.flags = flags
-
-    def __enter__(self):
-        self.saved = utils.type_flags(self.cls)
-        flags = self.saved
-
-        for flag in self.flags:
-            flags = flags & ~_utils.TypeFlags[flag]
-
-        _utils.set_type_flags(self.cls, flags)
-        return self.cls
-
-    def __exit__(self, *args):
-        _utils.set_type_flags(self.cls, self.saved)
-
-class WithFlags:
-
-    def __init__(self, cls  , *flags):
-        self.cls = cls
-        self.flags = flags
-
-    def __enter__(self):
-        self.saved = _utils.type_flags(self.cls)
-        flags = self.saved
-
-        for flag in self.flags:
-            flags |= _utils.TypeFlags[flag]
-
-        _utils.set_type_flags(self.cls, flags)
-        return self.cls
-
-    def __exit__(self, *args):
-        _utils.set_type_flags(self.cls, self.saved)
-
-def wrap_func_with_overrides(func, **overrides):
-    """
-    Return a new function identical to `func` but with selected global names
-    overridden by keyword arguments.
-
-    Example:
-        new_func = wrap_func_with_overrides(old_func, exec=my_exec, print=my_print)
-    """
-
-    import builtins as _builtins
-    import types
-
-    # Unwrap bound method if needed
-    orig = getattr(func, "__func__", func)
-
-    # Clone globals so we don't mutate the original module dict
-    g = dict(orig.__globals__)
-    g.setdefault("__builtins__", _builtins.__dict__)
-    g.update(overrides)
-
-    # Recreate the function
-    return types.FunctionType(
-        orig.__code__, g, orig.__name__, orig.__defaults__, orig.__closure__
-    )
-
-def update(obj, name, f, *args, **kwargs):
-    value = getattr(obj, name)
-    setattr(obj, name, f(value, *args, **kwargs))
-
-from typing import Dict, Any
-
-class InterceptDict(dict):
-    def __init__(self, backing: Dict, on_set: Callable[[str, Any], Any]):
-        """
-        A dictionary-like class that wraps an existing dictionary and calls a callback
-        to potentially modify values before they are added or updated.
-        
-        Args:
-            underlying_dict: The existing dictionary to wrap and modify directly.
-            on_set: Function that takes (key, value) and returns the value to store.
-            *args: Iterable of key-value pairs to update the underlying dict.
-            **kwargs: Keyword arguments to update the underlying dict.
-        """
-        super().__init__()
-        self.backing = backing
-        self.on_set = on_set
-        self.move_from_backing()
-        # self.fallback = initial
-
-        # store the dict version on the backing object
-
-        # Process additional items through the callback
-        # updates = dict(*args, **kwargs)
-        # for key, value in updates.items():
-        #     modified_value = self.on_set(key, value)
-        #     self._dict[key] = modified_value
-
-    def move_from_backing(self):
-        for key,value in self.backing.items():
-            super().__setitem__(key, self.on_set(key, value))
-        self.backing.clear()
-
-    def __getitem__(self, key):
-        self.move_from_backing()
-        return super().__getitem__(key)
-            
-    def __setitem__(self, key: str, value: Any) -> None:
-        """Set an item in the underlying dict, modifying the value via callback."""
-        self.move_from_backing()
-        super().__setitem__(key, self.on_set(key, value))
-    
-
-    # def update(self, *args, **kwargs) -> None:
-    #     """Update the underlying dict, processing values through the callback."""
-    #     updates = dict(*args, **kwargs)
-    #     for key, value in updates.items():            
-    #         self._dict[key] = self.on_set(key, value)
-    
-def map_values(f, m):
-    return {k: f(v) for k,v in m.items()}
-
-@contextmanager
-def on_set(dict, on_set):
-    _utils.intercept_dict_set(dict, on_set)
-    yield
-    _utils.intercept_dict_set(dict, None)

retracesoftware_utils-0.2.5.dist-info/RECORD

@@ -1,5 +0,0 @@
-retracesoftware_utils.cpython-312-aarch64-linux-gnu.so,sha256=vp09Wn2Q19CfSQT8qjgwMfrVEOBzbxq2zizBB1IYidc,380240
-retracesoftware_utils-0.2.5.data/purelib/retracesoftware/utils.py,sha256=oEvg-rvTXwum-rLKQ626ihr3A4XILdi-H3gGjnTTh9A,4641
-retracesoftware_utils-0.2.5.dist-info/WHEEL,sha256=ZPInqmoV0ASPMOQ0bb26_WmRflzUKSKcBoAb2iDqeyo,139
-retracesoftware_utils-0.2.5.dist-info/METADATA,sha256=PoO5SABlDQpwdd2rR3JhrI2YeQr6Hk1q2MeopspWNqU,763
-retracesoftware_utils-0.2.5.dist-info/RECORD,,