@descryy/adapter-python 0.2.0 → 0.3.0

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@descryy/adapter-python",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Python adapter. Parses with Python's own ast in one subprocess (DEC-062) \u2014 no grammar to keep in sync, and annotations arrive as source text.",
   "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/descryhq-wq/descry-adapters.git",
+    "directory": "packages/adapter-python"
+  },
+  "bugs": {
+    "url": "https://github.com/descryhq-wq/descry-adapters/issues"
+  },
+  "homepage": "https://github.com/descryhq-wq/descry-adapters#readme",
   "engines": {
     "node": ">=22.5"
   },
@@ -26,9 +35,9 @@
     "build:assets": "node -e \"require('fs').copyFileSync('src/extract.py','dist/extract.py')\""
   },
   "dependencies": {
-    "@descryy/adapter-common": "0.1.0",
-    "@descryy/ir": "0.4.0",
-    "@descryy/adapter-openapi": "0.2.0",
-    "@descryy/adapter-sql": "0.2.0"
+    "@descryy/adapter-common": "0.2.0",
+    "@descryy/ir": "0.5.0",
+    "@descryy/adapter-openapi": "0.3.0",
+    "@descryy/adapter-sql": "0.3.0"
   }
 }

package/src/extract.py

@@ -290,6 +290,17 @@ class Collector(ast.NodeVisitor):
         # Module-level `name = ClassName()`, which is the only inference this
         # file performs and the only one it can perform without a checker.
         self.instantiations: list[dict] = []
+        # A local variable's *own* type annotation — `org: Organization | None
+        # = await get_org_for_user(...)` — as opposed to `instantiations`
+        # above, which only sees a bare constructor call on the right-hand
+        # side. The ground truth this exists for is exactly this shape: a
+        # local carrying its own annotation, assigned from a call whose
+        # return type nothing here resolves. Kept as the raw annotation
+        # string (not a single type name) so the Node side can run its own
+        # `typeNamesIn` + "exactly one candidate" discipline against
+        # `Optional[X]` / `X | None` / `Union[X, Y]`, the same as it already
+        # does for a parameter's own annotation.
+        self.local_annotations: list[dict] = []
         # Module-level assignments that *might* be type aliases. Classified in
         # `collect()` rather than here, because rule 4 asks where a constructor
         # was imported from and the import table is only complete once the whole
@@ -682,6 +693,20 @@ class Collector(ast.NodeVisitor):
                     "line": node.lineno,
                 }
             )
+            # A local variable's own annotation, inside a function (or
+            # nested closure) body — `org: Organization | None = await
+            # get_org_for_user(...)`. Module-level annotated assignments are
+            # already covered by `alias_candidates`/`_alembic_revision`; this
+            # is specifically the local-scope case those do not read.
+            if self._scope:
+                self.local_annotations.append(
+                    {
+                        "local": node.target.id,
+                        "annotation": _annotation(node.annotation),
+                        "scope": list(self._scope),
+                        "line": node.lineno,
+                    }
+                )
             if not self._scope and node.value is not None:
                 self.alias_candidates.append(
                     {
@@ -1210,19 +1235,34 @@ def _alembic_revision(tree: ast.Module) -> dict | None:
     down_revision: str | list[str] | None = None
 
     for node in tree.body:
-        if not (isinstance(node, ast.Assign) and len(node.targets) == 1):
+        target: ast.AST | None
+        value: ast.AST | None
+        if isinstance(node, ast.Assign) and len(node.targets) == 1:
+            target = node.targets[0]
+            value = node.value
+        elif isinstance(node, ast.AnnAssign):
+            # `revision: str = "..."` — a type-annotated assignment. Alembic's
+            # newer templates and mypy-strict repos write the pair this way;
+            # it is semantically the same assignment, just with an annotation
+            # attached. `node.value` is `None` for a bare annotation with no
+            # value (`down_revision: str` alone) — that assigns nothing, so it
+            # must not be treated as `down_revision = None` (a root migration
+            # is a real, distinct fact). Skip the node entirely in that case.
+            if node.value is None:
+                continue
+            target = node.target
+            value = node.value
+        else:
             continue
-        target = node.targets[0]
         if not isinstance(target, ast.Name):
             continue
 
         if target.id == "revision":
-            revision = string_of(node.value)
+            revision = string_of(value)
             continue
 
         if target.id == "down_revision":
             has_down_revision = True
-            value = node.value
             if isinstance(value, ast.Constant) and value.value is None:
                 down_revision = None
             else:
@@ -1301,6 +1341,7 @@ def collect(path: str, source: str, deep_call_modules: frozenset[str] = frozense
         "imports": collector.imports,
         "references": collector.references,
         "instantiations": collector.instantiations,
+        "localAnnotations": collector.local_annotations,
         "valueRefs": collector.value_refs,
         "aliases": aliases,
         "calls": collector.calls,