codeanalyzer-python 1.1.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

codeanalyzer/options/__init__.py

@@ -1,3 +1,3 @@
-from .options import AnalysisOptions, EmitTarget, OutputFormat, ShardStrategy
+from .options import AnalysisOptions, EmitTarget
 
-__all__ = ["AnalysisOptions", "EmitTarget", "OutputFormat", "ShardStrategy"]
+__all__ = ["AnalysisOptions", "EmitTarget"]

codeanalyzer/options/options.py

@@ -1,14 +1,9 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Tuple
 from enum import Enum
 
 
-class OutputFormat(str, Enum):
-    JSON = "json"
-    MSGPACK = "msgpack"
-
-
 class EmitTarget(str, Enum):
     """Output target selected by ``--emit``.
 
@@ -23,25 +18,10 @@ class EmitTarget(str, Enum):
     SCHEMA = "schema"
 
 
-class ShardStrategy(str, Enum):
-    """How ``--pycg-shard`` groups files into shards (level 2 only).
-
-    - ``jedi``    : partition the Jedi module-dependency graph (strongly-
-                    connected-component condensation + Louvain) so tightly-
-                    coupled modules co-compute and few call edges are severed
-                    between shards. Import cycles are never split.
-    - ``package`` : legacy one-shard-per-package-directory grouping.
-    """
-
-    JEDI = "jedi"
-    PACKAGE = "package"
-
-
 @dataclass
 class AnalysisOptions:
     input: Path
     output: Optional[Path] = None
-    format: OutputFormat = OutputFormat.JSON
     emit: EmitTarget = EmitTarget.JSON
     app_name: Optional[str] = None
     neo4j_uri: Optional[str] = None
@@ -57,12 +37,13 @@ class AnalysisOptions:
     rebuild_analysis: bool = False
     skip_tests: bool = True
     no_venv: bool = False
+    resolve_installed: bool = False
     file_name: Optional[Path] = None
     cache_dir: Optional[Path] = None
     clear_cache: bool = False
     verbosity: int = 0
-    pycg_shard: bool = False
-    pycg_shard_ceiling: int = 100
-    pycg_shard_timeout: int = 120
-    pycg_shard_strategy: ShardStrategy = ShardStrategy.JEDI
-    pycg_max_iter: int = 50
+    entrypoint_rules: Tuple[Path, ...] = ()
+    # Artifact text-capture controls (#157 follow-up): whether to capture
+    # `source` at all, and the per-file byte cap before it truncates.
+    artifact_text: bool = True
+    artifact_text_max_bytes: int = 262144

codeanalyzer/schema/__init__.py

@@ -62,6 +62,31 @@ if not PYDANTIC_V2:
     )
     Analysis.update_forward_refs(PyApplication=PyApplication)
     
+# Fields the analyzer keeps in memory (and in the cache) but never emits.
+# `call_sites` is the internal record `body{}` call nodes are derived from (#120);
+# emitting both shipped the same fact twice under two identity schemes.
+INTERNAL_ONLY_FIELDS = frozenset({"call_sites"})
+
+
+def strip_internal_only(data):
+    """Recursively drop `INTERNAL_ONLY_FIELDS` from a dumped payload.
+
+    Applied at emit time rather than as a field-level Pydantic `exclude`, because
+    the analysis cache uses the same serializer -- excluding at the field would
+    drop these from the cache as well, and the next warm-cache run would rebuild
+    from a payload with no call sites.
+    """
+    if isinstance(data, dict):
+        return {
+            k: strip_internal_only(v)
+            for k, v in data.items()
+            if k not in INTERNAL_ONLY_FIELDS
+        }
+    if isinstance(data, list):
+        return [strip_internal_only(v) for v in data]
+    return data
+
+
 # Compatibility helpers for Pydantic v1/v2
 def model_dump_json(model, **kwargs):
     """Compatibility helper for JSON serialization."""
@@ -79,6 +104,27 @@ def model_dump_json(model, **kwargs):
             v1_kwargs['separators'] = kwargs['separators']
         return model.json(**v1_kwargs)
 
+def model_dump(model, **kwargs):
+    """Compatibility helper for dict serialization (v2 model_dump / v1 dict).
+
+    ``mode="json"`` (v2) maps to a json round-trip on v1 so both versions
+    yield JSON-safe primitives.
+    """
+    if PYDANTIC_V2:
+        return model.model_dump(**kwargs)
+    import json as _json
+    mode = kwargs.pop("mode", None)
+    v1_kwargs = {k: v for k, v in kwargs.items() if k in ("exclude_none", "exclude")}
+    if mode == "json":
+        return _json.loads(model.json(**v1_kwargs))
+    return model.dict(**v1_kwargs)
+
+
+def model_copy(model):
+    """Compatibility helper for copying a model (v2 model_copy / v1 copy)."""
+    return model.model_copy() if PYDANTIC_V2 else model.copy()
+
+
 def model_validate_json(model_class, json_data):
     """Compatibility helper for JSON deserialization."""
     if PYDANTIC_V2:
@@ -89,5 +135,7 @@ def model_validate_json(model_class, json_data):
 __all__.extend([
     "PYDANTIC_V2",
     "model_dump_json",
+    "strip_internal_only",
+    "INTERNAL_ONLY_FIELDS",
     "model_validate_json"
 ])

codeanalyzer/schema/ids.py

@@ -21,3 +21,24 @@ def callable_sig_segment(name: str, param_names: List[str]) -> str:
 
 def ordinal_id(callable_id: str, tag: str) -> str:
     return f"{callable_id}@{tag}"
+
+
+def artifact_id(app_name: str, rel_path: str) -> str:
+    """Language-neutral artifact id: ``can://artifact/<app>/<rel-path>``.
+
+    The first segment is a namespace (a language for code nodes, the literal
+    ``artifact`` for files), so sibling analyzers over the same repo emit the
+    same id for the same file."""
+    return f"can://artifact/{app_name}/{rel_path}"
+
+
+def config_key_id(artifact_id: str, dotted_key: str) -> str:
+    """A ``PyConfigKey`` extracted from an artifact: ``<artifact-id>@key/<dotted.key>``.
+    ``dotted_key`` uses numeric segments for array indices (e.g.
+    ``services.web.ports.0``); ids are opaque, do not re-split them."""
+    return f"{artifact_id}@key/{dotted_key}"
+
+
+def purl_pypi(name: str) -> str:
+    """Package URL for a (PEP 503 normalized) PyPI distribution name."""
+    return f"pkg:pypi/{name}"

codeanalyzer/schema/l1_body.py

@@ -9,7 +9,17 @@ def _do_callable(source: str, c: PyCallable) -> None:
         span = Span(start=(cs.start_line, cs.start_column),
                     end=(cs.end_line, cs.end_column),
                     bytes=byte_offsets(source, cs.start_line, cs.start_column, cs.end_line, cs.end_column)) if source else None
-        c.body[key] = BodyNode(kind="call", span=span, callee=None)
+        c.body[key] = BodyNode(
+            kind="call",
+            span=span,
+            callee=None,
+            method_name=cs.method_name,
+            receiver_expr=cs.receiver_expr,
+            receiver_type=cs.receiver_type,
+            return_type=cs.return_type,
+            is_constructor_call=cs.is_constructor_call,
+            arguments=list(cs.arguments or []),
+        )
     for ic in (c.callables or {}).values():
         _do_callable(source, ic)
     for icl in (c.types or {}).values():

codeanalyzer/schema/l2_callees.py

@@ -1,36 +1,52 @@
 """L2 refinement: fill each L1 `call` body node's `callee` (null→id) from the
 call site's resolved signature — the one sanctioned value change. A declared
 target becomes its can:// id; an external/library target keeps its dotted
