@descryy/adapter-python 0.1.0 → 0.3.0

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@descryy/adapter-python",
-  "version": "0.1.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.3.0",
-    "@descryy/adapter-openapi": "0.1.0",
-    "@descryy/adapter-sql": "0.1.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(
                     {
@@ -1182,6 +1207,80 @@ def _classify_alias(candidate: dict, typing_names: set[str], bound: set[str]) ->
     return None
 
 
+def _alembic_revision(tree: ast.Module) -> dict | None:
+    """`attrs.migrationRevision` — the revision/down_revision half `_migration_ops`
+    does not read.
+
+    Alembic's generator writes exactly this pair at module scope in every
+    script it produces: `revision = "..."` and `down_revision = "..." | None`.
+    Gated on **both names being assigned at module level**, not just one —
+    a bare `revision = ...` is not rare on its own (a git SHA, an API version)
+    and is not enough by itself to claim this file is a migration; the pair is.
+
+    `down_revision` carries three shapes Alembic itself writes: a single
+    string (one parent), the literal `None` (a root migration — a real,
+    meaningful empty parent, not an unread one), or a tuple/list of strings
+    (a merge revision, several parents). Anything else written there — a
+    computed expression, a name — is reported as the string `"unknown"`
+    rather than guessed at: the same "a name-matched guess is a false claim"
+    rule `descry-core`'s own regex-based migration reader applies to this
+    exact line from the outside (`sources/migrations/dialects.ts`).
+    """
+
+    def string_of(node: ast.AST) -> str | None:
+        return node.value if isinstance(node, ast.Constant) and isinstance(node.value, str) else None
+
+    revision: str | None = None
+    has_down_revision = False
+    down_revision: str | list[str] | None = None
+
+    for node in tree.body:
+        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
+        if not isinstance(target, ast.Name):
+            continue
+
+        if target.id == "revision":
+            revision = string_of(value)
+            continue
+
+        if target.id == "down_revision":
+            has_down_revision = True
+            if isinstance(value, ast.Constant) and value.value is None:
+                down_revision = None
+            else:
+                single = string_of(value)
+                if single is not None:
+                    down_revision = single
+                elif isinstance(value, (ast.Tuple, ast.List)):
+                    ids = [string_of(elt) for elt in value.elts]
+                    down_revision = ids if len(ids) > 0 and all(i is not None for i in ids) else "unknown"
+                else:
+                    down_revision = "unknown"
+
+    if revision is None or not has_down_revision:
+        return None
+
+    return {"revision": revision, "downRevision": down_revision}
+
+
 def collect(path: str, source: str, deep_call_modules: frozenset[str] = frozenset()) -> dict:
     tree = ast.parse(source, filename=path)
     collector = Collector(path)
@@ -1235,12 +1334,14 @@ def collect(path: str, source: str, deep_call_modules: frozenset[str] = frozense
 
     env_reads, env_dynamic_reads = _env_reads(tree, collector.imports)
     migration_ops = _migration_ops(tree, collector.imports)
+    migration_revision = _alembic_revision(tree)
 
     return {
         "declarations": collector.declarations,
         "imports": collector.imports,
         "references": collector.references,
         "instantiations": collector.instantiations,
+        "localAnnotations": collector.local_annotations,
         "valueRefs": collector.value_refs,
         "aliases": aliases,
         "calls": collector.calls,
@@ -1250,6 +1351,7 @@ def collect(path: str, source: str, deep_call_modules: frozenset[str] = frozense
         "envReads": env_reads,
         "envDynamicReads": env_dynamic_reads,
         "migrationOps": migration_ops,
+        "migrationRevision": migration_revision,
     }