@descryy/adapter-python 0.1.0

package/dist/module.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Python module paths and import resolution — the whole of R1.
+ *
+ * ## Where the last adapter lost three quarters of its graph
+ *
+ * DEC-059: the TypeScript adapter ignored the repository's own path
+ * configuration, so every aliased import failed and every cross-directory edge
+ * with it. Python's equivalents are `src/` layouts, `PYTHONPATH`, namespace
+ * packages and `pyproject.toml`'s package table — **the same defect in a
+ * different spelling** — so the layout is read from the repository here rather
+ * than assumed, and what could not be read is disclosed.
+ *
+ * ## The two hard cases, both in the corpus
+ *
+ * `from . import validate_order` — level 1, **no module name**. The dots are the
+ * whole address, and they are not recoverable from the specifier text: this is
+ * why the Python side reports `ImportFrom.level` rather than a string. It
+ * resolves to the containing package's `__init__.py`, which is the re-export hop
+ * golden pattern 03 turns on.
+ *
+ * `from .money import format_money` — level 1 with a module. Resolves to a
+ * sibling file, and the imported name is a *symbol* in it rather than a module.
+ * Deciding which of the two a name is cannot be done from the import alone —
+ * `from .pkg import mod` and `from .mod import fn` are identical in shape — so
+ * both candidates are returned and the caller picks by what exists.
+ */
+/** `src/order_service.py` -> `["src", "order_service"]`; `src/__init__.py` -> `["src"]`. */
+export declare function modulePathOf(repoRelativeFile: string): readonly string[];
+/**
+ * The display name of a module node.
+ *
+ * A package takes its directory's name — the corpus binds the `barrel` role to
+ * the symbol `src` at `src/__init__.py`, so `__init__` would fail to bind and
+ * the failure would read as a missing node rather than as a naming choice.
+ */
+export declare function moduleNameOf(repoRelativeFile: string): string;
+/**
+ * The project's distribution name, read rather than guessed.
+ *
+ * `pyproject.toml` first, then `setup.cfg`. Parsed with a narrow regex on
+ * purpose: a TOML dependency would buy correctness on a field nothing else in
+ * this adapter reads, and the fallback is disclosed through
+ * `capabilities().nodeIdentityFallback` either way.
+ */
+export declare function projectName(absoluteRoot: string): {
+    name: string;
+    evidence: string;
+};
+export interface ImportRecord {
+    readonly kind: string;
+    readonly level: number;
+    readonly module: string | null;
+    readonly name: string | null;
+    readonly local: string;
+    readonly line: number;
+}
+/** What an import might refer to: a module file, or a symbol inside one. */
+export interface ImportTarget {
+    /** Repo-relative file the specifier reaches, or undefined if nothing does. */
+    readonly file: string | undefined;
+    /** The symbol name inside that file, when the import names one. */
+    readonly symbol: string | undefined;
+    /** Set when the specifier names a package whose `__init__.py` re-exports. */
+    readonly viaPackageInit: boolean;
+}
+export interface ResolveOptions {
+    /** Repo-relative files this run analysed. Nothing outside it can be a target. */
+    readonly known: ReadonlySet<string>;
+    /**
+     * Directories that are import roots, repo-relative, longest first.
+     *
+     * A `src/` layout means `from myapp.models import X` resolves under `src/`,
+     * not under the repository root. Discovered rather than assumed — see
+     * `importRoots`.
+     */
+    readonly roots: readonly string[];
+}
+/**
+ * Resolve one import to a file, and to a symbol inside it when it names one.
+ *
+ * Returns `file: undefined` for anything outside the analysed set — the standard
+ * library, an installed package, a namespace package this run did not read.
+ * That is a scope boundary rather than a failure, and DEC-050 keeps the two
+ * apart in the ledger.
+ */
+export declare function resolveImport(record: ImportRecord, fromFile: string, options: ResolveOptions): ImportTarget;
+/**
+ * Directories an absolute import can be resolved against.
+ *
+ * This is the DEC-059 surface for Python, and it is *derived from the files that
+ * exist* rather than from a configuration file that may not. A directory is an
+ * import root when it directly contains a package — a subdirectory with an
+ * `__init__.py` — or a top-level module. `src/` layouts fall out of that without
+ * being special-cased, and so does a repository with no layout at all.
+ *
+ * Longest first, so a `src/` layout wins over the root when both could match.
+ */
+export declare function importRoots(files: readonly string[]): readonly string[];
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAKH,4FAA4F;AAC5F,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAQxE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAwBpF;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAeD,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,cAAc,GACtB,YAAY,CA0Dd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAwCvE"}

