crosshair-tool 0.0.83__cp313-cp313-win_amd64.whl → 0.0.85__cp313-cp313-win_amd64.whl

crosshair/diff_behavior_test.py

@@ -81,7 +81,7 @@ def _sum_list_rewrite_2(int_list):
     return count
 
 
-class BehaviorDiffTest(unittest.TestCase):
+class TestBehaviorDiff:
     def test_diff_method(self):
         diffs = diff_behavior(
             walk_qualname(Base, "foo"),
@@ -89,10 +89,9 @@ class BehaviorDiffTest(unittest.TestCase):
             DEFAULT_OPTIONS.overlay(max_iterations=10),
         )
         assert isinstance(diffs, list)
-        self.assertEqual(
-            [(d.result1.return_repr, d.result2.return_repr) for d in diffs],
-            [("10", "11")],
-        )
+        assert [(d.result1.return_repr, d.result2.return_repr) for d in diffs] == [
+            ("10", "11")
+        ]
 
     def test_diff_staticmethod(self):
         diffs = diff_behavior(
@@ -100,20 +99,20 @@ class BehaviorDiffTest(unittest.TestCase):
             foo2,
             DEFAULT_OPTIONS.overlay(max_iterations=10),
         )
-        self.assertEqual(diffs, [])
+        assert diffs == []
 
     def test_diff_behavior_same(self) -> None:
         diffs = diff_behavior(foo1, foo2, DEFAULT_OPTIONS.overlay(max_iterations=10))
-        self.assertEqual(diffs, [])
+        assert diffs == []
 
     def test_diff_behavior_different(self) -> None:
         diffs = diff_behavior(foo1, foo3, DEFAULT_OPTIONS.overlay(max_iterations=10))
-        self.assertEqual(len(diffs), 1)
+        assert len(diffs) == 1
         diff = diffs[0]
         assert isinstance(diff, BehaviorDiff)
-        self.assertGreater(int(diff.args["x"]), 1000)
-        self.assertEqual(diff.result1.return_repr, "100")
-        self.assertEqual(diff.result2.return_repr, "1000")
+        assert int(diff.args["x"]) > 1000
+        assert diff.result1.return_repr == "100"
+        assert diff.result2.return_repr == "1000"
 
     def test_diff_behavior_mutation(self) -> None:
         def cut_out_item1(a: List[int], i: int):
@@ -130,10 +129,10 @@ class BehaviorDiffTest(unittest.TestCase):
             opts,
         )
         assert not isinstance(diffs, str)
-        self.assertEqual(len(diffs), 1)
+        assert len(diffs) == 1
         diff = diffs[0]
-        self.assertGreater(len(diff.args["a"]), 1)
-        self.assertEqual(diff.args["i"], "-1")
+        assert len(diff.args["a"]) > 1
+        assert diff.args["i"] == "-1"
 
     def test_example_coverage(self) -> None:
         # Try to get examples that highlist the differences in the code.
@@ -159,7 +158,7 @@ class BehaviorDiffTest(unittest.TestCase):
         debug("diffs=", diffs)
         assert not isinstance(diffs, str)
         return_vals = set((d.result1.return_repr, d.result2.return_repr) for d in diffs)
-        self.assertEqual(return_vals, {("False", "None"), ("False", "True")})
+        assert return_vals == {("False", "None"), ("False", "True")}
 
 
 def test_diff_behavior_lambda() -> None:
@@ -262,9 +261,3 @@ def test_diff_behavior_nan() -> None:
         DEFAULT_OPTIONS,
     )
     assert diffs == []
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/dynamic_typing.py

@@ -1,9 +1,13 @@
 import collections.abc
 import typing
-from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Type
+from inspect import Parameter, Signature
+from itertools import zip_longest
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Type
 
 import typing_inspect  # type: ignore
 
+from crosshair.util import debug  # type: ignore
+
 _EMPTYSET: frozenset = frozenset()
 
 
