codeanalyzer-python 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -16,6 +16,7 @@ from codeanalyzer.schema.py_schema import (
     PyCallableParameter,
     PyCallArgument,
     PyCallsite,
+    PyDecorator,
     PyClass,
     PyClassAttribute,
     PyComment,
@@ -258,10 +259,26 @@ class SymbolTableBuilder:
 
         return imports
 
+    @staticmethod
+    def _scope_definitions(node: AST):
+        """Yield the def/class statements belonging to *node*'s own scope.
+
+        Sees through compound statements — a ``def`` under a module-level
+        ``if sys.platform == ...:``, inside a ``try:`` import guard, or
+        conditionally defined within a method body is still a definition of
+        that scope (#148 reference comparison caught these missing). Never
+        descends into a yielded def/class: nested scopes recurse separately.
+        """
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                yield child
+            else:
+                yield from SymbolTableBuilder._scope_definitions(child)
+
     def _add_class(self, node: AST, script: Script, source: str, prefix: str = "") -> Dict[str, PyClass]:
         classes: Dict[str, PyClass] = {}
 
-        for child in ast.iter_child_nodes(node):
+        for child in self._scope_definitions(node):
             if not isinstance(child, ast.ClassDef):
                 continue
 
@@ -295,6 +312,7 @@ class SymbolTableBuilder:
                 .name(class_name)
                 .signature(signature)
                 .span(span)
+                .decorators(self._decorators(child, script, source))
                 .start_line(start_line)
                 .end_line(end_line)
                 .comments(self._pycomments(child, code))
@@ -317,7 +335,7 @@ class SymbolTableBuilder:
     def _callables(self, node: AST, script: Script, source: str, prefix: str = "") -> Dict[str, PyCallable]:
         callables: Dict[str, PyCallable] = {}
 
-        for child in ast.iter_child_nodes(node):
+        for child in self._scope_definitions(node):
             if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 method_name = child.name  # Keep the actual method name unchanged
                 start_line = child.lineno
@@ -331,7 +349,11 @@ class SymbolTableBuilder:
                                        getattr(child, "end_lineno", child.lineno),
                                        getattr(child, "end_col_offset", child.col_offset)),
                 )
-                decorators = [ast.unparse(d) for d in child.decorator_list]
+                decorators = self._decorators(child, script, source)
+                # `async def` is a declaration modifier, not a distinct kind (#130).
+                modifiers = (
+                    ["async"] if isinstance(child, ast.AsyncFunctionDef) else []
+                )
                 
                 if prefix:
                     # We're in a nested context - build signature with prefix
@@ -357,6 +379,7 @@ class SymbolTableBuilder:
                     .signature(signature)  # Use the full signature here
                     .span(span)
                     .decorators(decorators)
+                    .modifiers(modifiers)
                     .start_line(start_line)
                     .end_line(end_line)
                     .code_start_line(child.body[0].lineno if child.body else start_line)
@@ -590,6 +613,68 @@ class SymbolTableBuilder:
 
         return params
 
+    def _decorators(
+        self, node: ast.AST, script: Optional[Script], source: str = ""
+    ) -> List[PyDecorator]:
+        """Structure each entry of ``node.decorator_list`` (#128).
+
+        ``name`` is the spelling as written and ``qualified_name`` is Jedi's
+        resolution of it, inferred at the last identifier of the callee so that
+        ``@a.b.c`` resolves ``c`` rather than ``a``. Resolution is best-effort:
+        dynamic, conditional and re-exported decorators stay unresolved, and a
+        failure here must never abort the symbol table.
+        """
+        out: List[PyDecorator] = []
+        for dec in getattr(node, "decorator_list", []) or []:
+            callee = dec.func if isinstance(dec, ast.Call) else dec
+            positional: List[str] = []
+            keyword: Dict[str, str] = {}
+            if isinstance(dec, ast.Call):
+                positional = [ast.unparse(a) for a in dec.args]
+                for kw in dec.keywords:
+                    # ``**kwargs`` has no arg name; keep it addressable rather
+                    # than dropping it.
+                    key = kw.arg if kw.arg is not None else f"**{ast.unparse(kw.value)}"
+                    keyword[key] = ast.unparse(kw.value)
+            span = Span(
+                start=(dec.lineno, dec.col_offset),
+                end=(getattr(dec, "end_lineno", dec.lineno),
+                     getattr(dec, "end_col_offset", dec.col_offset)),
+                bytes=byte_offsets(source, dec.lineno, dec.col_offset,
+                                   getattr(dec, "end_lineno", dec.lineno),
+                                   getattr(dec, "end_col_offset", dec.col_offset)),
+            ) if source else None
+            out.append(
+                PyDecorator.builder()
+                .name(ast.unparse(callee))
+                .qualified_name(self._decorator_qualified_name(callee, script))
+                .positional_arguments(positional)
+                .keyword_arguments(keyword)
+                .expression(ast.unparse(dec))
+                .span(span)
+                .build()
+            )
+        return out
+
+    @staticmethod
+    def _decorator_qualified_name(
+        callee: ast.AST, script: Optional[Script]
+    ) -> Optional[str]:
+        """Jedi's full name for a decorator's callee, or ``None``."""
+        if script is None:
+            return None
+        line = getattr(callee, "end_lineno", getattr(callee, "lineno", None))
+        col = getattr(callee, "end_col_offset", None)
+        if line is None or col is None:
+            return None
+        try:
+            d = SymbolTableBuilder._first_definition(
+                script.infer(line=line, column=max(col - 1, 0))
+            )
+        except Exception:
+            return None
+        return getattr(d, "full_name", None) if d is not None else None
+
     def _accessed_symbols(
         self, fn_node: ast.FunctionDef, script: Script
     ) -> List[PySymbol]:

