fix(schema): pydantic v1 compatibility for the 3.10 dependency line

The release compat job (Python 3.10, where ray==2.0.0 pins pydantic v1)
caught two v2-only idioms that landed after v1.1.1 — the tag-gated job
is the first thing that exercises that half of the matrix:

- BodyNode.arguments forward-references PyCallArgument (#120); v1
  resolves string annotations only when told to, so the module now
  calls update_forward_refs on v1 (v2 rebuilds automatically and its
  shim rejects localns, hence the guard).
- merge_edges copied edges with model_copy(); routed through a new
  model_copy() compat helper alongside the existing model_dump_json
  one, and the CLI's raw artifacts.model_dump(mode="json") now goes
  through a model_dump() helper that maps mode=json onto a v1
  json-round-trip.

Verified on Python 3.10 + pydantic 1.10.26 locally: all 60 tests from
the failing families pass; the only local residue is ray 2.0.0's
x86_64 grpc wheel refusing Apple Silicon in subprocess tests, which
does not affect the ubuntu runners. Python 3.12 + pydantic v2: 291
passed solo (a concurrent-run '2 failed' reproduced as machine-load
flakiness, not code).

Author: rahlk

codeanalyzer/__main__.py

@@ -38,7 +38,7 @@ def _pin_hash_seed() -> None:
 
 from codeanalyzer.core import Codeanalyzer
 from codeanalyzer.utils import _set_log_level, logger
-from codeanalyzer.schema import model_dump_json, strip_internal_only
+from codeanalyzer.schema import model_dump, model_dump_json, strip_internal_only
 from codeanalyzer.options import AnalysisOptions, EmitTarget
 
 
@@ -368,7 +368,7 @@ def main(
             print(
                 json.dumps(
                     strip_internal_only(
-                        artifacts.model_dump(mode="json", exclude_none=True)
+                        model_dump(artifacts, mode="json", exclude_none=True)
                     )
                 )
             )
@@ -384,7 +384,7 @@ def _write_output(artifacts, output_dir: Path):
     # Strip internal-only fields here rather than with a field-level Pydantic
     # `exclude`: the analysis cache shares the serializer and must keep them.
     json_str = json.dumps(
-        strip_internal_only(artifacts.model_dump(mode="json", exclude_none=True))
+        strip_internal_only(model_dump(artifacts, mode="json", exclude_none=True))
     )
     with output_file.open("w") as f:
         f.write(json_str)

codeanalyzer/schema/__init__.py

@@ -104,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:

codeanalyzer/schema/py_schema.py

@@ -308,6 +308,13 @@ class PyCallArgument(BaseModel):
     inferred_type: Optional[str] = None
 
 
+# BodyNode.arguments forward-references PyCallArgument (defined later);
+# pydantic v1 resolves string annotations only when told to, while v2
+# rebuilds automatically (and its update_forward_refs shim rejects localns).
+if not hasattr(BodyNode, "model_rebuild"):  # pydantic v1
+    BodyNode.update_forward_refs(PyCallArgument=PyCallArgument)
+
+
 @builder
 class PyCallsite(BaseModel):
     """Represents a Python call site (function or method invocation) with contextual metadata."""

codeanalyzer/semantic_analysis/call_graph.py

@@ -29,6 +29,7 @@
 import networkx as nx
 
 from codeanalyzer.semantic_analysis.defuse_linker import _module_qual
+from codeanalyzer.schema import model_copy
 from codeanalyzer.schema.py_schema import (
     PyApplication,
     PyCallable,
@@ -295,5 +296,5 @@ def merge_edges(*edge_lists: list) -> list:
                 cur.weight += e.weight
                 cur.prov = sorted(set(cur.prov) | set(e.prov))
             else:
-                by_key[k] = e.model_copy()
+                by_key[k] = model_copy(e)
     return list(by_key.values())