@@ -234,3 +238,88 @@ def realize(pytype: Type, bindings: Mapping[object, type]) -> object:
     if pytype_origin is Callable:  # Callable args get flattened
         newargs = [newargs[:-1], newargs[-1]]
     return pytype_origin.__getitem__(tuple(newargs))
+
+
+def isolate_var_params(
+    sig: Signature,
+) -> Tuple[
+    List[Parameter], Dict[str, Parameter], Optional[Parameter], Optional[Parameter]
+]:
+    pos_only_params: List[Parameter] = []
+    keyword_params: Dict[str, Parameter] = {}
+    var_positional: Optional[Parameter] = None
+    var_keyword: Optional[Parameter] = None
+    for name, param in sig.parameters.items():
+        if param.kind == Parameter.VAR_POSITIONAL:
+            var_positional = param
+        elif param.kind == Parameter.VAR_KEYWORD:
+            var_keyword = param
+        elif param.kind == Parameter.POSITIONAL_ONLY:
+            pos_only_params.append(param)
+        else:
+            keyword_params[name] = param
+    return pos_only_params, keyword_params, var_positional, var_keyword
+
+
+def intersect_signatures(
+    sig1: Signature,
+    sig2: Signature,
+) -> Signature:
+    """
+    Approximate the intersection of two signatures.
+    The resulting signature may be overly loose
+    (matching some inputs that neither of the original signatures would match),
+    but it should cover all the inputs for each original signature.
+
+    One minor exception: All arguments that are allowed to be called as
+    keyword arguments will be converted to keyword-only arguments.
+    We do this to resolve the abiguity when position-or-keyword arguments
+    appear in the same position but with different names.
+    """
+    pos1, key1, var_pos1, var_key1 = isolate_var_params(sig1)
+    pos2, key2, var_pos2, var_key2 = isolate_var_params(sig2)
+    is_squishy1 = var_pos1 is not None or var_key1 is not None
+    is_squishy2 = var_pos2 is not None or var_key2 is not None
+    out_params: Dict[str, Parameter] = {}
+    for (p1, p2) in zip_longest(pos1, pos2):
+        if p1 is None:
+            if is_squishy1:
+                out_params[p2.name] = p2
+        elif p2 is None:
+            if is_squishy2:
+                out_params[p1.name] = p1
+        elif unify(p1.annotation, p2.annotation):
+            out_params[p1.name] = p1
+        else:
+            out_params[p2.name] = p2
+    for key in [
+        k
+        for pair in zip_longest(key1.keys(), key2.keys())
+        for k in pair
+        if k is not None
+    ]:
+        if key not in key2:
+            if is_squishy2:
+                out_params[key] = key1[key].replace(kind=Parameter.KEYWORD_ONLY)
+            continue
+        if key not in key1:
+            if is_squishy1:
+                out_params[key] = key2[key].replace(kind=Parameter.KEYWORD_ONLY)
+            continue
+        if unify(key1[key].annotation, key2[key].annotation):
+            out_params[key] = key1[key].replace(kind=Parameter.KEYWORD_ONLY)
+        else:
+            out_params[key] = key2[key].replace(kind=Parameter.KEYWORD_ONLY)
+    if var_pos1 and var_pos2:
+        out_params[var_pos1.name] = var_pos1
+    if var_key1 and var_key2:
+        out_params[var_key1.name] = var_key1
+    if unify(sig1.return_annotation, sig2.return_annotation):
+        out_return_annotation = sig1.return_annotation
+    else:
+        out_return_annotation = sig2.return_annotation
+    result = Signature(
+        parameters=list(out_params.values()), return_annotation=out_return_annotation
+    )
+    debug("Combined __init__ and __new__ signatures", sig1, "and", sig2, "into", result)
+    return result

crosshair/dynamic_typing_test.py

@@ -1,4 +1,5 @@
 import collections
+from inspect import Parameter, Signature, signature
 from typing import (
     Callable,
     Dict,
@@ -6,15 +7,25 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    Optional,
     Sequence,
     Tuple,
     TypeVar,
     Union,
 )
 
