crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/copyext.py

@@ -1,4 +1,9 @@
-from copy import _deepcopy_atomic  # type: ignore
+import sys
+
+if sys.version_info >= (3, 14):
+    from copy import _atomic_types
+else:
+    from copy import _deepcopy_atomic  # type: ignore
 from copy import _deepcopy_dict  # type: ignore
 from copy import _deepcopy_dispatch  # type: ignore
 from copy import _deepcopy_list  # type: ignore
@@ -8,10 +13,17 @@ from copy import _reconstruct  # type: ignore
 from copy import Error
 from copyreg import dispatch_table  # type: ignore
 from enum import Enum
-from typing import Any, Dict
+from types import MappingProxyType
+from typing import Any, Callable, Dict, Tuple
 
-from crosshair.tracers import is_tracing
-from crosshair.util import debug, test_stack
+from crosshair.tracers import ResumedTracing
+from crosshair.util import (
+    CrossHairInternal,
+    IdKeyedDict,
+    assert_tracing,
+    ch_stack,
+    debug,
+)
 
 _MISSING = object
 
@@ -22,22 +34,54 @@ class CopyMode(int, Enum):
     REALIZE = 2
 
 
+# We need to be able to realize some types that are not deep-copyable.
+# Such realization overrides are defined here.
+# TODO: This capability should probably be something that plugins can extend
+_DEEP_REALIZATION_OVERRIDES = IdKeyedDict()
+_DEEP_REALIZATION_OVERRIDES[MappingProxyType] = lambda p, m: MappingProxyType(
+    deepcopyext(dict(p), CopyMode.REALIZE, m)
+)
+if sys.version_info >= (3, 10):
+    _DEEP_REALIZATION_OVERRIDES[type({}.items())] = lambda p, m: deepcopyext(
+        p.mapping, CopyMode.REALIZE, m
+    ).items()
+    _DEEP_REALIZATION_OVERRIDES[type({}.keys())] = lambda p, m: deepcopyext(
+        p.mapping, CopyMode.REALIZE, m
+    ).keys()
+    _DEEP_REALIZATION_OVERRIDES[type({}.values())] = lambda p, m: deepcopyext(
+        p.mapping, CopyMode.REALIZE, m
+    ).values()
+
+
+@assert_tracing(False)
 def deepcopyext(obj: object, mode: CopyMode, memo: Dict) -> Any:
-    assert not is_tracing()
     objid = id(obj)
     cpy = memo.get(objid, _MISSING)
-    if cpy is _MISSING:
+    if cpy is not _MISSING:
+        if objid not in map(id, memo.get(id(memo), ())):
+            # we are trying to return some value that was not kept alive;
+            # it may have been garbage collected and replaced.
+            raise CrossHairInternal("Possibly transient value found in memo")
+    else:
+        _keep_alive(obj, memo)
+        deepconstruct_obj = obj
         if mode == CopyMode.REALIZE:
             cls = type(obj)
             if hasattr(cls, "__ch_deep_realize__"):
-                cpy = obj.__ch_deep_realize__()  # type: ignore
+                cpy = obj.__ch_deep_realize__(memo)  # type: ignore
             elif hasattr(cls, "__ch_realize__"):
                 # Do shallow realization here, and then fall through to
                 # _deepconstruct below.
-                obj = obj.__ch_realize__()  # type: ignore
+                deepconstruct_obj = obj.__ch_realize__()  # type: ignore
+                # this transient object may be inserted into memo below
+                _keep_alive(deepconstruct_obj, memo)
+            else:
+                realization_override = _DEEP_REALIZATION_OVERRIDES.get(cls)
+                if realization_override:
+                    cpy = realization_override(obj, memo)
         if cpy is _MISSING:
             try:
-                cpy = _deepconstruct(obj, mode, memo)
+                cpy = _deepconstruct(deepconstruct_obj, mode, memo)
             except TypeError as exc:
                 if mode == CopyMode.REGULAR:
                     raise
@@ -46,41 +90,66 @@ def deepcopyext(obj: object, mode: CopyMode, memo: Dict) -> Any:
                     type(obj),
                     "ignoring",
                     type(exc),
+                    ":",
+                    str(exc),
                     "at",
-                    test_stack(exc.__traceback__),
+                    ch_stack(currently_handling=exc),
                 )
