appmap 3.0.1__tar.gz → 4.0.0__tar.gz

{appmap-3.0.1 → appmap-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: appmap
-Version: 3.0.1
+Version: 4.0.0
 Summary: Create AppMap files by recording a Python application.
 Project-URL: Homepage, https://github.com/applandinc/appmap-python
 Author-email: Alan Potter <alan@app.land>, Viraj Kanwade <viraj.kanwade@forgeahead.io>, Rafał Rzepecki <rafal@app.land>
@@ -9,14 +9,24 @@ License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
 Classifier: Framework :: Flask
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Documentation
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Requires-Dist: importlib-resources>=5.4.0
 Requires-Dist: inflection>=0.3.0
 Requires-Dist: packaging>=19.0
@@ -33,8 +43,7 @@ Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'dev'
 Requires-Dist: httpx<1.0,>=0.27.0; extra == 'dev'
 Requires-Dist: incremental<24.7.0; extra == 'dev'
 Requires-Dist: isort<6.0,>=5.10.1; extra == 'dev'
-Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'dev'
-Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'dev'
+Requires-Dist: numpy>=2.0; extra == 'dev'
 Requires-Dist: pprintpp<1.0,>=0.4.0; extra == 'dev'
 Requires-Dist: psutil<7.0,>=6.0.0; extra == 'dev'
 Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'dev'
@@ -66,8 +75,7 @@ Requires-Dist: flask; extra == 'test'
 Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'test'
 Requires-Dist: httpx<1.0,>=0.27.0; extra == 'test'
 Requires-Dist: incremental<24.7.0; extra == 'test'
-Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'test'
-Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'test'
+Requires-Dist: numpy>=2.0; extra == 'test'
 Requires-Dist: psutil<7.0,>=6.0.0; extra == 'test'
 Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'test'
 Requires-Dist: pytest-console-scripts<2.0,>=1.4.1; extra == 'test'
@@ -185,7 +193,7 @@ cd appmap-python
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
 
 # Run tests with a specific Python version
-APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.11 appmap-python pytest
 
 # Run tests in parallel
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto

{appmap-3.0.1 → appmap-4.0.0}/README.md

@@ -96,7 +96,7 @@ cd appmap-python
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
 
 # Run tests with a specific Python version
-APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.11 appmap-python pytest
 
 # Run tests in parallel
 APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto

{appmap-3.0.1 → appmap-4.0.0}/_appmap/__init__.py

@@ -12,6 +12,7 @@ def initialize(**kwargs):
     importer.initialize()
     recorder.initialize()
     configuration.initialize()  # needs to be initialized after recorder
+    importer.install()  # needs the filters registered by configuration
     metadata.initialize()
     web_framework.initialize()
     recording.initialize()

{appmap-3.0.1 → appmap-4.0.0}/_appmap/configuration.py

@@ -185,13 +185,10 @@ class Config(metaclass=SingletonMeta):
         env = Env.current
         output_dir = env.output_dir
         root_dir = env.root_dir
-        try:
+        # If output_dir isn't relative to root_dir, APPMAP_OUTPUT_DIR is set, and we've already
+        # logged a warning.
+        if output_dir.is_relative_to(root_dir):
             ret["appmap_dir"] = str(output_dir.relative_to(root_dir))
-        except ValueError:
-            # The only way we can get here is if APPMAP_OUTPUT_DIR is set, and we've already logged
-            # a warning. (Note that PurePath.is_relative_to wasn't added till 3.9, so it can't be
-            # used here.)
-            pass
 
         return ret
 

{appmap-3.0.1 → appmap-4.0.0}/_appmap/event.py

@@ -156,10 +156,11 @@ class Event:
 
 
 class Param:
-    __slots__ = ["name", "kind", "default", "default_class"]
+    __slots__ = ["name", "kind", "positional_only", "default", "default_class"]
 
     def __init__(self, sigp):
         self.name = sigp.name
+        self.positional_only = sigp.kind == Parameter.POSITIONAL_ONLY
         has_default = sigp.default is not Signature.empty
         if sigp.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD):
             self.kind = "opt" if has_default else "req"
@@ -275,28 +276,34 @@ class CallEvent(Event):
             # we're popping the front repeatedly, lists are better at this
             args = list(args)
 
+        # Names of keyword arguments bound to named parameters. Python
+        # doesn't include them in **kwargs, so neither do we.
+        bound = set()
         for p in params:
-            if p.kind == "req":
-                # A 'req' argument can be either keyword or
-                # positional.
-                if p.name in kwargs:
+            if p.kind in ("req", "opt"):
+                # These can be either keyword or positional, unless
+                # they're positional-only.
+                if not p.positional_only and p.name in kwargs:
                     value = kwargs[p.name]
