crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/core_and_libs.py

@@ -0,0 +1,149 @@
+"""Register all type handlers and exports core functionality."""
+
+import sys
+from typing import List
+
+from packaging import version
+
+from crosshair import opcode_intercept
+
+# These imports are just for exporting functionality:
+from crosshair.core import (
+    AnalysisMessage,
+    MessageType,
+    _reset_all_registrations,
+    analyze_any,
+    analyze_class,
+    analyze_function,
+    analyze_module,
+    proxy_for_type,
+    run_checkables,
+    standalone_statespace,
+)
+
+# Modules with registrations:
+from crosshair.libimpl import (
+    arraylib,
+    binasciilib,
+    builtinslib,
+    codecslib,
+    collectionslib,
+    copylib,
+    datetimelib,
+    decimallib,
+    fractionlib,
+    functoolslib,
+    hashliblib,
+    heapqlib,
+    importliblib,
+    iolib,
+    ipaddresslib,
+    itertoolslib,
+    jsonlib,
+    mathlib,
+    oslib,
+    randomlib,
+    relib,
+    timelib,
+    typeslib,
+    unicodedatalib,
+    urlliblib,
+    weakreflib,
+    zliblib,
+)
+from crosshair.options import AnalysisKind, AnalysisOptions
+from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import debug
+
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
+
+installed_plugins: List[str] = []  # We record these for diagnostic purposes
+__all__ = [
+    "analyze_function",
+    "analyze_any",
+    "analyze_class",
+    "analyze_module",
+    "run_checkables",
+    "proxy_for_type",
+    "standalone_statespace",
+    "AnalysisMessage",
+    "MessageType",
+    "AnalysisKind",
+    "AnalysisOptions",
+    "NoTracing",
+    "ResumedTracing",
+    "debug",
+]
+
+
+def _make_registrations():
+    _reset_all_registrations()
+    arraylib.make_registrations()
+    binasciilib.make_registrations()
+    builtinslib.make_registrations()
+    codecslib.make_registrations()
+    collectionslib.make_registrations()
+    copylib.make_registrations()
+    datetimelib.make_registrations()
+    decimallib.make_registrations()
+    functoolslib.make_registrations()
+    fractionlib.make_registrations()
+    hashliblib.make_registrations()
+    heapqlib.make_registrations()
+    jsonlib.make_registrations()
+    importliblib.make_registrations()
+    iolib.make_registrations()
+    ipaddresslib.make_registrations()
+    itertoolslib.make_registrations()
+    mathlib.make_registrations()
+    oslib.make_registrations()
+    randomlib.make_registrations()
+    relib.make_registrations()
+    timelib.make_registrations()
+    typeslib.make_registrations()
+    unicodedatalib.make_registrations()
+    urlliblib.make_registrations()
+    opcode_intercept.make_registrations()
+    weakreflib.make_registrations()
+    zliblib.make_registrations()
+
+    plugin_entries = entry_points(group="crosshair.plugin")
+    for plugin_entry in plugin_entries:
+        installed_plugins.append(plugin_entry.name)
+        plugin_entry.load()
+
+    # We monkey patch icontract below to prevent it from enforcing contracts.
+    # (we want to control how and when they run)
+    # TODO: consider a better home for this code
+    try:
+        import icontract  # type: ignore
+
+        if version.parse(icontract.__version__) < version.parse("2.4.0"):
+            raise Exception("CrossHair requires icontract version >= 2.4.0")
+
+        icontract._checkers._assert_invariant = lambda *a, **kw: None
+        icontract._checkers._assert_preconditions = lambda *a, **kw: None
+        icontract._checkers._assert_postconditions = lambda *a, **kw: None
+    except ImportError:
+        pass
+
+    try:
+        import deal  # type: ignore
+
+        deal_version = version.parse(deal.__version__)
+        if deal_version < version.parse("4.13.0"):
+            raise Exception("CrossHair requires deal version >= 4.13.0")
+        if deal_version < version.parse("4.21.2"):
+            deal.disable()
+        else:
+            # deal >= 4.21.2 throws runtime warnings.
+            deal.disable(warn=False)
+    except ImportError:
+        pass
+
+
+_make_registrations()

crosshair/core_regestered_types_test.py

@@ -0,0 +1,82 @@
+import collections
+import re
+from dataclasses import dataclass
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Final,
+    List,
+    NamedTuple,
+    NoReturn,
+    SupportsBytes,
+    SupportsComplex,
+    Union,
+)
+
+import pytest  # type: ignore
+import typing_inspect  # type: ignore
+
+from crosshair.core import _SIMPLE_PROXIES, proxy_for_type
+from crosshair.dynamic_typing import origin_of
+from crosshair.tracers import ResumedTracing
+from crosshair.util import CrosshairUnsupported, debug, name_of_type
+
+"""
+Tests that the builtin and standard library types behave like their
+counterparts.
+"""
+
+
+possible_args = [
+    (),
+    (Any,),
+    (Any, Any),
+    (Any, Any, Any),
+]
+
+untested_types = {
+    # These types won't check at runtime:
+    Union,
+    NoReturn,
+    Final,
+    BinaryIO,
+    SupportsBytes,
+    SupportsComplex,
+    # Callable actually works ok but can throw IgnoreAttempt
+    collections.abc.Callable,
+    # TODO: make a symbolic NamedTuple that intercepts attribute access:
+    NamedTuple,
+}
+
+
+comparisons: List = []
+for typ, creator in _SIMPLE_PROXIES.items():
+    if typ in untested_types:
+        continue
+    name = name_of_type(typ)
+    comparisons.append(pytest.param(typ, creator, id=name))
+    if typing_inspect.is_generic_type(typ) and hasattr(typ, "__getitem__"):
+        for nargs in range(1, 3):
+            type_args = tuple([Any for _ in range(nargs)])
+            try:
+                typ_paramed = typ.__getitem__(type_args)
+            except TypeError:
+                pass
+            else:
+                comparisons.append(
+                    pytest.param(typ_paramed, creator, id=name + "_with_{nargs}_args")
+                )
+
+
+@pytest.mark.parametrize("typ,creator", comparisons)
+def test_patch(typ: type, creator: Callable, space):
+    debug("Patch test:", typ, creator)
+    try:
+        proxy = proxy_for_type(typ, "x")
+    except CrosshairUnsupported:
+        debug("Ignored pass - CrossHair explicitly does not support this type")
+        return
+    origin = origin_of(typ)
+    with ResumedTracing():
+        assert isinstance(proxy, origin)