-                cpy = obj
+                cpy = deepconstruct_obj
         memo[objid] = cpy
-        _keep_alive(obj, memo)
     return cpy
 
 
+if sys.version_info >= (3, 14):
+
+    def lookup_dispatch(cls: type) -> Callable:
+        if cls in _atomic_types:
+            return lambda obj, memo: obj
+        return _deepcopy_dispatch.get(cls)
+
+else:
+
+    def lookup_dispatch(cls: type) -> Callable:
+        return _deepcopy_dispatch.get(cls)
+
+
 def _deepconstruct(obj: object, mode: CopyMode, memo: Dict):
     cls = type(obj)
 
     def subdeepcopy(obj: object, memo: Dict):
         return deepcopyext(obj, mode, memo)
 
-    if cls in _deepcopy_dispatch:
-        creator = _deepcopy_dispatch[cls]
-        if creator is _deepcopy_atomic:
-            return obj
-        elif creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
+    creator = lookup_dispatch(cls)
+    if creator is not None:
+        if creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
             return creator(obj, memo, deepcopy=subdeepcopy)
         else:
+            # TODO: We loose subdeepcopy in this case - won't
+            # that make e.g. deep_realize be too shallow?
             return creator(obj, memo)
     if isinstance(obj, type):
         return obj
     if mode != CopyMode.REALIZE and hasattr(obj, "__deepcopy__"):
         return obj.__deepcopy__(memo)  # type: ignore
     if cls in dispatch_table:
-        reduct = dispatch_table[cls](obj)
-    elif hasattr(obj, "__reduce_ex__"):
-        reduct = getattr(obj, "__reduce_ex__")(4)
-    elif hasattr(obj, "__reduce__"):
-        reduct = getattr(obj, "__reduce__")()
+        to_call = dispatch_table[cls]
+        call_args: Tuple = (obj,)
+    elif hasattr(cls, "__reduce_ex__"):
+        to_call = getattr(cls, "__reduce_ex__")
+        call_args = (obj, 4)
+    elif hasattr(cls, "__reduce__"):
+        to_call = getattr(cls, "__reduce__")
+        call_args = (obj,)
     else:
         raise Error("un(deep)copyable object of type %s" % cls)
+    if (
+        getattr(cls, "__reduce__") is object.__reduce__
+        and getattr(cls, "__reduce_ex__") is object.__reduce_ex__
+    ):
+        reduct = to_call(*call_args)
+    else:
+        with ResumedTracing():
+            reduct = to_call(*call_args)
     if isinstance(reduct, str):
         return obj
     return _reconstruct(obj, memo, *reduct, deepcopy=subdeepcopy)

crosshair/copyext_test.py

@@ -1,3 +1,4 @@
+import sys
 from copy import deepcopy
 from threading import RLock
 from typing import Tuple
@@ -33,6 +34,16 @@ def test_deepcopyext_symbolic_set():
             deepcopyext(s, CopyMode.REALIZE, {})
 
 
+def test_deepcopyext_realize_simple(space):
+    x = SymbolicInt("x")
+    input = (x,)
+    output = deepcopyext(input, CopyMode.REALIZE, {})
+    assert input is not output
+    assert input[0] is not output[0]
+    assert type(input[0]) is SymbolicInt
+    assert type(output[0]) is int
+
+
 def test_deepcopyext_realize(space):
     x = SymbolicInt("x")
     lock = RLock()
@@ -49,3 +60,25 @@ def test_deepcopyext_realize(space):
 def test_deepcopyext_tuple_type():
     assert deepcopy(Tuple) is Tuple
     assert deepcopyext(Tuple, CopyMode.REALIZE, {}) is Tuple
+
+
+class RecursiveType:
+    a: "RecursiveType"
+
+    def set(self, a):
+        self.a = a
+
+
+def test_deepcopyext_recursivetype(space):
+    recursive_obj = RecursiveType()
+    recursive_obj.set(recursive_obj)
+    deepcopyext(recursive_obj, CopyMode.REALIZE, {})
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 10), reason="dict views not inspect-able before python 3.10"
+)
+def test_fsum_accepts_dict_values_argument(space):
+    d = {"a": proxy_for_type(int, "b")}
+    realized_vals = deepcopyext(d.values(), CopyMode.REALIZE, {})
+    assert type(next(iter(realized_vals))) is int