codeanalyzer-python 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

codeanalyzer/schema/py_schema.py

@@ -176,6 +176,7 @@ class PyImport(BaseModel):
     module: str
     name: str
     alias: Optional[str] = None
+    resolved_module: Optional[str] = None
     start_line: int = -1
     end_line: int = -1
     start_column: int = -1
@@ -240,6 +241,19 @@ class PyCallableParameter(BaseModel):
     end_column: int = -1
 
 
+@builder
+@msgpk
+class PyCallArgument(BaseModel):
+    """One call-site argument: AST category + inferred type, kept separate.
+
+    The legacy ``PyCallsite.argument_types`` mixed these two vocabularies
+    in one list; this model is the disambiguated replacement (#86).
+    """
+
+    ast_kind: str
+    inferred_type: Optional[str] = None
+
+
 @builder
 @msgpk
 class PyCallsite(BaseModel):
@@ -249,6 +263,7 @@ class PyCallsite(BaseModel):
     receiver_expr: Optional[str] = None
     receiver_type: Optional[str] = None
     argument_types: List[str] = []
+    arguments: List[PyCallArgument] = []
     return_type: Optional[str] = None
     callee_signature: Optional[str] = None
     is_constructor_call: bool = False
@@ -295,6 +310,7 @@ class PyClassAttribute(BaseModel):
 
     name: str
     type: Optional[str] = None
+    initializer: Optional[str] = None
     comments: List[PyComment] = []
     start_line: int = -1
     end_line: int = -1
@@ -355,7 +371,7 @@ class PyCallEdge(BaseModel):
     target: str  # callee's PyCallable.signature
     type: Literal["CALL_DEP"] = "CALL_DEP"
     weight: int = 1
-    provenance: List[Literal["jedi", "codeql", "joern"]] = []
+    provenance: List[Literal["jedi", "pycg", "joern"]] = []
 
 
 @builder
@@ -369,6 +385,26 @@ class PyExternalSymbol(BaseModel):
     module: Optional[str] = None  # best-effort owning module, e.g. "requests"
 
 
+@builder
+@msgpk
+class PyRepositoryInfo(BaseModel):
+    """Where the analyzed source came from: git provenance captured at analysis time."""
+
+    uri: Optional[str] = None
+    revision: str
+    dirty: bool = False
+
+
+@builder
+@msgpk
+class PyAnalyzerInfo(BaseModel):
+    """Which analyzer produced this snapshot, and how it was configured."""
+
+    name: str
+    version: str
+    config: Dict[str, Any] = {}
+
+
 @builder
 @msgpk
 class PyApplication(BaseModel):
@@ -380,3 +416,5 @@ class PyApplication(BaseModel):
     # builtin members), keyed by signature. Populated by the analyzer so every
     # backend (JSON and Neo4j) shares one authoritative external-symbol set.
     external_symbols: Dict[str, PyExternalSymbol] = {}
+    analyzer: Optional[PyAnalyzerInfo] = None
+    repository: Optional[PyRepositoryInfo] = None

codeanalyzer/semantic_analysis/call_graph.py

@@ -173,7 +173,7 @@ def jedi_call_graph_edges(
 
     Edges are coalesced on ``(source, target)``: ``weight`` is the count of
     matching sites. Provenance is always ``["jedi"]``; combine with
-    CodeQL-derived edges via ``merge_edges``.
+    PyCG-derived edges via ``merge_edges``.
     """
     counts: Counter = Counter()
     for caller in iter_callables_in_symbol_table(symbol_table):
@@ -191,7 +191,7 @@ def jedi_call_graph_edges(
 def resolve_unresolved_constructors(symbol_table: Dict[str, PyModule]) -> int:
     """Fill in ``PyCallsite.callee_signature`` for unresolved constructor sites.
 
-    When both Jedi and CodeQL fail to resolve a constructor call (commonly
+    When Jedi fails to resolve a constructor call (commonly
     for classes nested inside functions or methods, where static-analysis
     points-to is weakest), Jedi still flags the site as
     ``is_constructor_call=True`` with ``method_name`` set to the class's
@@ -246,12 +246,33 @@ def resolve_unresolved_constructors(symbol_table: Dict[str, PyModule]) -> int:
     return resolved
 
 
+def filter_external_edges(
+    edges: List[PyCallEdge],
+    symbol_table: Dict[str, PyModule],
+) -> List[PyCallEdge]:
+    """Remove edges where both source and target are outside the app namespace.
+
+    Edges where an app callable calls a library function (or vice-versa) are
+    retained; only lib→lib edges are dropped.  The app symbol set is built by
+    walking every callable in the symbol table recursively (including nested
+    functions and closures via ``inner_callables``) plus every class, so
+    PyCG-discovered closure nodes are correctly recognised as app symbols.
+    """
+    app_symbols: set = {c.signature for c in iter_callables_in_symbol_table(symbol_table)}
+    app_symbols.update(cls.signature for cls in iter_classes_in_symbol_table(symbol_table))
+
+    return [
+        e for e in edges
+        if e.source in app_symbols or e.target in app_symbols
+    ]
+
+
 def merge_edges(*edge_lists: list) -> list:
     """Merge multiple ``List[PyCallEdge]`` into one.
 
     Edges with the same ``(source, target)`` are coalesced: weights sum,
     provenance is the sorted union. Useful for combining edges produced
-    by different backends (e.g. Jedi + CodeQL).
+    by different backends (e.g. Jedi + PyCG).
     """
     by_key: Dict[Tuple[str, str], PyCallEdge] = {}
     for edges in edge_lists:

codeanalyzer/semantic_analysis/pycg/__init__.py

@@ -0,0 +1,20 @@
+################################################################################
+# 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"]