package/dist/module.js

@@ -0,0 +1,211 @@
+/**
+ * Python module paths and import resolution — the whole of R1.
+ *
+ * ## Where the last adapter lost three quarters of its graph
+ *
+ * DEC-059: the TypeScript adapter ignored the repository's own path
+ * configuration, so every aliased import failed and every cross-directory edge
+ * with it. Python's equivalents are `src/` layouts, `PYTHONPATH`, namespace
+ * packages and `pyproject.toml`'s package table — **the same defect in a
+ * different spelling** — so the layout is read from the repository here rather
+ * than assumed, and what could not be read is disclosed.
+ *
+ * ## The two hard cases, both in the corpus
+ *
+ * `from . import validate_order` — level 1, **no module name**. The dots are the
+ * whole address, and they are not recoverable from the specifier text: this is
+ * why the Python side reports `ImportFrom.level` rather than a string. It
+ * resolves to the containing package's `__init__.py`, which is the re-export hop
+ * golden pattern 03 turns on.
+ *
+ * `from .money import format_money` — level 1 with a module. Resolves to a
+ * sibling file, and the imported name is a *symbol* in it rather than a module.
+ * Deciding which of the two a name is cannot be done from the import alone —
+ * `from .pkg import mod` and `from .mod import fn` are identical in shape — so
+ * both candidates are returned and the caller picks by what exists.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** `src/order_service.py` -> `["src", "order_service"]`; `src/__init__.py` -> `["src"]`. */
+export function modulePathOf(repoRelativeFile) {
+    const withoutExtension = repoRelativeFile.replace(/\.pyi?$/, "");
+    const parts = withoutExtension.split("/").filter((p) => p !== "" && p !== ".");
+    // A package *is* its directory. `src/__init__.py` and the directory `src` are
+    // one module, and emitting two nodes for them would split every import into
+    // the package across two targets.
+    if (parts[parts.length - 1] === "__init__")
+        parts.pop();
+    return parts;
+}
+/**
+ * The display name of a module node.
+ *
+ * A package takes its directory's name — the corpus binds the `barrel` role to
+ * the symbol `src` at `src/__init__.py`, so `__init__` would fail to bind and
+ * the failure would read as a missing node rather than as a naming choice.
+ */
+export function moduleNameOf(repoRelativeFile) {
+    const path = modulePathOf(repoRelativeFile);
+    return path[path.length - 1] ?? "";
+}
+/**
+ * The project's distribution name, read rather than guessed.
+ *
+ * `pyproject.toml` first, then `setup.cfg`. Parsed with a narrow regex on
+ * purpose: a TOML dependency would buy correctness on a field nothing else in
+ * this adapter reads, and the fallback is disclosed through
+ * `capabilities().nodeIdentityFallback` either way.
+ */
+export function projectName(absoluteRoot) {
+    const pyproject = join(absoluteRoot, "pyproject.toml");
+    if (existsSync(pyproject)) {
+        const text = readFileSync(pyproject, "utf8");
+        const inProject = /\[project\][^[]*?^\s*name\s*=\s*["']([^"']+)["']/ms.exec(text);
+        const inPoetry = /\[tool\.poetry\][^[]*?^\s*name\s*=\s*["']([^"']+)["']/ms.exec(text);
+        const found = inProject?.[1] ?? inPoetry?.[1];
+        if (found !== undefined)
+            return { name: found, evidence: `pyproject.toml declares ${found}` };
+    }
+    const setupCfg = join(absoluteRoot, "setup.cfg");
+    if (existsSync(setupCfg)) {
+        const found = /^\s*name\s*=\s*(.+)$/m.exec(readFileSync(setupCfg, "utf8"));
+        if (found?.[1] !== undefined) {
+            return { name: found[1].trim(), evidence: `setup.cfg declares ${found[1].trim()}` };
+        }
+    }
+    return {
+        name: ".",
+        // The same shape of admission DEC-024 required of the TypeScript adapter:
+        // without a declared name, node identity rests on the module path alone.
+        evidence: "no pyproject.toml or setup.cfg declares a project name, so node identity falls back to " +
+            "the module path alone (DEC-024, DEC-054)",
+    };
+}
+/**
+ * Candidate files for a dotted module path, in Python's own order.
+ *
+ * A package's `__init__.py` is checked before a same-named module, because that
+ * is what the interpreter does and a graph that disagrees with the interpreter
+ * is wrong regardless of which is nicer.
+ */
+function candidates(parts) {
+    if (parts.length === 0)
+        return [];
+    const base = parts.join("/");
+    return [`${base}/__init__.py`, `${base}.py`, `${base}.pyi`];
+}
+/**
+ * Resolve one import to a file, and to a symbol inside it when it names one.
+ *
+ * Returns `file: undefined` for anything outside the analysed set — the standard
+ * library, an installed package, a namespace package this run did not read.
+ * That is a scope boundary rather than a failure, and DEC-050 keeps the two
+ * apart in the ledger.
+ */
+export function resolveImport(record, fromFile, options) {
+    const miss = { file: undefined, symbol: undefined, viaPackageInit: false };
+    if (record.level > 0) {
+        // Relative. `level` counts dots: 1 is the containing package, 2 its parent.
+        const here = modulePathOf(fromFile);
+        // A module inside a package is addressed relative to the package, so the
+        // module's own last segment is dropped first unless it *is* the package.
+        const isPackage = fromFile.endsWith("__init__.py");
+        const packagePath = isPackage ? [...here] : here.slice(0, -1);
+        const base = packagePath.slice(0, packagePath.length - (record.level - 1));
+        if (base.length === 0 && record.level > 1)
+            return miss;
+        const parts = record.module === null ? base : [...base, ...record.module.split(".")];
+        // `from . import x` and `from .mod import x`: x may be a submodule or a
+        // symbol. The submodule is tried first because it is unambiguous when it
+        // exists; a symbol needs the package's `__init__` to be the file.
+        if (record.name !== null) {
+            const asModule = candidates([...parts, record.name]).find((c) => options.known.has(c));
+            if (asModule !== undefined) {
+                return { file: asModule, symbol: undefined, viaPackageInit: false };
+            }
+        }
+        const asFile = candidates(parts).find((c) => options.known.has(c));
+        if (asFile === undefined)
+            return miss;
+        return {
+            file: asFile,
+            symbol: record.name ?? undefined,
+            viaPackageInit: asFile.endsWith("__init__.py"),
+        };
+    }
+    // Absolute: try each import root. `import a.b.c` binds `a`, but the file the
+    // specifier names is still `a/b/c`, so the whole dotted path is resolved.
+    const dotted = (record.module ?? "").split(".").filter((p) => p !== "");
+    if (dotted.length === 0)
+        return miss;
+    for (const root of options.roots) {
+        const prefix = root === "" ? [] : root.split("/");
+        if (record.name !== null) {
+            const asModule = candidates([...prefix, ...dotted, record.name]).find((c) => options.known.has(c));
+            if (asModule !== undefined) {
+                return { file: asModule, symbol: undefined, viaPackageInit: false };
+            }
+        }
+        const asFile = candidates([...prefix, ...dotted]).find((c) => options.known.has(c));
+        if (asFile !== undefined) {
+            return {
+                file: asFile,
+                symbol: record.name ?? undefined,
+                viaPackageInit: asFile.endsWith("__init__.py"),
+            };
+        }
+    }
+    return miss;
+}
+/**
+ * Directories an absolute import can be resolved against.
+ *
+ * This is the DEC-059 surface for Python, and it is *derived from the files that
+ * exist* rather than from a configuration file that may not. A directory is an
+ * import root when it directly contains a package — a subdirectory with an
+ * `__init__.py` — or a top-level module. `src/` layouts fall out of that without
+ * being special-cased, and so does a repository with no layout at all.
+ *
+ * Longest first, so a `src/` layout wins over the root when both could match.
+ */
+export function importRoots(files) {
+    // **A Set, because `files.includes` here was quadratic in the repository.**
+    //
+    // This ran a linear scan of every file in the run, inside a loop over every
+    // file, inside a walk up each path — hundreds of millions of string
+    // comparisons on a large repository, and worse the deeper its packages nest.
+    // Measured: posthog took 1,655 s against 112 s for home-assistant-core at the
+    // same file count (18,479 against 18,189). It reads as a repository-specific
+    // slowdown and is nothing of the kind — every repository paid it, in
+    // proportion to its size squared.
+    const present = new Set(files);
+    const roots = new Set();
+    // Directories walk out to the same root repeatedly; caching by directory turns
+    // the remaining per-file walk into one walk per distinct directory.
+    const rootOfDirectory = new Map();
+    for (const file of files) {
+        const parts = file.split("/");
+        if (parts.length === 1) {
+            roots.add("");
+            continue;
+        }
+        const directory = parts.slice(0, -1).join("/");
+        const cached = rootOfDirectory.get(directory);
+        if (cached !== undefined) {
+            roots.add(cached);
+            continue;
+        }
+        // The outermost directory that is NOT a package is the import root: walking
+        // out of `src/myapp/models.py` stops at `src`, because `src` has no
+        // `__init__.py` while `src/myapp` does.
+        let depth = parts.length - 1;
+        while (depth > 0 && present.has(`${parts.slice(0, depth).join("/")}/__init__.py`)) {
+            depth -= 1;
+        }
+        const root = parts.slice(0, depth).join("/");
+        rootOfDirectory.set(directory, root);
+        roots.add(root);
+    }
+    return [...roots].sort((a, b) => b.length - a.length || a.localeCompare(b));
+}
+//# sourceMappingURL=module.js.map

package/dist/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"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"}

package/dist/orm.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The ORM framework extractor for Python — SQLAlchemy and Django.
+ *
+ * **A `MODEL` is a framework claim, and this file is where the claim is earned.**
+ * Golden pattern 07 states the constraint that produced it: in the conformance
+ * corpus `Order` and `CreateOrderRequest` are structurally identical, so any
+ * classification a *language* adapter made between them would be a name
+ * heuristic — the one thing pattern 12 exists to punish. The evidence that
+ * separates them is a persistence mapping: a declarative base, a table binding,
+ * a column declaration. All three are written in the source, and this file reads
+ * them rather than inferring them.
+ *
+ * Nothing here is a name rule. `isTestSuiteClass` in `extract.ts` deliberately
+ * keeps one — a base whose name ends in `TestCase` — because the cost of being
+ * wrong is a test attributed to the wrong suite. The cost of being wrong here is
+ * a `MODEL` node that no database backs, which corrupts every data-propagation
+ * traversal above it, so provenance or a chain to provenance is the only
+ * admission. A class named `Model` proves nothing.
+ *
+ * The split with `extract.py` is the same one the rest of this adapter uses: the
+ * Python side records syntactic form and names no framework, and every decision
+ * about what a form *means* is taken here.
+ */
+/** One assignment in a class body, as `extract.py` recorded it. */
+export interface PyAttribute {
+    readonly name: string;
+    readonly annotation: string | null;
+    /** The callee as written — `Column`, `mapped_column`, `models.CharField`. */
+    readonly callee: string | null;
+    readonly args: readonly string[];
+    /** Keyword arguments whose value is a written constant. */
+    readonly keywords: Readonly<Record<string, unknown>>;
+    /** Keyword arguments that were written with a value this reader cannot state. */
+    readonly opaqueKeywords: readonly string[];
+    readonly literal: unknown;
+    readonly hasLiteral: boolean;
+    readonly line: number;
+}
+export type OrmFramework = "sqlalchemy" | "django";
+export interface OrmField {
+    readonly name: string;
+    readonly nullable: boolean;
+    /** Where the answer came from, so a default can be told from a declaration. */
+    readonly nullableFrom: "declared" | "annotation" | "framework-default";
+}
+export interface OrmShape {
+    readonly framework: OrmFramework;
+    /** The mapped table, where the source names one. */
+    readonly table: string | null;
+    readonly fields: readonly OrmField[];
+    /**
+     * Fields whose nullability is written in a form this reader cannot evaluate.
+     *
+     * Listed rather than guessed, and listed rather than dropped. `nullable=FLAG`
+     * is a stated answer this reader failed to read, and letting the framework
+     * default stand in for it would report the opposite of the source as fact.
+     */
+    readonly undecided: readonly string[];
+}
+/**
+ * Modules whose names, if a base class came from one, make the framework certain.
+ *
+ * Provenance is written in the import statement and needs no resolution, which
+ * is why a model is recognisable at R0. Only the cross-file *chain* — a project's
+ * own `class BaseModel(Base)` — needs imports resolved.
+ */
+export declare const ORM_BASE_MODULES: Readonly<Record<OrmFramework, ReadonlySet<string>>>;
+/**
+ * Calls that *produce* a declarative base rather than being one.
+ *
+ * SQLAlchemy 1.x writes `Base = declarative_base()` at module level, so the base
+ * class of a model is a name bound to a call result and not a class declaration
+ * at all. Without this rule every 1.x model in existence is invisible.
+ */
+export declare const DECLARATIVE_BASE_FACTORIES: ReadonlySet<string>;
+/**
+ * Is this attribute a mapped column, and by which framework's rule?
+ *
+ * Django's rule is shape-based rather than a name list: every field class in
+ * `django.db.models` ends in `Field`, and new ones are added by Django and by
+ * every third-party app. A closed list would go stale on each release and would
+ * miss `JSONField`, `ArrayField` and every custom field a project writes. The
+ * receiver still has to be the imported `models` module, so this is not a name
+ * heuristic — the provenance is checked by the caller before this is consulted.
+ */
+export declare function isColumnCall(attribute: PyAttribute, framework: OrmFramework): boolean;
+/** A base class name that is the framework's own, rather than a project's. */
+export declare function isFrameworkBaseName(name: string, framework: OrmFramework): boolean;
+/**
+ * The mapped shape of a class already established to belong to `framework`.
+ *
+ * Returns `null` where the class declares no column at all. That guard is what
+ * keeps a declarative base out of the graph as a model of its own: `class
+ * Base(DeclarativeBase): pass` inherits the provenance and maps nothing, and a
+ * `MODEL` with no fields is a claim about a table that does not exist.
+ */
+export declare function ormShapeOf(input: {
+    readonly framework: OrmFramework;
+    readonly attributes: readonly PyAttribute[];
+    readonly meta: readonly PyAttribute[];
+}): OrmShape | null;
+//# sourceMappingURL=orm.d.ts.map

package/dist/orm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.d.ts","sourceRoot":"","sources":["../src/orm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrD,iFAAiF;IACjF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEnD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,EAAE,UAAU,GAAG,YAAY,GAAG,mBAAmB,CAAC;CACxE;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAQhF,CAAC;AAaF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,CAIzD,CAAC;AA2CH;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,GAAG,OAAO,CAMrF;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,GAAG,OAAO,CAElF;AA8DD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAChC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,WAAW,EAAE,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;CACvC,GAAG,QAAQ,GAAG,IAAI,CA0ClB"}

package/dist/orm.js

@@ -0,0 +1,221 @@
+/**
+ * The ORM framework extractor for Python — SQLAlchemy and Django.
+ *
+ * **A `MODEL` is a framework claim, and this file is where the claim is earned.**
+ * Golden pattern 07 states the constraint that produced it: in the conformance
+ * corpus `Order` and `CreateOrderRequest` are structurally identical, so any
+ * classification a *language* adapter made between them would be a name
+ * heuristic — the one thing pattern 12 exists to punish. The evidence that
+ * separates them is a persistence mapping: a declarative base, a table binding,
+ * a column declaration. All three are written in the source, and this file reads
+ * them rather than inferring them.
+ *
+ * Nothing here is a name rule. `isTestSuiteClass` in `extract.ts` deliberately
+ * keeps one — a base whose name ends in `TestCase` — because the cost of being
+ * wrong is a test attributed to the wrong suite. The cost of being wrong here is
+ * a `MODEL` node that no database backs, which corrupts every data-propagation
+ * traversal above it, so provenance or a chain to provenance is the only
+ * admission. A class named `Model` proves nothing.
+ *
+ * The split with `extract.py` is the same one the rest of this adapter uses: the
+ * Python side records syntactic form and names no framework, and every decision
+ * about what a form *means* is taken here.
+ */
+/**
+ * Modules whose names, if a base class came from one, make the framework certain.
+ *
+ * Provenance is written in the import statement and needs no resolution, which
+ * is why a model is recognisable at R0. Only the cross-file *chain* — a project's
+ * own `class BaseModel(Base)` — needs imports resolved.
+ */
+export const ORM_BASE_MODULES = {
+    sqlalchemy: new Set([
+        "sqlalchemy.orm",
+        "sqlalchemy.orm.decl_api",
+        "sqlalchemy.ext.declarative",
+        "sqlalchemy.ext.declarative.api",
+    ]),
+    django: new Set(["django.db", "django.db.models", "django.db.models.base"]),
+};
+/** The framework's own base class names. A project's own base reaches these by chain. */
+const ORM_BASE_NAMES = {
+    // `Base` is deliberately absent. It is what almost every SQLAlchemy project
+    // calls its declarative base, and admitting it would be a name rule wearing a
+    // framework's clothes — a project is free to call its base anything, and
+    // something else is free to be called `Base`. The 1.x shape is reached through
+    // `DECLARATIVE_BASE_FACTORIES` instead, which is provenance.
+    sqlalchemy: new Set(["DeclarativeBase"]),
+    django: new Set(["Model"]),
+};
+/**
+ * Calls that *produce* a declarative base rather than being one.
+ *
+ * SQLAlchemy 1.x writes `Base = declarative_base()` at module level, so the base
+ * class of a model is a name bound to a call result and not a class declaration
+ * at all. Without this rule every 1.x model in existence is invisible.
+ */
+export const DECLARATIVE_BASE_FACTORIES = new Set([
+    "declarative_base",
+    "as_declarative",
+    "registry",
+]);
+/** Column constructors, per framework. */
+const COLUMN_CALLS = {
+    sqlalchemy: new Set(["Column", "mapped_column", "deferred", "synonym_for"]),
+    /**
+     * Django's relational fields, which are the exception to the `…Field` shape
+     * below and were **not** guessed at — they were counted.
+     *
+     * Across django's own tree `ForeignKey` is the second most common field
+     * constructor in existence, 914 uses against `CharField`'s 1,226, and the
+     * shape rule alone missed every one of them because it is the one field class
+     * Django did not suffix. `GenericForeignKey` and `GenericRelation` came out of
+     * the same count at 59 and 46.
+     */
+    django: new Set([
+        "ForeignKey",
+        "OneToOneField",
+        "ManyToManyField",
+        "GenericForeignKey",
+        "GenericRelation",
+    ]),
+};
+/**
+ * Attribute names that are configuration rather than columns.
+ *
+ * `__tablename__` is the table binding and `__table_args__` its options; neither
+ * is a field, and reporting them as fields would put two members in every model
+ * that no query can select.
+ */
+const NOT_A_FIELD = new Set([
+    "__tablename__",
+    "__table_args__",
+    "__mapper_args__",
+    "__abstract__",
+    "objects",
+    "Meta",
+]);
+const leafOf = (dotted) => dotted === null ? "" : (dotted.split(".").pop() ?? "");
+/**
+ * Is this attribute a mapped column, and by which framework's rule?
+ *
+ * Django's rule is shape-based rather than a name list: every field class in
+ * `django.db.models` ends in `Field`, and new ones are added by Django and by
+ * every third-party app. A closed list would go stale on each release and would
+ * miss `JSONField`, `ArrayField` and every custom field a project writes. The
+ * receiver still has to be the imported `models` module, so this is not a name
+ * heuristic — the provenance is checked by the caller before this is consulted.
+ */
+export function isColumnCall(attribute, framework) {
+    if (attribute.callee === null)
+        return false;
+    const leaf = leafOf(attribute.callee);
+    if (COLUMN_CALLS[framework].has(leaf))
+        return true;
+    if (framework === "sqlalchemy")
+        return false;
+    return leaf.endsWith("Field") && leaf.length > "Field".length;
+}
+/** A base class name that is the framework's own, rather than a project's. */
+export function isFrameworkBaseName(name, framework) {
+    return ORM_BASE_NAMES[framework].has(leafOf(name));
+}
+/**
+ * Nullability for one mapped column.
+ *
+ * Order is the framework's own, not this reader's preference. An explicit
+ * keyword is the source's answer and wins outright. A primary key is not
+ * nullable — that is SQL, not a convention. SQLAlchemy 2.0 then derives
+ * nullability from the `Mapped[...]` annotation, and only when none of those
+ * spoke does the framework default apply.
+ */
+function nullabilityOf(attribute, framework) {
+    const keyword = framework === "django" ? "null" : "nullable";
+    if (attribute.opaqueKeywords.includes(keyword))
+        return { undecided: true };
+    const declared = attribute.keywords[keyword];
+    if (typeof declared === "boolean") {
+        return { name: attribute.name, nullable: declared, nullableFrom: "declared" };
+    }
+    if (attribute.keywords["primary_key"] === true) {
+        return { name: attribute.name, nullable: false, nullableFrom: "declared" };
+    }
+    if (framework === "django") {
+        // Django's documented default, and the only one it has: a field is NOT NULL
+        // unless the model says otherwise.
+        return { name: attribute.name, nullable: false, nullableFrom: "framework-default" };
+    }
+    // SQLAlchemy 2.0: `Mapped[str]` is NOT NULL, `Mapped[str | None]` is nullable.
+    // The annotation is the declaration in this style, so it ranks above the
+    // 1.x-era default rather than below it.
+    const annotation = attribute.annotation;
+    if (annotation !== null && /\bMapped\s*\[/.test(annotation)) {
+        const inner = annotation.slice(annotation.indexOf("[") + 1, annotation.lastIndexOf("]"));
+        const nullable = /\bOptional\s*\[/.test(inner) || /\bNone\b/.test(inner);
+        return { name: attribute.name, nullable, nullableFrom: "annotation" };
+    }
+    // SQLAlchemy 1.x: a column is nullable unless it says otherwise. The opposite
+    // of Django's default, which is why neither is written once for both.
+    return { name: attribute.name, nullable: true, nullableFrom: "framework-default" };
+}
+/** The table a model binds to, where the source names one. */
+function tableOf(attributes, meta, framework) {
+    const named = framework === "django" ? "db_table" : "__tablename__";
+    const source = framework === "django" ? meta : attributes;
+    for (const attribute of source) {
+        if (attribute.name === named && typeof attribute.literal === "string")
+            return attribute.literal;
+    }
+    return null;
+}
+/**
+ * The mapped shape of a class already established to belong to `framework`.
+ *
+ * Returns `null` where the class declares no column at all. That guard is what
+ * keeps a declarative base out of the graph as a model of its own: `class
+ * Base(DeclarativeBase): pass` inherits the provenance and maps nothing, and a
+ * `MODEL` with no fields is a claim about a table that does not exist.
+ */
+export function ormShapeOf(input) {
+    const fields = [];
+    const undecided = [];
+    for (const attribute of input.attributes) {
+        if (NOT_A_FIELD.has(attribute.name) || attribute.name.startsWith("__"))
+            continue;
+        if (!isColumnCall(attribute, input.framework))
+            continue;
+        const read = nullabilityOf(attribute, input.framework);
+        if ("undecided" in read)
+            undecided.push(attribute.name);
+        else
+            fields.push(read);
+    }
+    // **The column requirement is SQLAlchemy's alone, and the asymmetry is the
+    // frameworks', not this reader's.**
+    //
+    // SQLAlchemy's declarative base is a class the *project* writes — `class
+    // Base(DeclarativeBase): pass` — so it inherits the provenance that admits a
+    // model and maps nothing. Without this guard the base itself becomes a `MODEL`
+    // describing a table that does not exist.
+    //
+    // Django has no such class in the analysed set: `models.Model` is Django's own
+    // and is never a subclass of itself. Inheriting it IS the declaration, and
+    // `class Foo(models.Model): pass` is a complete model — Django gives it an
+    // implicit primary key. Requiring a column here cost 317 real models on
+    // django's own tree, which is how the asymmetry was found rather than reasoned
+    // about.
+    const table = tableOf(input.attributes, input.meta, input.framework);
+    if (input.framework === "sqlalchemy" &&
+        fields.length === 0 &&
+        undecided.length === 0 &&
+        table === null) {
+        return null;
+    }
+    return {
+        framework: input.framework,
+        table,
+        fields: [...fields].sort((a, b) => a.name.localeCompare(b.name)),
+        undecided: [...undecided].sort(),
+    };
+}
+//# sourceMappingURL=orm.js.map