-signature; an unresolved call site leaves `callee` absent."""
+signature; an unresolved call site leaves `callee` absent.
+
+Two resolution sources feed the backfill: Jedi's `callee_signature` on the
+call site itself, and the defuse linker's returned map (keyed by caller
+signature + "line:col"). The linker's resolutions are deliberately NOT written
+into `callee_signature` — the symbol table round-trips through the analysis
+cache, and a persisted resolution would resurface on a warm run as a Jedi
+edge, silently changing provenance."""
 from __future__ import annotations
 from codeanalyzer.schema.py_schema import PyApplication, PyClass, PyCallable
 
 
-def _do_callable(c: PyCallable, sig_to_id: dict) -> None:
+def _do_callable(c: PyCallable, sig_to_id: dict, resolutions: dict) -> None:
     for cs in c.call_sites or []:
-        if cs.callee_signature is None:
-            continue
         key = f"{cs.start_line}:{cs.start_column}"
+        jedi_sig = cs.callee_signature
+        if jedi_sig and jedi_sig.startswith("typing."):
+            # A decorator-typed callable resolved to its annotation, not a
+            # target; the linker's resolution (if any) is the real callee.
+            jedi_sig = None
+        sig = jedi_sig or resolutions.get((c.signature, key))
+        if not sig:
+            continue
         node = c.body.get(key)
         if node is None or node.kind != "call":
             continue
-        node.callee = sig_to_id.get(cs.callee_signature, cs.callee_signature)
+        node.callee = sig_to_id.get(sig, sig)
     for ic in (c.callables or {}).values():
-        _do_callable(ic, sig_to_id)
+        _do_callable(ic, sig_to_id, resolutions)
     for icl in (c.types or {}).values():
-        _do_class(icl, sig_to_id)
+        _do_class(icl, sig_to_id, resolutions)
 
 
-def _do_class(cl: PyClass, sig_to_id: dict) -> None:
+def _do_class(cl: PyClass, sig_to_id: dict, resolutions: dict) -> None:
     for m in (cl.callables or {}).values():
-        _do_callable(m, sig_to_id)
+        _do_callable(m, sig_to_id, resolutions)
     for ic in (cl.types or {}).values():
-        _do_class(ic, sig_to_id)
+        _do_class(ic, sig_to_id, resolutions)
 
 
-def backfill_callees(app: PyApplication, sig_to_id: dict) -> None:
+def backfill_callees(
+    app: PyApplication, sig_to_id: dict, resolutions: dict | None = None
+) -> None:
+    resolutions = resolutions or {}
     for mod in app.symbol_table.values():
         for fn in (mod.functions or {}).values():
-            _do_callable(fn, sig_to_id)
+            _do_callable(fn, sig_to_id, resolutions)
         for cl in (mod.types or {}).values():
-            _do_class(cl, sig_to_id)
+            _do_class(cl, sig_to_id, resolutions)