+import pytest
 from typing_extensions import TypedDict
 
-from crosshair.dynamic_typing import get_bindings_from_type_arguments, realize, unify
+from crosshair.dynamic_typing import (
+    get_bindings_from_type_arguments,
+    intersect_signatures,
+    realize,
+    unify,
+)
+from crosshair.options import AnalysisOptionSet
+from crosshair.statespace import CANNOT_CONFIRM
+from crosshair.test_util import check_states
 
 _T = TypeVar("_T")
 _U = TypeVar("_U")
@@ -121,3 +132,64 @@ def test_bindings_from_type_arguments():
     var_mapping = get_bindings_from_type_arguments(Pair[int, str])
     assert var_mapping == {_U: int, _T: str}
     assert realize(List[_U], var_mapping) == List[int]
+
+
+def test_intersect_signatures_basic():
+    def f1(x: int, y: str, **kw) -> List[bool]:
+        return []
+
+    def f2(x: bool, *extra: str, **kw) -> List[int]:
+        return []
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    assert intersection.parameters == {
+        "x": Parameter("x", kind=Parameter.KEYWORD_ONLY, annotation=bool),
+        "y": Parameter("y", kind=Parameter.KEYWORD_ONLY, annotation=str),
+        "kw": Parameter("kw", kind=Parameter.VAR_KEYWORD),
+    }
+    assert intersection.return_annotation == List[bool]
+
+
+def test_intersect_signatures_typevars():
+    _T = TypeVar("_T")
+
+    def f1(cc, *args, **kwds):
+        pass
+
+    def f2(dd, left: Optional[_T], right: Optional[_T]):
+        pass
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    expected = {
+        "dd": Parameter("dd", kind=Parameter.KEYWORD_ONLY),
+        "left": Parameter("left", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]),
+        "right": Parameter(
+            "right", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]
+        ),
+    }
+    assert intersection.parameters == expected
+
+
+@pytest.mark.skip(
+    reason="The inspect module doesn't expose runtime type information yet"
+)
+def test_intersect_signature_with_crosshair():
+    def check_intersect_signatures(
+        sig1: Signature, sig2: Signature, pos_args: List, kw_args: Mapping[str, object]
+    ) -> None:
+        """post: True"""
+
+        def _sig_bindable(sig: Signature) -> bool:
+            try:
+                sig.bind(*pos_args, **kw_args)
+                return True
+            except TypeError:
+                return False
+
+        if _sig_bindable(sig1) or _sig_bindable(sig2):
+            intersection = intersect_signatures(sig1, sig2)
+            assert _sig_bindable(intersection)
+
+    check_states(check_intersect_signatures, CANNOT_CONFIRM)

crosshair/enforce_test.py

@@ -1,6 +1,5 @@
 import abc
 import sys
-import unittest
 from contextlib import ExitStack
 
 import pytest
@@ -57,21 +56,21 @@ class Enforcement(ExitStack):
         COMPOSITE_TRACER.trace_caller()
 
 
-class CoreTest(unittest.TestCase):
+class TestCore:
     def test_enforce_conditions(self) -> None:
-        self.assertEqual(foo(-1), -2)  # unchecked
+        assert foo(-1) == -2  # unchecked
         with Enforcement():
-            self.assertEqual(foo(50), 100)
-            with self.assertRaises(PreconditionFailed):
+            assert foo(50) == 100
+            with pytest.raises(PreconditionFailed):
                 foo(-1)
-            with self.assertRaises(PostconditionFailed):
+            with pytest.raises(PostconditionFailed):
                 foo(0)
 
     def test_class_enforce(self) -> None:
         Pokeable().pokeby(-1)  # no exception (yet!)
         with Enforcement():
             Pokeable().poke()
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 Pokeable().pokeby(-1)
 
     def test_enforce_on_uncopyable_value(self) -> None:
@@ -81,7 +80,7 @@ class CoreTest(unittest.TestCase):
 
         not_copyable = NotCopyable()
         with Enforcement():
-            with self.assertRaises(AttributeError):
+            with pytest.raises(AttributeError):
                 same_thing(not_copyable)
 
 
@@ -114,19 +113,19 @@ class DerivedFooable(BaseFooable):
         """pre: x > 0"""
 
 
-class TrickyCasesTest(unittest.TestCase):
+class TestTrickyCases:
     def test_attrs_restored_properly(self) -> None:
         orig_class_dict = DerivedFooable.__dict__.copy()
         with Enforcement():
             pass
         for k, v in orig_class_dict.items():
-            self.assertIs(
-                DerivedFooable.__dict__[k], v, f'member "{k}" changed afer encforcement'
-            )
+            assert (
+                DerivedFooable.__dict__[k] is v
+            ), f'member "{k}" changed afer encforcement'
 
     def test_enforcement_of_class_methods(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.class_foo(50)
         with Enforcement():
             DerivedFooable.class_foo(50)
@@ -134,14 +133,14 @@ class TrickyCasesTest(unittest.TestCase):
     def test_enforcement_of_static_methods(self) -> None:
         with Enforcement():
             DerivedFooable.static_foo(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.static_foo(50)
 
     def test_super_method_enforced(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo_only_in_super(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo(-1)
             # Derived class has a weaker precondition, so this is OK:
             DerivedFooable().foo(50)
@@ -181,9 +180,3 @@ def test_enforcement_init_on_abcmeta() -> None:
         with pytest.raises(PostconditionFailed):
             WithMetaclass(55)
         WithMetaclass(99)
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/fnutil_test.py

@@ -1,7 +1,6 @@
 import builtins
 import inspect
 import sys
-import unittest
 from dataclasses import dataclass
 from typing import Generic
 
@@ -27,7 +26,10 @@ def test_fn_globals_on_builtin() -> None:
 
 def test_resolve_signature_invalid_annotations() -> None:
     sig = resolve_signature(with_invalid_type_annotation)
-    assert sig == "name 'TypeThatIsNotDefined' is not defined"
+    if sys.version_info >= (3, 14):
+        assert sig == "TypeThatIsNotDefined"
+    else:
+        assert sig == "name 'TypeThatIsNotDefined' is not defined"
 
 
 @pytest.mark.skipif(
@@ -74,9 +76,3 @@ def test_load_function_at_line():
 
 def test_FunctionInfo_get_callable_on_generic():
     assert FunctionInfo.from_class(Generic, "__class_getitem__").get_callable() is None
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/libimpl/arraylib.py

@@ -1,5 +1,6 @@
+import sys
 from array import array
-from typing import BinaryIO, ByteString, Dict, Iterable, List, Sequence, Tuple
+from typing import BinaryIO, Dict, Iterable, List, Sequence, Tuple
 
 import z3  # type: ignore
 
@@ -29,10 +30,6 @@ INT_TYPE_BOUNDS: Dict[str, Tuple[int, int]] = {
 INT_TYPE_SIZE = {c: array(c).itemsize for c in INT_TYPE_BOUNDS.keys()}
 
 
-def is_bytes_like(obj: object) -> bool:
-    return isinstance(obj, (ByteString, array))
-
-
 def pick_code(space: StateSpace) -> Tuple[str, int, int]:
     last_idx = len(INT_TYPE_BOUNDS) - 1
     for (idx, (code, rng)) in enumerate(INT_TYPE_BOUNDS.items()):

crosshair/libimpl/binasciilib.py

@@ -1,7 +1,6 @@
 import binascii
-from collections.abc import ByteString
 from functools import partial
-from typing import Dict, Iterable, Tuple
+from typing import Dict, Iterable, Tuple, Union
 
 from crosshair.core import register_patch
 from crosshair.libimpl.builtinslib import _ALL_BYTES_TYPES, SymbolicBytes
@@ -89,7 +88,7 @@ _DECODE_MAPPER_BASE64_STRICT = partial(
 _ENCODE_MAPPER_BASE64 = partial(_remap, _ENCODE_BASE64_MAP)
 
 
-def make_bytes(arg: object) -> ByteString:
+def make_bytes(arg: object) -> Union[bytes, bytearray, memoryview]:
     if isinstance(arg, (bytes, bytearray, memoryview)):
         return arg
     if isinstance(arg, str):

crosshair/libimpl/builtinslib.py

@@ -17,11 +17,10 @@ from dataclasses import dataclass
 from itertools import zip_longest
 from math import inf, isfinite, isinf, isnan, nan
 from numbers import Integral, Number, Real
-from sys import maxunicode
+from sys import maxunicode, version_info
 from typing import (
     Any,
     BinaryIO,
-    ByteString,
     Callable,
     Dict,
     FrozenSet,
@@ -59,6 +58,8 @@ try:
 except ImportError:
     from z3 import FfpEQ as fpEQ
 
+import sys
+
 from crosshair.abcstring import AbcString
 from crosshair.core import (
     SymbolicFactory,
@@ -117,6 +118,7 @@ from crosshair.util import (
     assert_tracing,
     ch_stack,
     debug,
+    is_bytes_like,
     is_hashable,
     is_iterable,
     memo,
@@ -127,9 +129,9 @@ from crosshair.util import (
 from crosshair.z3util import z3And, z3Eq, z3Ge, z3Gt, z3IntVal, z3Not, z3Or
 
 if sys.version_info >= (3, 12):
-    from collections.abc import Buffer as BufferAbc
+    from collections.abc import Buffer
 else:
-    from collections.abc import ByteString as BufferAbc
+    from collections.abc import ByteString as Buffer
 
 
 _T = TypeVar("_T")
@@ -1214,10 +1216,11 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
         cur_divisor = 10
         while True:
             leftover = self // cur_divisor
-            if leftover == 0:
+            if leftover != 0:
+                codepoints.append(48 + (leftover % 10))
+                cur_divisor *= 10
+            else:
                 break
-            codepoints.append(48 + (leftover % 10))
-            cur_divisor *= 10
         with NoTracing():
             codepoints.reverse()
             return LazyIntSymbolicStr(codepoints)
@@ -1317,7 +1320,7 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
                 z3.If(val < 128, 7, 8)))))))))
             # fmt: on
 
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
 
         def is_integer(self):
             return True
@@ -2935,7 +2938,7 @@ class AnySymbolicStr(AbcString):
     def capitalize(self):
         if self.__len__() == 0:
             return ""
-        if sys.version_info >= (3, 8):
+        if version_info >= (3, 8):
             firstchar = self[0].title()
         else:
             firstchar = self[0].upper()
@@ -3173,7 +3176,7 @@ class AnySymbolicStr(AbcString):
         return ""
 
     def splitlines(self, keepends=False):
-        if sys.version_info < (3, 12):
+        if version_info < (3, 12):
             if not isinstance(keepends, int):
                 raise TypeError
         mylen = self.__len__()
@@ -3439,6 +3442,7 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
                 SliceView,
                 SequenceConcatenation,
                 list,  # TODO: are we sharing mutable state here?
+                tuple,
             ),
         ):
             self._codepoints = smtvar
@@ -3968,7 +3972,7 @@ def is_ascii_space_ord(char_ord: int):
     )
 
 