{codeanalyzer_python-1.1.0.dist-info → codeanalyzer_python-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 1.1.0
+Version: 1.2.0
 Summary: Static analysis for Python — canonical schema v2 (symbol table, call graph, and native CFG/PDG/SDG dataflow) as analysis.json or a Neo4j property graph.
 Author-email: Rahul Krishna <i.m.ralk@gmail.com>
 License-File: LICENSE
@@ -9,20 +9,13 @@ Requires-Python: >=3.9
 Requires-Dist: astor<0.9.0,>=0.8.1
 Requires-Dist: jedi<0.20.0,>=0.18.0; python_version < '3.11'
 Requires-Dist: jedi<=0.19.2; python_version >= '3.11'
-Requires-Dist: msgpack<1.0.7,>=1.0.0; python_version < '3.11'
-Requires-Dist: msgpack<2.0.0,>=1.0.7; python_version >= '3.11'
 Requires-Dist: networkx<3.2.0,>=2.6.0; python_version < '3.11'
 Requires-Dist: networkx<4.0.0,>=3.0.0; python_version >= '3.11'
-Requires-Dist: numpy<1.24.0,>=1.21.0; python_version < '3.11'
-Requires-Dist: numpy<2.0.0,>=1.24.0; python_version >= '3.11' and python_version < '3.12'
-Requires-Dist: numpy<2.0.0,>=1.26.0; python_version >= '3.12'
 Requires-Dist: packaging>=25.0
-Requires-Dist: pandas<2.0.0,>=1.3.0; python_version < '3.11'
-Requires-Dist: pandas<3.0.0,>=2.0.0; python_version >= '3.11'
 Requires-Dist: parso>=0.8.5
-Requires-Dist: pycg>=0.0.6
 Requires-Dist: pydantic<2.0.0,>=1.8.0; python_version < '3.11'
 Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.11'
+Requires-Dist: pyyaml<7.0,>=6.0
 Requires-Dist: ray<3.0.0,>=2.10.0; python_version >= '3.11'
 Requires-Dist: ray==2.0.0; python_version < '3.11'
 Requires-Dist: requests<3.0.0,>=2.20.0; python_version >= '3.11'
@@ -55,7 +48,7 @@ Description-Content-Type: text/markdown
 ---
 
 `canpy` is a static analyzer for Python built on [Jedi](https://jedi.readthedocs.io/),
-[PyCG](https://github.com/vitsalis/PyCG), and [Tree-sitter](https://tree-sitter.github.io/). It
+and [Tree-sitter](https://tree-sitter.github.io/). It
 emits the **canonical CodeLLM-DevKit (CLDK) schema v2** — a single, additive Code Property Graph
 tree — either as `analysis.json` or projected into a **Neo4j property graph**. It is the Python
 backend behind [CLDK](https://github.com/codellm-devkit/python-sdk), mirroring its
@@ -97,8 +90,9 @@ needs.
   at a single `application` node with durable `can://` ids on every callable and above.
 - **Symbol table** — modules, classes, functions, methods, variables, decorators, imports, and
   docstrings, with precise byte-offset source spans; each module carries its `source` once.
-- **Call graph** — Jedi's lexical resolver at level 1, enriched with **PyCG**-resolved edges at
-  level 2 (provenance-tagged, coupling-aware sharding for large apps).
+- **Call graph** — Jedi's lexical resolver at level 1, enriched at level 2 by a per-callable
+  **defuse linker** that resolves call sites through local def-use chains and module-scope
+  bindings (provenance-tagged, deterministic, no global fixpoint).
 - **Dataflow graphs** — native, per-callable exceptional **CFG** plus **control-** and
   **data-dependence** edges (`cfg`/`cdg`/`ddg`) at level 3, stitched into a whole-program
   **interprocedural SDG** (synthetic parameter vertices, `param_in`/`param_out`/`summary`,
@@ -109,7 +103,7 @@ needs.
   checked in as `schema.neo4j.json` (`2.0.0`) and shipped with every release.
 - **Incremental cache** — per-file results are cached under `.codeanalyzer`; `--lazy` (default)
   reuses them, `--eager` forces a clean rebuild. `--ray` distributes the work across cores.
-- **Compact output** — canonical `analysis.json`, or binary `analysis.msgpack` for smaller artifacts.
+- **Compact output** — one canonical `analysis.json` per run.
 
 ## Installation
 
@@ -182,8 +176,7 @@ canpy --input /path/to/python/project
 ```
 
 With no `--output`, the analysis is printed to stdout as compact JSON; with `--output <dir>` it is
-written to `analysis.json` (or `graph.cypher` for `--emit neo4j`, or `analysis.msgpack` with
-`--format msgpack`) in that directory.
+written to `analysis.json` (or `graph.cypher` for `--emit neo4j`) in that directory.
 
 ### Options
 
@@ -194,7 +187,7 @@ $ canpy --help
 
  Usage: canpy [OPTIONS] COMMAND [ARGS]...
 
- Static Analysis on Python source code using Jedi, PyCG and Tree sitter.
+ Static Analysis on Python source code using Jedi and Tree sitter.
 
 ╭─ Options ────────────────────────────────────────────────────────────────────╮
 │ --version                                                   Show the canpy   │
@@ -207,10 +200,6 @@ $ canpy --help
 │                                                             --emit schema).  │
 │ --output           -o                     <path>            Output directory │
 │                                                             for artifacts.   │
-│ --format           -f                     <json|msgpack>    Output format    │
-│                                                             for --emit json: │
-│                                                             json or msgpack. │
-│                                                             [default: json]  │
 │ --emit                                    <json|neo4j|sche  Output target:   │
 │                                           ma>               json             │
 │                                                             (analysis.json,  │
@@ -258,7 +247,8 @@ $ canpy --help
 │ --analysis-level   -a                     <int range>       Analysis depth:  │
 │                                           [1<=x<=4]         1=symbol         │
 │                                                             table+Jedi call  │
-│                                                             graph, 2=+PyCG   │
+│                                                             graph,           │
+│                                                             2=+defuse-linker │
 │                                                             call graph,      │
 │                                                             3=+native        │
 │                                                             intraprocedural  │
@@ -270,7 +260,7 @@ $ canpy --help
 │                                                             edges,           │
 │                                                             alias-aware      │
 │                                                             DDG).            │
-│                                                             [default: 1]     │
+│                                                             [default: (1)]   │
 │ --graphs                                  <str>             Level 3+ only:   │
 │                                                             comma-separated  │
 │                                                             program-graph    │
@@ -282,8 +272,12 @@ $ canpy --help
 │                                                             PDG's data edges │
 │                                                             only; `sdg`      │
 │                                                             requires -a 4.   │
+│                                                             Incompatible     │
+│                                                             with --emit      │
+│                                                             neo4j (always    │
+│                                                             full-depth).     │
 │                                                             [default:        │
-│                                                             cfg,dfg,pdg]     │
+│                                                             (cfg,dfg,pdg)]   │
 │ --graph-field-de…                         <int range>       Level 3 only:    │
 │                                           [x>=1]            k-limit on       │
 │                                                             access-path      │
@@ -344,134 +338,14 @@ $ canpy --help
 │                                                             verbosity: -v,   │
 │                                                             -vv, -vvv        │
 │                                                             [default: 0]     │
-│ --pycg-shard           --no-pycg-shard                      Shard PyCG       │
-│                                                             call-graph       │
-│                                                             analysis by      │
-│                                                             Python package   │
-│                                                             (level 2 only).  │
-│                                                             When the project │
-│                                                             exceeds the      │
-│                                                             500-file         │
-│                                                             ceiling, PyCG is │
-│                                                             run              │
-│                                                             independently    │
-│                                                             per top-level    │
-│                                                             package with     │
-│                                                             cross-package    │
-│                                                             imports treated  │
-│                                                             as ghost nodes.  │
-│                                                             Without this     │
-│                                                             flag, projects   │
-│                                                             over the ceiling │
-│                                                             fall back to     │
-│                                                             Jedi-only edges. │
-│                                                             [default:        │
-│                                                             no-pycg-shard]   │
-│ --pycg-shard-cei…                         <int range>       Maximum files    │
-│                                           [x>=1]            per shard when   │
-│                                                             --pycg-shard is  │
-│                                                             active (default  │
-│                                                             100). Shards     │
-│                                                             exceeding this   │
-│                                                             limit are        │
-│                                                             skipped; their   │
-│                                                             call edges are   │
-│                                                             omitted from the │
-│                                                             call graph (Jedi │
-│                                                             edges for those  │
-│                                                             packages are     │
-│                                                             still included). │
-│                                                             Lower values are │
-│                                                             safer for        │
-│                                                             packages with    │
-│                                                             deep class       │
-│                                                             hierarchies or   │
-│                                                             heavy import     │
-│                                                             graphs.          │
-│                                                             [default: 100]   │
-│ --pycg-shard-tim…                         <int range>       Per-shard        │
-│                                           [x>=0]            wall-clock       │
-│                                                             timeout in       │
-│                                                             seconds when     │
-│                                                             --pycg-shard is  │
-│                                                             active (default  │
-│                                                             120). A shard    │
-│                                                             that exceeds     │
-│                                                             this limit is    │
-│                                                             skipped          │
-│                                                             gracefully.      │
-│                                                             PyCG's fixpoint  │
-│                                                             is bimodal: it   │
-│                                                             either converges │
-│                                                             quickly or       │
-│                                                             diverges         │
-│                                                             indefinitely, so │
-│                                                             the timeout acts │
-│                                                             as a final       │
-│                                                             safety net after │
-│                                                             the file-count   │
-│                                                             ceiling. Set to  │
-│                                                             0 to disable.    │
-│                                                             POSIX only       │
-│                                                             (macOS / Linux); │
-│                                                             ignored on       │
-│                                                             Windows.         │
-│                                                             [default: 120]   │
-│ --pycg-shard-str…                         <jedi|package>    How --pycg-shard │
-│                                                             groups files     │
-│                                                             (level 2 only).  │
-│                                                             'jedi' (default) │
-│                                                             partitions the   │
-│                                                             Jedi             │
-│                                                             module-dependen… │
-│                                                             graph (SCC +     │
-│                                                             Louvain) so      │
-│                                                             tightly-coupled  │
-│                                                             modules          │
-│                                                             co-compute and   │
-│                                                             few call edges   │
-│                                                             are severed      │
-│                                                             between shards;  │
-│                                                             import cycles    │
-│                                                             are never split. │
-│                                                             'package' uses   │
-│                                                             the legacy       │
-│                                                             one-shard-per-p… │
-│                                                             grouping.        │
-│                                                             [default: jedi]  │
-│ --pycg-max-iter                           <int range>       Cap on PyCG's    │
-│                                           [x>=-1]           fixpoint passes  │
-│                                                             per              │
-│                                                             shard/project    │
-│                                                             (level 2;        │
-│                                                             default 50).     │
-│                                                             PyCG iterates    │
-│                                                             until its        │
-│                                                             points-to state  │
-│                                                             stops changing,  │
-│                                                             but its          │
-│                                                             access-path      │
-│                                                             domain has no    │
-│                                                             convergence      │
-│                                                             bound, so heavy  │
-│                                                             metaclass/mixin  │
-│                                                             code (e.g. an    │
-│                                                             ORM) can loop    │
-│                                                             with each pass   │
-│                                                             costing seconds. │
-│                                                             The cap returns  │
-│                                                             a                │
-│                                                             sound-but-incom… │
-│                                                             call graph       │
-│                                                             instead of       │
-│                                                             looping until    │
-│                                                             the timeout      │
-│                                                             kills it. Set to │
-│                                                             -1 for PyCG's    │
-│                                                             unbounded        │
-│                                                             run-to-converge… │
-│                                                             behaviour.       │
-│                                                             [default: 50]    │
+│ --entrypoint-rul…                         <path>            Extra entrypoint │
+│                                                             rules file       │
+│                                                             (YAML).          │
+│                                                             Repeatable;      │
+│                                                             merges with the  │
+│                                                             shipped rules. A │
+│                                                             malformed file   │
+│                                                             is an error.     │
 │ --help                                                      Show this        │
 │                                                             message and      │
 │                                                             exit.            │
@@ -493,13 +367,14 @@ $ canpy --help
    canpy --input ./my-python-project --output ./out --format msgpack   # → ./out/analysis.msgpack
    ```
 
-3. **Enrich the call graph with PyCG (level 2):**
+3. **Enrich the call graph with the defuse linker (level 2):**
    ```sh
    canpy --input ./my-python-project -a 2
    ```
-   Level 1 edges come from Jedi's lexical resolution. `-a 2` runs **PyCG** and merges its
-   flow-sensitive edges in (RPC / third-party / dynamically-dispatched targets), backfilling
-   callees Jedi could not resolve. Every edge is provenance-tagged (e.g. `jedi`, `pycg`).
+   Level 1 edges come from Jedi's lexical resolution. `-a 2` runs the **defuse linker** —
+   per-callable resolution over lexical scopes, import bindings, class hierarchies, and a
+   bounded type-propagation round — and merges its edges with Jedi's, backfilling the
+   callees Jedi could not resolve. Every edge is provenance-tagged (`jedi`, `defuse`).
 
 4. **Emit a Neo4j snapshot, or push to a live database:**
    ```sh
@@ -528,7 +403,7 @@ $ canpy --help
    canpy --input ./my-python-project -a 3 --graph-field-depth 2   # tighter access-path k-limit
    ```
    Levels 3 and 4 also enrich the Neo4j projection (`--emit neo4j`) with the CPG overlay
-   (`:PyCFGNode` nodes wired by `PY_CFG_NEXT`/`PY_CDG`/`PY_DDG`, plus the level-4
+   (`:PyBodyNode` nodes wired by `PY_CFG_NEXT`/`PY_CDG`/`PY_DDG`, plus the level-4
    `PY_PARAM_IN`/`PY_PARAM_OUT`/`PY_SUMMARY` edges — the cross-language dataflow vocabulary,
    PY_-namespaced like every other row family so multi-language databases never mingle
    analyzers' edges).
@@ -541,7 +416,7 @@ levels are cumulative and additive — `analysis.json(-a 1) ⊆ … ⊆ analysis
 | Level | Flag | What it adds | Where it lands |
 | --- | --- | --- | --- |
 | **1** | `-a 1` (default) | Symbol table, Jedi call graph, and `call` nodes in each callable's `body` | `body` calls (`callee: null`) |
-| **2** | `-a 2` | PyCG call-graph enrichment; each call's `callee` backfilled to a `can://` id | `call_graph`, `body` callees |
+| **2** | `-a 2` | Defuse-linker call-graph enrichment; each call's `callee` backfilled to a `can://` id | `call_graph`, `body` callees |
 | **3** | `-a 3` | Native **intraprocedural** CFG/CDG/DDG (syntactic, name-equality, `prov: ["ssa"]`) | `cfg`, `cdg`, `ddg`, `@entry`/`@exit` on each callable |
 | **4** | `-a 4` | **Interprocedural** SDG: synthetic param vertices, alias-aware DDG (`prov: ["points-to"]`) | `param_in`, `param_out`, `summary`, semantic `ddg` |
 
@@ -570,7 +445,7 @@ symbol-table signature by construction
   external dependency to install; the analyzer falls back to the built-in `TypeBasedAliasOracle`
   (Jedi-inferred types; unknown types conservatively alias) only when Scalpel can't resolve a
   construct or a per-callable build fails, keeping the `may_alias` interface total. Call dispatch
-  comes from the merged Jedi(+PyCG) call graph, treated as a frozen oracle.
+  comes from the merged Jedi + defuse-linker call graph, treated as a frozen oracle.
 - **Summaries:** relational formal-in → formal-out flows composed bottom-up over the Tarjan SCC
   condensation of the call graph, a monotone fixpoint within SCCs; globals ride as extra formals,
   closure captures bind at definition sites.
@@ -609,7 +484,7 @@ just populate more of the same tree:
       }
     },
     "call_graph": [ { "src": "can://…/main(a)", "dst": "can://…/helper(x)",
-                      "weight": 1, "prov": ["jedi", "pycg"] } ],
+                      "weight": 1, "prov": ["defuse", "jedi"] } ],
     "external_symbols": {         // imported/builtin call targets, keyed by id
       "can://python/<app>/@external/os/getcwd":
         { "id": "can://python/<app>/@external/os/getcwd", "kind": "external",
@@ -675,7 +550,7 @@ label is `Py`-prefixed and every relationship type is `PY_`-prefixed (e.g. `:PyC
 so multiple language analyzers can share one database without label or relationship-type collisions.
 Declarations are keyed by their **`can://` id** under a shared `:PySymbol` label; calls, imports,
 inheritance, decorators, and call sites are relationships. At `-a 3`/`-a 4` the projection gains the
-**CPG overlay** — `:PyCFGNode` nodes (statements, and at level 4 the parameter vertices) wired by
+**CPG overlay** — `:PyBodyNode` nodes (statements, and at level 4 the parameter vertices) wired by
 `PY_CFG_NEXT`/`PY_CDG`/`PY_DDG`, plus the level-4 `PY_PARAM_IN`/`PY_PARAM_OUT`/`PY_SUMMARY` edges:
 
 - **Without `--neo4j-uri`** — writes a self-contained `graph.cypher` (constraints + indexes, a scoped

{codeanalyzer_python-1.1.0.dist-info → codeanalyzer_python-1.2.0.dist-info}/RECORD

@@ -1,21 +1,19 @@
 codeanalyzer/__init__.py,sha256=BZ3Kuwl-F_F-8H8cepLnVJ4Ku4NNUjjqg0Y6ujPQSsI,108
-codeanalyzer/__main__.py,sha256=fukx4MhfahAdwN1oHRDkbOaAZZanXrHpHwWV4FG6esg,16275
-codeanalyzer/core.py,sha256=ZBPXgRNWlSW2utzaII686TsppIvbFCPUz5337OxaKvg,43095
+codeanalyzer/__main__.py,sha256=hmuIKxpW7TFfGaBGb1HiHCFS02dCQxVhG7FkruXECWQ,14954
+codeanalyzer/core.py,sha256=vkU8djqKmyX4mXmb5rOz3oRjlMWYjMB7dWB_toIHnu4,42140
 codeanalyzer/provenance.py,sha256=DT-DqwdVwO7g-GyK3sC0_4vDNCUjZYEY1fyYCt-7VRM,2306
 codeanalyzer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codeanalyzer/config/__init__.py,sha256=9XBxAn1oWGRuhg3bEBUuVGs3hFNXEAKrr-Ce7tq9a2k,61
-codeanalyzer/config/config.py,sha256=ZiKzc5uEUCIvih58-6BDtLLI1hPij41wGQjBcj9KNQM,188
 codeanalyzer/dataflow/__init__.py,sha256=HCNOH24rAGLUMG94N9aC-2SsAWSntk3uys7e39ipU5o,1725
-codeanalyzer/dataflow/access_paths.py,sha256=9BUaupb9_jev3pYcRSBroKt5IDCRhpfssxWUWxwcEDM,22821
+codeanalyzer/dataflow/access_paths.py,sha256=wC8Q9qD-RZzkoFWMVvu_6uNNmYP8z48OGp9h9v3F1d4,23623
 codeanalyzer/dataflow/alias.py,sha256=ZYKY0DiR3GHv6YJr7C001Lode9rZsk6-gxdomUyIvwg,3928
-codeanalyzer/dataflow/builder.py,sha256=QhsezCYCEDw_hdFudD6aUoVah9nE0B7M4dQC3YU1agE,28248
+codeanalyzer/dataflow/builder.py,sha256=sCngN3MWfCbHteSHiue8l7AUVQNttETJInsgVMy_xkY,31317
 codeanalyzer/dataflow/cfg.py,sha256=u5YXJjAaDshdgv-9kWWITbBJFP-MwXKq6hbNh0fhDm8,25307
 codeanalyzer/dataflow/defuse.py,sha256=LrX1ToOZzR79NlAGg5T647UAFkpiEqEnT7t0K5RXOiI,4377
 codeanalyzer/dataflow/dominance.py,sha256=X7Ki1QRdVqaseYsJtiUL7m9MbcC2WHEv9b8bczSLFUA,5086
-codeanalyzer/dataflow/identity.py,sha256=jGuyPrtRL5jTfHBVr1aLA7SvJAAS9PyZhb5zouVv2yA,3905
-codeanalyzer/dataflow/pdg.py,sha256=vVrdUrdKB-3Czf9N0wuuA1x_Bfj1KnyEvXhW6UefGcA,3488
+codeanalyzer/dataflow/identity.py,sha256=WAIal6XchmQqdnXbvbEgu8J6vJdXNRdie1KHz1vJBl8,3906
+codeanalyzer/dataflow/pdg.py,sha256=1Bm7AnoRqXBryZulII2idPw0feV8eZQ1VqqprQ8PW-g,3731
 codeanalyzer/dataflow/scalpel_oracle.py,sha256=FxRadKrTWar0VKHyQJM40n3cq25sld3Sj4lMdOm5NFk,11494
-codeanalyzer/dataflow/scc.py,sha256=AfnUCJ2-ZMkdoGL-ucUyb6903u26dfDkliF51KdP_3s,3501
+codeanalyzer/dataflow/scc.py,sha256=Doa_0-5f3agCu_5UmeEDlCUErg34TtniKIv8Uqd7Jiw,3493
 codeanalyzer/dataflow/sdg.py,sha256=sTUUlYMB9uTKg9Yxiw-ScTBXogaQKcrSP6vksKXG14M,17841
 codeanalyzer/dataflow/slicing.py,sha256=lWZ7jHhlR8m7rECWJQXvwfs5GNZeJY55Cud3Ji5UbNU,3654
 codeanalyzer/dataflow/summaries.py,sha256=DOgesiymL6WgePrtkQBiS_Rd7SuCr3McD4Eq05Msb50,8023
@@ -31,40 +29,43 @@ codeanalyzer/dataflow/scalpel/cfg/model.py,sha256=5t_3jQgYwbkSvUUCKkOjX0pBzVUyDC
 codeanalyzer/dataflow/scalpel/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/dataflow/scalpel/core/func_call_visitor.py,sha256=ps0snjTchBXilhor3ijrx3ZqUuhCZYT94b5s5lFC5Z8,7313
 codeanalyzer/dataflow/scalpel/core/vars_visitor.py,sha256=gE5fNyJS6jslD6vsMRbFLoy3n1xTwH-b54mBcNYO72M,5660
+codeanalyzer/entrypoints/__init__.py,sha256=VaMd4mSEPLuPlRxxAve_nTJ9ZH62stXZGTPNwU_BQ50,99
+codeanalyzer/entrypoints/detect.py,sha256=fsWRQz1njvB9d3LIJEHxsNFE1GrB7q52KCvozw_UIUQ,4594
+codeanalyzer/entrypoints/matching.py,sha256=vXrhCsPOeaYHp8tYyILk5kNh9_3rwV_1wi6Z47PqG80,6427
+codeanalyzer/entrypoints/pipeline.py,sha256=PDptL_o105BpofpnQHWZYOtFYVelqTB4zktp0PVPbEc,5540
+codeanalyzer/entrypoints/rules.py,sha256=aYwCiX-J3tvj8qJrrb-tph5zovin5wIdmzc49iR3h2U,5318
+codeanalyzer/entrypoints/rules.yml,sha256=rgDglVOcUNXnQ5FXLMfnJbfI7xHRiRmegTP5bmiemSQ,3112
 codeanalyzer/jedi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/jedi/jedi.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codeanalyzer/neo4j/__init__.py,sha256=8Ei6uThTOqmul6GhnKoGOjLXJZbyDwF5Jo-8I8NxnAk,1574
-codeanalyzer/neo4j/bolt.py,sha256=0JHv6bHp2bsKwpFPT7CDzjDaz2GvGyoEaIKVtk_ayuA,10133
+codeanalyzer/neo4j/bolt.py,sha256=qEBtQlBjaMPpLQPUCOAR9jEqLxpXYJG5mtxdYAhjtMI,10134
 codeanalyzer/neo4j/cypher.py,sha256=a7YSmxxDbPcYc5gI4TW9sM6_WOE3RgLXTGBR9K8W8kw,5321
 codeanalyzer/neo4j/emit.py,sha256=QdrZWG3_IQHMcKCX4bFINpXvqZU2Qfsi9beIJovC2p4,3493
-codeanalyzer/neo4j/project.py,sha256=HbrehiVmVxLtoDCZkUVFpCOEWQuZR1ezr3mrp1EFnyo,24332
+codeanalyzer/neo4j/project.py,sha256=LFj8O_2DYA_dvMTbSYK_PYxmnP2UJ4h_3J8rCIoK1w8,25927
 codeanalyzer/neo4j/rows.py,sha256=med0XFa63PPUVUhJMq1TtVcJxgaVW39sgxBRZJDIJ_w,7811
-codeanalyzer/neo4j/schema.py,sha256=SyjaME5z9vgBC70Aswksct8Z0Tiau1PNvbHoeT3JLxE,10582
-codeanalyzer/options/__init__.py,sha256=Ki4qhHFqpyuUWVsntO-NYJMVWrkeFOzPW4nQ7oxiUVI,155
-codeanalyzer/options/options.py,sha256=RLJ298wSnK0FdaN3xJ5Ha7Lj62jaV9UDlhhtb5vh4Ro,2162
-codeanalyzer/schema/__init__.py,sha256=5bdJFV8icBDlTVHEoPumCFHBcq7O98-YNvuKs0qsqEs,2420
+codeanalyzer/neo4j/schema.py,sha256=kx134hxG_Uv6b5PkHFfkX7L1STpxSaW4pGTDe_Wruf0,10768
+codeanalyzer/options/__init__.py,sha256=6NewN0a-1HAEgKcxQjYyVn2WEDLrhax8h3WLgZddeqI,94
+codeanalyzer/options/options.py,sha256=5gmKNxb51vWmIknE4e8kyT9nJRchL0VYspZxe_PAsws,1389
+codeanalyzer/schema/__init__.py,sha256=hIyz02abUJNPW8yUgguaeKflZjTmOZWbDiKICNBD7yk,4141
 codeanalyzer/schema/assign_ids.py,sha256=pQHluLaO5a6hFREp3vjVRsUeAfTYSJ95RXS9TZvnoys,1590
 codeanalyzer/schema/call_graph_ids.py,sha256=mWAhJDBsW8i-siJiINOHCXEm4qM6F_5se9-HuHWIFqU,568
 codeanalyzer/schema/ids.py,sha256=G5NGPjJ3UdJ1k0opy2MrvgWRWNBZgKU1PwY1MR6hDT4,829
-codeanalyzer/schema/l1_body.py,sha256=9dRyrhHU277MVWAEjumvATbIai2YkuRE8kXyjHD-evo,1365
-codeanalyzer/schema/l2_callees.py,sha256=A4kX4Sm07O06-2CskqshP4QThdaTgCFHB6x3BarRvs8,1438
-codeanalyzer/schema/py_schema.py,sha256=KesvWIODJTl-kVMt1fYvw9yVQNWA0tMsLApqmb9ZkLk,17479
+codeanalyzer/schema/l1_body.py,sha256=5Su347kwAPNflJDf7SvBR3sNXx9PVdGEml2pOpQCwo0,1684
+codeanalyzer/schema/l2_callees.py,sha256=CTcBeGoO04DstDC6h-1sHMbbIrHDEOMxP01U9VLBcfc,2327
+codeanalyzer/schema/py_schema.py,sha256=VwwRqr_jFolkbRKi8ytiwUScKZmscJBZvh16Y2tDbII,18449
 codeanalyzer/semantic_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codeanalyzer/semantic_analysis/call_graph.py,sha256=PuR7dFTVrKanPatomYDJgkBaJq1Fd9920KspQpHQl1U,10957
-codeanalyzer/semantic_analysis/pycg/__init__.py,sha256=Lsgz25iFM_RGGu_i2psY-LN-KwvYIZQPnKgRPL1JsjU,928
-codeanalyzer/semantic_analysis/pycg/pycg_analysis.py,sha256=u22ZbicZ8_uTBNhbO4WepiO4ZcKB4OnarcOFh5xMido,48081
-codeanalyzer/semantic_analysis/pycg/pycg_exceptions.py,sha256=n4tRderrSYw9cUYgR2wsn64UqozY56nD1YfDNnaVcAk,968
-codeanalyzer/semantic_analysis/pycg/shard_planner.py,sha256=7wz821fv18vojzOHFYhXB6MLE1KdU4kFaldbd2kZHt0,15837
+codeanalyzer/semantic_analysis/call_graph.py,sha256=6YEB_wTn5-oQYLrbIhJYE0BsHl4fpWPoy5Hwd9mTnGc,11918
+codeanalyzer/semantic_analysis/defuse_linker.py,sha256=bSn1rCun28OQqSd2NOc9aVBSm47Gt9Iul4r_gwfqO1w,64930
 codeanalyzer/syntactic_analysis/__init__.py,sha256=EUQkJEh6wHjWx2qTTKbTbUgwSbfKeNieKHNy7RknVXA,476
 codeanalyzer/syntactic_analysis/exceptions.py,sha256=whs_n0vIu655Jkk1a7iOoXY6iIca4pZqJnU40V9Ejaw,537
 codeanalyzer/syntactic_analysis/import_resolver.py,sha256=Q8noZwSdDNt4P4NMqDTB9FaS-M0_d4ASK9GnJop9MDI,2751
-codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=US09mQgyaCbaF72YOtZF5NkJv1UM881c0dT9DSBpqXY,43398
+codeanalyzer/syntactic_analysis/symbol_table_builder.py,sha256=2bp9S5Z9Atx0Ovd70nMzAbutoNx_FD0VYBY397GAAVo,47343
 codeanalyzer/utils/__init__.py,sha256=hC6VWdR5rerSqBxzu9KQHTASWqwrrYJv-CMDwrTlzkc,137
 codeanalyzer/utils/logging.py,sha256=Fw0tattPAOMs3o0JMjjXhRVLIF64f-SCcygUXF9jqeg,904
 codeanalyzer/utils/progress_bar.py,sha256=C9JtzVdd10lIxTv-KA6PebqjKWueC_vMGwVzAtHuHIw,2818
-codeanalyzer_python-1.1.0.dist-info/METADATA,sha256=vZi9sYUtyn9x9IFsoUYsxSxm6bTmDOlA3eBwTR3VCrw,46835
-codeanalyzer_python-1.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-codeanalyzer_python-1.1.0.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
-codeanalyzer_python-1.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-codeanalyzer_python-1.1.0.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
-codeanalyzer_python-1.1.0.dist-info/RECORD,,
+codeanalyzer_python-1.2.0.dist-info/METADATA,sha256=Un9ZuyLWDpzfB_CNuAXiXGvM8eN0HQmr_0r2jGsBqqA,36319
+codeanalyzer_python-1.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codeanalyzer_python-1.2.0.dist-info/entry_points.txt,sha256=v4Vux0Nnx7sOntVk_CH7W9RX6SkIkvR1FQYq73oVlCQ,105
+codeanalyzer_python-1.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+codeanalyzer_python-1.2.0.dist-info/licenses/NOTICE,sha256=MdVkNYqHJ20on2FmWvgD4WpMsX5mir33xdyPvTXd0A0,1223
+codeanalyzer_python-1.2.0.dist-info/RECORD,,

{codeanalyzer_python-1.1.0.dist-info → codeanalyzer_python-1.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any

codeanalyzer/config/__init__.py

@@ -1,3 +0,0 @@
-from .config import OutputFormat
-
-__all__ = ["OutputFormat"]

codeanalyzer/config/config.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class OutputFormat(str, Enum):
-    """String-based enum for output formats to support typer case-insensitive options."""
-
-    JSON = "json"
-    MSGPACK = "msgpack"

codeanalyzer/semantic_analysis/pycg/__init__.py

@@ -1,20 +0,0 @@
-################################################################################
-# Copyright IBM Corporation 2025
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-################################################################################
-
-from codeanalyzer.semantic_analysis.pycg.pycg_analysis import PyCG
-from codeanalyzer.semantic_analysis.pycg.pycg_exceptions import PyCGExceptions
-
-__all__ = ["PyCG", "PyCGExceptions"]