+                    bound.add(p.name)
+                elif args:
+                    value = args.pop(0)
+                elif p.kind == "opt":
+                    value = p.default
                 else:
-                    if args:
-                        value = args.pop(0)
-                    else:
-                        continue  # required argument missing
-            elif p.kind == "keyreq":
+                    continue  # required argument missing
+            elif p.kind in ("keyreq", "key"):
                 if p.name in kwargs:
                     value = kwargs[p.name]
+                    bound.add(p.name)
+                elif p.kind == "key":
+                    value = p.default
                 else:
                     continue  # required argument missing
-            elif p.kind in ("opt", "key"):
-                value = kwargs.get(p.name, p.default)
             elif p.kind == "rest":
                 value = tuple(args)
             elif p.kind == "keyrest":
-                value = kwargs
+                value = {k: v for k, v in kwargs.items() if k not in bound} if bound else kwargs
             else:
                 # If all the parameter types are handled, this
                 # shouldn't ever happen...

{appmap-3.0.1 → appmap-4.0.0}/_appmap/importer.py

@@ -166,7 +166,7 @@ class Importer:
     @classmethod
     def initialize(cls):
         cls.filter_stack = []
-        cls.filter_chain = []
+        cls.filter_chain = None
         cls._skip_instrumenting = ("appmap", "_appmap")
         cls.instrument_properties = (
             Env.current.get("APPMAP_INSTRUMENT_PROPERTIES", "true").lower() == "true"
@@ -176,6 +176,10 @@ class Importer:
     def use_filter(cls, filter_class):
         cls.filter_stack.append(filter_class)
 
+    @classmethod
+    def build_filter_chain(cls):
+        cls.filter_chain = reduce(lambda acc, e: e(acc), cls.filter_stack, NullFilter(None))
+
     @classmethod
     def instrument_function(cls, fn_name, filterableFn: FilterableFn, selected_functions=None):
         # Only instrument the function if it was specifically called out for the package
@@ -194,8 +198,10 @@ class Importer:
             return
 
         logger.trace("do_import, mod %s args %s kwargs %s", mod, args, kwargs)
-        if not cls.filter_chain:
-            cls.filter_chain = reduce(lambda acc, e: e(acc), cls.filter_stack, NullFilter(None))
+        if cls.filter_chain is None:
+            # Only possible while _appmap is being (re)initialized, before install() has run.
+            logger.trace("no filter chain yet, not instrumenting %s", mod.__name__)
+            return
 
         def instrument_functions(filterable, selected_functions=None):
             # pylint: disable=too-many-locals
@@ -314,26 +320,18 @@ def wrapped_find_spec(find_spec, _, args, kwargs):
 
 
 def wrap_finder_find_spec(finder):
-    # Prior to 3.11, it worked fine to just grab find_spec from the finder and wrap it. The
-    # implementation of builtin finders must have changed with 3.11, because we now need the same
-    # kind of workaround we use above for exec_module.
-    if sys.version_info[1] < 11:
-        find_spec = getattr(finder, "find_spec", None)
-        if find_spec is None:
-            logger.trace("no find_spec for finder %r", finder)
-            return
-
+    # Builtin finders define find_spec as a classmethod or staticmethod, which wrapt has trouble
+    # identifying (see the comment in wrapped_find_spec above), so wrap the descriptor found in
+    # __dict__ instead.
+    find_spec = inspect.getattr_static(finder, "find_spec", None)
+    if find_spec is None:
+        logger.trace("no find_spec for finder %r", finder)
+        return
+
+    if isinstance(find_spec, (classmethod, staticmethod)):
         finder.find_spec = wrap_finder_function(find_spec, wrapped_find_spec)
     else:
-        find_spec = inspect.getattr_static(finder, "find_spec", None)
-        if find_spec is None:
-            logger.trace("no find_spec for finder %r", finder)
-            return
-
-        if isinstance(find_spec, (classmethod, staticmethod)):
-            finder.find_spec = wrap_finder_function(find_spec, wrapped_find_spec)
-        else:
-            finder.find_spec = wrap_finder_function(finder.find_spec, wrapped_find_spec)
+        finder.find_spec = wrap_finder_function(finder.find_spec, wrapped_find_spec)
 
 
 class MetapathObserver(MutableSequence):
@@ -362,6 +360,18 @@ class MetapathObserver(MutableSequence):
 
 def initialize():
     Importer.initialize()
+
+
+def install():
+    """
+    Build the filter chain and hook the finders. Must run after the filters have been registered
+    (i.e. after configuration.initialize()).
+
+    The chain is built before the finders are hooked because building it can import modules (e.g.
+    since 3.13, importlib.metadata.files imports csv lazily). If the hooks were already in place,
+    those imports would need the chain that's still being built.
+    """
+    Importer.build_filter_chain()
     # If we're not enabled, there's no reason to hook the finders.
     if Env.current.enabled:
         logger.trace("sys.metapath: %s", sys.meta_path)

{appmap-3.0.1 → appmap-4.0.0}/_appmap/py_version_check.py

@@ -17,7 +17,7 @@ def _get_platform_version():
 
 
 def check_py_version():
-    req = (3, 8)
+    req = (3, 11)
     actual = _get_platform_version()
     if _get_py_version() < req:
         raise AppMapPyVerException(

{appmap-3.0.1 → appmap-4.0.0}/_appmap/test/data/params.py

@@ -22,6 +22,9 @@ class C:
     def with_defaults(self, p1=1, p2=2):
         return "%s %s" % (p1, p2)
 
+    def mixed(self, a, b=None, c="dflt", *args, d, e="e", **kwargs):
+        return "%s %s %s %s %s %s %s" % (a, b, c, args, d, e, kwargs)
+
 
 if sys.version_info >= (3, 8):
     exec(
@@ -33,5 +36,9 @@ C.positional_only = positional_only
 def keyword_only(self, *, p1, p2):
     return '%s %s' % (p1, p2)
 C.keyword_only = keyword_only
+
+def positional_only_kwargs(self, a, b="dflt", /, **kwargs):
+    return '%s %s %s' % (a, b, kwargs)
+C.positional_only_kwargs = positional_only_kwargs
     """
     )

{appmap-3.0.1 → appmap-4.0.0}/_appmap/test/test_command.py

@@ -115,14 +115,14 @@ class TestAgentValidate:
     def test_python_version(self, capsys, mocker):
         mocker.patch(
             "_appmap.py_version_check._get_py_version",
-            return_value=(3, 5),
+            return_value=(3, 10),
         )
         mocker.patch(
             "_appmap.py_version_check._get_platform_version",
-            return_value="3.5",
+            return_value="3.10",
         )
 
-        self.check_errors(capsys, 1, 1, r"Minimum Python version supported is \d\.\d, found")
+        self.check_errors(capsys, 1, 1, r"Minimum Python version supported is \d+\.\d+, found")
 
     def test_django_version(self, capsys, mocker):
         mocker.patch(

{appmap-3.0.1 → appmap-4.0.0}/_appmap/test/test_params.py

@@ -266,9 +266,6 @@ class TestInstanceMethods(TestMethodBase):
             },
         )
 
-    @pytest.mark.skipif(
-        sys.version_info < (3, 8), reason="positional-only added in 3.8"
-    )
     @pytest.mark.parametrize("params", ["positional_only"], indirect=True)
     def test_positional_only(self, params):
         evt = params.C().positional_only(1, 2)
@@ -282,7 +279,6 @@ class TestInstanceMethods(TestMethodBase):
             evt, 1, {"class": "builtins.int", "kind": "req", "name": "p2", "value": "2"}
         )
 
-    @pytest.mark.skipif(sys.version_info < (3, 8), reason="keyword-only added in 3.8")
     @pytest.mark.parametrize("params", ["keyword_only"], indirect=True)
     def test_keyword_only(self, params):
         evt = params.C().keyword_only(p2=2, p1=1)
@@ -325,3 +321,161 @@ class TestInstanceMethods(TestMethodBase):
         self.assert_parameter(
             evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
         )
+
+    @pytest.mark.parametrize("params", ["with_defaults"], indirect=True)
+    def test_defaults_positional(self, params):
+        evt = params.C().with_defaults(3, 4)
+        assert len(evt.parameters) == 2
+
+        self.assert_parameter(
+            evt, 0, {"class": "builtins.int", "kind": "opt", "name": "p1", "value": "3"}
+        )
+
+        self.assert_parameter(
+            evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
+        )
+
+    @pytest.mark.parametrize("params", ["with_defaults"], indirect=True)
+    def test_defaults_positional_and_keyword(self, params):
+        evt = params.C().with_defaults(3, p2=4)
+        assert len(evt.parameters) == 2
+
+        self.assert_parameter(
+            evt, 0, {"class": "builtins.int", "kind": "opt", "name": "p1", "value": "3"}
+        )
+
+        self.assert_parameter(
+            evt, 1, {"class": "builtins.int", "kind": "opt", "name": "p2", "value": "4"}
+        )
+
+
+class TestMixedParams(TestMethodBase):
+    """
+    C.mixed has the signature (self, a, b=None, c="dflt", *args, d, e="e", **kwargs),
+    covering every parameter kind.
+    """
+
+    def assert_values(self, evt, expected):
+        actual = {p["name"]: (p["kind"], p["value"]) for p in evt.parameters}
+        assert actual == expected
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_positional_opt(self, params):
+        evt = params.C().mixed("A", "B", "C", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "C"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_partial_positional_opt(self, params):
+        evt = params.C().mixed("A", "B", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_opt(self, params):
+        evt = params.C().mixed("A", c="C", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "C"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_rest_after_opt(self, params):
+        evt = params.C().mixed("A", "B", "C", "X", "Y", d="D")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "c": ("opt", "C"),
+                "args": ("rest", "('X', 'Y')"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_only(self, params):
+        evt = params.C().mixed("A", d="D", e="E", f="F")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "E"),
+                "kwargs": ("keyrest", "{'f': 'F'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["mixed"], indirect=True)
+    def test_keyword_req(self, params):
+        evt = params.C().mixed(a="A", d="D", f="F")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "None"),
+                "c": ("opt", "dflt"),
+                "args": ("rest", "()"),
+                "d": ("keyreq", "D"),
+                "e": ("key", "e"),
+                "kwargs": ("keyrest", "{'f': 'F'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["positional_only_kwargs"], indirect=True)
+    def test_positional_only_name_in_kwargs(self, params):
+        # Keyword arguments named like positional-only parameters go to **kwargs
+        evt = params.C().positional_only_kwargs("A", "B", a="X", b="Y")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "B"),
+                "kwargs": ("keyrest", "{'a': 'X', 'b': 'Y'}"),
+            },
+        )
+
+    @pytest.mark.parametrize("params", ["positional_only_kwargs"], indirect=True)
+    def test_positional_only_default_name_in_kwargs(self, params):
+        evt = params.C().positional_only_kwargs("A", b="Y")
+        self.assert_values(
+            evt,
+            {
+                "a": ("req", "A"),
+                "b": ("opt", "dflt"),
+                "kwargs": ("keyrest", "{'b': 'Y'}"),
+            },
+        )

{appmap-3.0.1 → appmap-4.0.0}/_appmap/test/test_properties.py

@@ -118,8 +118,7 @@ def test_operator_itemgetter(events):
     assert len(events) == 2
     assert events[0].to_dict() == DictIncluding({
         "event": "call",
-        # operator.itemgetter.__module__ isn't available before 3.10
-        # "defined_class": "operator",
+        "defined_class": "operator",
         "method_id": "itemgetter (get)",
     })
 

{appmap-3.0.1 → appmap-4.0.0}/appmap/command/runner.py

@@ -53,29 +53,12 @@ _parser.add_argument(
     default=argparse.SUPPRESS,
 )
 
-if sys.version_info >= (3, 9):
-    _parser.add_argument(
-        "--enable-log",
-        help="create a log file",
-        action=argparse.BooleanOptionalAction,
-        default=False,
-    )
-else:
-    # You can see why BooleanOptionalAction was added. This is close, though not
-    # really as good....
-    _enable_log_group = _parser.add_mutually_exclusive_group()
-    _enable_log_group.add_argument(
-        "--enable-log",
-        help="create a log file",
-        dest="enable_log",
-        action="store_true",
-    )
-    _enable_log_group.add_argument(
-        "--no-enable-log",
-        help="don't create a log file",
-        dest="enable_log",
-        action="store_false",
-    )
+_parser.add_argument(
+    "--enable-log",
+    help="create a log file",
+    action=argparse.BooleanOptionalAction,
+    default=False,
+)
 
 _parser.add_argument(
     "command",

{appmap-3.0.1 → appmap-4.0.0}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "appmap"
-version = "3.0.1"
+version = "4.0.0"
 description = "Create AppMap files by recording a Python application."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 license = { text = "MIT" }
 authors = [
   { name = "Alan Potter", email = "alan@app.land" },
@@ -14,10 +14,20 @@ classifiers = [
   "Development Status :: 4 - Beta",
   "Framework :: Django",
   "Framework :: Django :: 3.2",
+  "Framework :: Django :: 4.2",
+  "Framework :: Django :: 5.2",
+  "Framework :: Django :: 6.0",
   "Framework :: Flask",
   "Framework :: Pytest",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Topic :: Software Development",
   "Topic :: Software Development :: Debuggers",
   "Topic :: Software Development :: Documentation",
@@ -60,8 +70,7 @@ test = [
   "Flask",
   "sqlalchemy",
   "pytest-django>=4.7,<5.0",
-  "numpy>=1.24.4,<2.0; python_version < '3.9'",
-  "numpy>=2.0; python_version >= '3.9'",
+  "numpy>=2.0",
 ]
 dev = [
   "appmap[test]",