-class BytesLike(BufferAbc, AbcString, CrossHairValue):
+class BytesLike(Buffer, AbcString, CrossHairValue):
     def __eq__(self, other) -> bool:
         if not isinstance(other, _ALL_BYTES_TYPES):
             return False
@@ -3976,7 +3980,7 @@ class BytesLike(BufferAbc, AbcString, CrossHairValue):
             return False
         return list(self) == list(other)
 
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
 
         def __buffer__(self, flags: int):
             with NoTracing():
@@ -4136,7 +4140,10 @@ class SymbolicBytes(BytesLike):
         accumulated = []
         high = None
         if not isinstance(hexstr, str):
-            raise TypeError
+            if is_bytes_like(hexstr) and version_info >= (3, 14):
+                hexstr = LazyIntSymbolicStr(tuple(hexstr))
+            else:
+                raise TypeError
         for idx, ch in enumerate(hexstr):
             if not ch.isascii():
                 raise ValueError(
@@ -4895,7 +4902,7 @@ def _int_from_bytes(
 ) -> int:
     if byteorder is _MISSING:
         # byteorder defaults to "big" as of 3.11
-        if sys.version_info >= (3, 11):
+        if version_info >= (3, 11):
             byteorder = "big"
         else:
             raise TypeError
@@ -5038,11 +5045,11 @@ def _str_percent_format(self, other):
 
 
 def _bytes_join(self, itr) -> str:
-    return _join(self, itr, self_type=bytes, item_type=BufferAbc)
+    return _join(self, itr, self_type=bytes, item_type=Buffer)
 
 
 def _bytearray_join(self, itr) -> str:
-    return _join(self, itr, self_type=bytearray, item_type=BufferAbc)
+    return _join(self, itr, self_type=bytearray, item_type=Buffer)
 
 
 def _str_format(self, *a, **kw) -> Union[AnySymbolicStr, str]:
@@ -5109,7 +5116,7 @@ def make_registrations():
 
     register_type(Union, make_union_choice)
 
-    if sys.version_info >= (3, 8):
+    if version_info >= (3, 8):
         from typing import Final
 
         register_type(Final, lambda p, t: p(t))
@@ -5178,7 +5185,7 @@ def make_registrations():
     register_type(SupportsFloat, lambda p: p(float))
     register_type(SupportsInt, lambda p: p(int))
     register_type(SupportsRound, lambda p: p(float))
-    register_type(SupportsBytes, lambda p: p(ByteString))
+    register_type(SupportsBytes, lambda p: p(Buffer))
     register_type(SupportsComplex, lambda p: p(complex))
 
     # Patches
@@ -5267,7 +5274,7 @@ def make_registrations():
         "upper",
         "zfill",
     ]
-    if sys.version_info >= (3, 9):
+    if version_info >= (3, 9):
         names_to_str_patch.append("removeprefix")
         names_to_str_patch.append("removesuffix")
     for name in names_to_str_patch:
@@ -5323,12 +5330,12 @@ def make_registrations():
     # Patches on int
     register_patch(int.__repr__, with_checked_self(int, "__repr__"))
     register_patch(int.as_integer_ratio, with_checked_self(int, "as_integer_ratio"))
-    if sys.version_info >= (3, 10):
+    if version_info >= (3, 10):
         register_patch(int.bit_count, with_checked_self(int, "bit_count"))
     register_patch(int.bit_length, with_checked_self(int, "bit_length"))
     register_patch(int.conjugate, with_checked_self(int, "conjugate"))
     register_patch(int.from_bytes, _int_from_bytes)
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
         register_patch(int.is_integer, with_checked_self(int, "is_integer"))
     register_patch(int.to_bytes, with_checked_self(int, "to_bytes"))
 

crosshair/libimpl/builtinslib_test.py

@@ -8,7 +8,6 @@ import math
 import operator
 import re
 import sys
-import unittest
 from abc import ABC, abstractmethod
 from array import array
 from numbers import Integral
@@ -2882,7 +2881,7 @@ def test_frozenset___or__(space):
         assert len(s1 | s2) == 2
 
 
-class ProtocolsTest(unittest.TestCase):
+class TestProtocols:
     # TODO: move most of this into a collectionslib_test.py file
     def test_hashable_values_fail(self) -> None:
         def f(b: bool, i: int, t: Tuple[str, ...]) -> int:
@@ -3657,9 +3656,3 @@ def TODO_test_deepcopy_independence():
         with NoTracing():
             assert ls[0] is not lscopy[0]
         # Next try mutation on one and test the other...
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()