@alloy-js/python 0.0.1

package/dist/src/components/VariableDeclaration.js

@@ -0,0 +1,131 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { Declaration as CoreDeclaration, Name, OutputSymbolFlags, Show, createSymbolSlot, effect, emitSymbol, memo, useMemberScope, useScope } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { Atom } from "./Atom.js";
+import { SimpleCommentBlock } from "./index.js";
+/**
+ * A variable declaration component for Python.
+ *
+ * @example
+ * ```tsx
+ * <VariableDeclaration
+ *   name="myVar"
+ *   type="int"
+ *   initializer={42}  // Initial value
+ * />
+ * <VariableDeclaration
+ *   name="myOtherVar"
+ *   type="str"
+ *   omitNone={true}
+ * />
+ * <VariableDeclaration
+ *   name="myCallStmtVar"
+ *   callStatementVar={true}
+ *   initializer={12}
+ * />
+ * VariableDeclaration
+ *   name=""
+ *   callStatementVar={true}
+ *   initializer={12}
+ * />
+ * ```
+ * renders to
+ * ```py
+ * myVar: int = 42
+ * myOtherVar: str
+ * myCallStmtVar=12
+ * 12
+ * ```
+ */
+export function VariableDeclaration(props) {
+  const instanceVariable = props.instanceVariable ?? false;
+  const TypeSymbolSlot = createSymbolSlot();
+  const ValueTypeSymbolSlot = createSymbolSlot();
+  const memberScope = useMemberScope();
+  let scope = undefined;
+  // Only consider the member scope if this is an instance variable
+  if (memberScope !== undefined && instanceVariable) {
+    scope = memberScope.instanceMembers;
+  } else {
+    scope = useScope();
+  }
+  const sym = createPythonSymbol(props.name, {
+    scope: scope,
+    refkeys: props.refkey
+  }, "variable", true);
+  emitSymbol(sym);
+  // Handle optional type annotation
+  const type = memo(() => {
+    if (!props.type || props.callStatementVar) return undefined;
+    return [": ", _$createComponent(TypeSymbolSlot, {
+      get children() {
+        return props.type;
+      }
+    })];
+  });
+  effect(() => {
+    if (TypeSymbolSlot.ref.value) {
+      const takenSymbols = TypeSymbolSlot.ref.value;
+      for (const symbol of takenSymbols) {
+        // If the symbol is a type, instantiate it
+        symbol.instantiateTo(sym);
+      }
+    } else if (ValueTypeSymbolSlot.ref.value) {
+      const takenSymbols = ValueTypeSymbolSlot.ref.value;
+      for (const symbol of takenSymbols) {
+        // ignore non-transient symbols (likely not the result of an
+        // expression).
+        if (symbol.flags & OutputSymbolFlags.Transient) {
+          symbol.moveTo(sym);
+        }
+      }
+    }
+  });
+
+  // If we receive a symbol, resolve it to a name
+  const value = typeof props.initializer === "object" ? memo(() => props.initializer) : props.initializer;
+  const assignmentOperator = props.callStatementVar ? "=" : " = ";
+  const getRightSide = () => {
+    // Early return for omitNone case
+    if (props.omitNone && props.initializer === undefined) {
+      return [false, ""];
+    }
+
+    // Handle null/undefined values
+    if (value === null || value === undefined) {
+      return [true, ["None"]];
+    }
+    let renderRightSideOperator = true;
+    // Call statement with no name
+    if (props.callStatementVar && (props.name === undefined || props.name === "")) {
+      renderRightSideOperator = false;
+    }
+
+    // Standard assignment
+    return [renderRightSideOperator, _$createComponent(ValueTypeSymbolSlot, {
+      get children() {
+        return _$createComponent(Atom, {
+          jsValue: value
+        });
+      }
+    })];
+  };
+  const [renderRightSideOperator, rightSide] = getRightSide();
+  return [_$createComponent(Show, {
+    get when() {
+      return Boolean(props.doc);
+    },
+    get children() {
+      return [_$createComponent(SimpleCommentBlock, {
+        get children() {
+          return props.doc;
+        }
+      }), _$createIntrinsic("hbr", {})];
+    }
+  }), _$createComponent(CoreDeclaration, {
+    symbol: sym,
+    get children() {
+      return [_$memo(() => _$createComponent(Name, {})), type, renderRightSideOperator && assignmentOperator, rightSide];
+    }
+  })];
+}

package/dist/src/components/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./Atom.js";
+export * from "./CallSignature.js";
+export * from "./ClassDeclaration.js";
+export * from "./ClassInstantiation.js";
+export * from "./Declaration.js";
+export * from "./EnumDeclaration.js";
+export * from "./EnumMember.js";
+export * from "./FunctionCallExpression.js";
+export * from "./FunctionDeclaration.js";
+export * from "./ImportStatement.js";
+export * from "./MemberExpression.js";
+export * from "./NoNamePolicy.js";
+export * from "./PyDoc.js";
+export * from "./PythonBlock.js";
+export * from "./Reference.js";
+export * from "./SourceFile.js";
+export * from "./StatementList.js";
+export * from "./VariableDeclaration.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC"}

package/dist/src/components/index.js

@@ -0,0 +1,18 @@
+export * from "./Atom.js";
+export * from "./CallSignature.js";
+export * from "./ClassDeclaration.js";
+export * from "./ClassInstantiation.js";
+export * from "./Declaration.js";
+export * from "./EnumDeclaration.js";
+export * from "./EnumMember.js";
+export * from "./FunctionCallExpression.js";
+export * from "./FunctionDeclaration.js";
+export * from "./ImportStatement.js";
+export * from "./MemberExpression.js";
+export * from "./NoNamePolicy.js";
+export * from "./PyDoc.js";
+export * from "./PythonBlock.js";
+export * from "./Reference.js";
+export * from "./SourceFile.js";
+export * from "./StatementList.js";
+export * from "./VariableDeclaration.js";

package/dist/src/create-module.d.ts

@@ -0,0 +1,16 @@
+import { type Refkey, SymbolCreator } from "@alloy-js/core";
+export interface ModuleDescriptor {
+    [path: string]: string[];
+}
+export interface CreateModuleProps<T extends ModuleDescriptor> {
+    name: string;
+    descriptor: T;
+}
+export type NamedMap<TDescriptor extends readonly string[]> = {
+    [S in TDescriptor[number]]: Refkey;
+};
+export type ModuleRefkeys<PD extends Record<string, string[]>> = {
+    [P in keyof PD]: NamedMap<PD[P]>;
+};
+export declare function createModule<const T extends ModuleDescriptor>(props: CreateModuleProps<T>): ModuleRefkeys<T> & SymbolCreator;
+//# sourceMappingURL=create-module.d.ts.map

package/dist/src/create-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-module.d.ts","sourceRoot":"","sources":["../../src/create-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,MAAM,EAEX,aAAa,EACd,MAAM,gBAAgB,CAAC;AAIxB,MAAM,WAAW,gBAAgB;IAC/B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,gBAAgB;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,CAAC,CAAC;CACf;AAED,MAAM,MAAM,QAAQ,CAAC,WAAW,SAAS,SAAS,MAAM,EAAE,IAAI;KAC3D,CAAC,IAAI,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM;CACnC,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI;KAC9D,CAAC,IAAI,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AA2DF,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,gBAAgB,EAC3D,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC1B,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAelC"}

package/dist/src/create-module.js

@@ -0,0 +1,64 @@
+import { getSymbolCreatorSymbol, refkey } from "@alloy-js/core";
+import { createPythonSymbol } from "./symbol-creation.js";
+import { PythonModuleScope } from "./symbols/index.js";
+function createSymbols(binder, props, refkeys) {
+  // Create a module scope for each path in the descriptor
+  for (const [path, symbols] of Object.entries(props.descriptor)) {
+    // If the path is ".", we use the module name directly
+    // Otherwise, we append the path to the module name
+    const fullModuleScopeName = props.name + (path === "." ? "" : `.${path}`);
+    const keys = refkeys[path];
+    const moduleScope = new PythonModuleScope(fullModuleScopeName, {
+      parent: undefined,
+      binder: binder
+    });
+
+    // Create a symbol for each exported name
+    for (const exportedName of symbols ?? []) {
+      const key = keys[exportedName];
+      const _ = createPythonSymbol(exportedName, {
+        binder: binder,
+        scope: moduleScope,
+        refkeys: key,
+        module: moduleScope.name
+      }, undefined, false);
+    }
+  }
+}
+
+// A module is a map of refkeys for each path in the descriptor.
+// Each path maps to a set of named refkeys for the exported symbols.
+// When one of the symbols is used, the relevant import will be added
+// to the source file, and the symbol will be available in the output.
+//
+// Most of the use cases will be for templates and not for use in JSX,
+// so the symbols will not be normally used directly in the code, but
+// there may be cases where you want to use them directly.
+//
+// Example:
+// ```ts
+// const requestsLib = createModule({
+//   name: "requests",
+//   descriptor: {
+//     ".": ["get", "post"],
+//   },
+// });
+// ```
+//
+// For this scenario, if requestsLib["."].get is used, it will add
+// the import `from requests import get` and would render the symbol
+// as `get` in the output.
+export function createModule(props) {
+  const refkeys = {
+    [getSymbolCreatorSymbol()](binder) {
+      createSymbols(binder, props, refkeys);
+    }
+  };
+  for (const [path, symbols] of Object.entries(props.descriptor)) {
+    const keys = refkeys[path] = {};
+    for (const named of symbols ?? []) {
+      keys[named] = refkey(props.descriptor, path, named);
+    }
+  }
+  return refkeys;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./builtins/python.js";
+export * from "./components/index.js";
+export * from "./create-module.js";
+export * from "./name-policy.js";
+export * from "./parameter-descriptor.js";
+export * from "./symbols/index.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,7 @@
+export * from "./builtins/python.js";
+export * from "./components/index.js";
+export * from "./create-module.js";
+export * from "./name-policy.js";
+export * from "./parameter-descriptor.js";
+export * from "./symbols/index.js";
+export * from "./utils.js";

package/dist/src/name-policy.d.ts

@@ -0,0 +1,5 @@
+import { NamePolicy } from "@alloy-js/core";
+export type PythonElements = "class" | "class-member" | "function" | "variable" | "object-member" | "constant" | "parameter" | "method" | "module" | "enum" | "enum-member";
+export declare function createPythonNamePolicy(): NamePolicy<PythonElements>;
+export declare function usePythonNamePolicy(): NamePolicy<PythonElements>;
+//# sourceMappingURL=name-policy.d.ts.map

package/dist/src/name-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name-policy.d.ts","sourceRoot":"","sources":["../../src/name-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,UAAU,EAAiB,MAAM,gBAAgB,CAAC;AAG7E,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,cAAc,GACd,UAAU,GACV,UAAU,GACV,eAAe,GACf,UAAU,GACV,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,aAAa,CAAC;AA2DlB,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,cAAc,CAAC,CAuBnE;AAED,wBAAgB,mBAAmB,IAAI,UAAU,CAAC,cAAc,CAAC,CAEhE"}

package/dist/src/name-policy.js

@@ -0,0 +1,47 @@
+import { createNamePolicy, useNamePolicy } from "@alloy-js/core";
+import { constantCase, pascalCase, snakeCase } from "change-case";
+// Enum members
+
+// Reserved words
+const GLOBAL_RESERVED_WORDS = new Set(["False", "None", "True", "and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return", "try", "while", "with", "and", "yield"]);
+
+/**
+ * Ensures a valid Python identifier for the given element kind.
+ * @param name - The name to validate.
+ * @param element - The Python element kind.
+ * @returns A Python-safe name.
+ */
+function ensureNonReservedName(name) {
+  const suffix = "_";
+
+  // Global reserved words always need handling
+  if (GLOBAL_RESERVED_WORDS.has(name)) {
+    return `${name}${suffix}`;
+  }
+  return name;
+}
+export function createPythonNamePolicy() {
+  return createNamePolicy((name, element) => {
+    let transformedName;
+    switch (element) {
+      case "class":
+      case "enum":
+        transformedName = pascalCase(name);
+        break;
+      case "constant":
+      case "enum-member":
+        transformedName = constantCase(name);
+        break;
+      case "module":
+        transformedName = snakeCase(name).toLowerCase();
+        break;
+      default:
+        transformedName = snakeCase(name);
+        break;
+    }
+    return ensureNonReservedName(transformedName);
+  });
+}
+export function usePythonNamePolicy() {
+  return useNamePolicy();
+}

package/dist/src/parameter-descriptor.d.ts

@@ -0,0 +1,31 @@
+import type { Children, Refkey } from "@alloy-js/core";
+/**
+ * Information for a Python function parameter.
+ */
+export interface ParameterDescriptor {
+    /**
+     * The name of the parameter.
+     */
+    readonly name: string;
+    /**
+     * The type of the parameter.
+     */
+    readonly type?: Children;
+    /**
+     * The refkey for this parameter.
+     */
+    readonly refkey?: Refkey | Refkey[];
+    /**
+     * Whether the parameter is optional.
+     */
+    readonly optional?: boolean;
+    /**
+     * Documentation for the parameter.
+     */
+    readonly doc?: Children;
+    /**
+     * The default value of the parameter.
+     */
+    readonly default?: Children;
+}
+//# sourceMappingURL=parameter-descriptor.d.ts.map

package/dist/src/parameter-descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-descriptor.d.ts","sourceRoot":"","sources":["../../src/parameter-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC;CAC7B"}

package/dist/src/parameter-descriptor.js

@@ -0,0 +1 @@
+export {};

package/dist/src/symbol-creation.d.ts

@@ -0,0 +1,4 @@
+import { PythonElements } from "./name-policy.js";
+import { CreatePythonSymbolOptions, PythonOutputSymbol } from "./symbols/index.js";
+export declare function createPythonSymbol(name: string, options: CreatePythonSymbolOptions, kind?: PythonElements, createRefkeyIfNeeded?: boolean): PythonOutputSymbol;
+//# sourceMappingURL=symbol-creation.d.ts.map

package/dist/src/symbol-creation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-creation.d.ts","sourceRoot":"","sources":["../../src/symbol-creation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAuB,MAAM,kBAAkB,CAAC;AACvE,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,yBAAyB,EAClC,IAAI,CAAC,EAAE,cAAc,EACrB,oBAAoB,UAAQ,GAC3B,kBAAkB,CAsBpB"}

package/dist/src/symbol-creation.js

@@ -0,0 +1,24 @@
+import { refkey, useContext } from "@alloy-js/core";
+import { PythonSourceFileContext } from "./components/SourceFile.js";
+import { usePythonNamePolicy } from "./name-policy.js";
+import { PythonOutputSymbol } from "./symbols/index.js";
+export function createPythonSymbol(name, options, kind, createRefkeyIfNeeded = false) {
+  let processedName = name;
+  const sfContext = useContext(PythonSourceFileContext);
+  // Only apply the name policy if a kind is provided and name policy context is available
+  if (kind) {
+    const namePolicy = usePythonNamePolicy();
+    if (namePolicy) {
+      processedName = namePolicy.getName(name, kind);
+    }
+  }
+  return new PythonOutputSymbol(processedName, {
+    binder: options.binder,
+    aliasTarget: options.aliasTarget,
+    scope: options.scope,
+    refkeys: options.refkeys ?? (createRefkeyIfNeeded ? refkey(processedName) : undefined),
+    flags: options.flags,
+    metadata: options.metadata,
+    module: sfContext?.module
+  });
+}

package/dist/src/symbols/custom-output-scope.d.ts

@@ -0,0 +1,10 @@
+import { OutputScope, OutputScopeOptions, SymbolTable } from "@alloy-js/core";
+export declare class CustomOutputScope extends OutputScope {
+    #private;
+    /**
+     * The symbols defined within this scope.
+     */
+    get symbols(): SymbolTable;
+    constructor(name: string, options?: OutputScopeOptions);
+}
+//# sourceMappingURL=custom-output-scope.d.ts.map

package/dist/src/symbols/custom-output-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-output-scope.d.ts","sourceRoot":"","sources":["../../../src/symbols/custom-output-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAI9E,qBAAa,iBAAkB,SAAQ,WAAW;;IAEhD;;OAEG;IACH,IAAI,OAAO,gBAEV;gBAEW,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB;CAqB3D"}

package/dist/src/symbols/custom-output-scope.js

@@ -0,0 +1,25 @@
+import { OutputScope, SymbolTable } from "@alloy-js/core";
+
+// This is named as CustomOutputScope and not PythonOutputScope to avoid confusion with the one defined in scopes.ts
+// We are creating a custom output scope so we can add out custom name conflict resolution logic.
+export class CustomOutputScope extends OutputScope {
+  #symbols;
+  /**
+   * The symbols defined within this scope.
+   */
+  get symbols() {
+    return this.#symbols;
+  }
+  constructor(name, options = {}) {
+    super(name, options);
+    this.#symbols = new SymbolTable(this, {
+      nameConflictResolver: (_, symbols) => {
+        for (let i = 1; i < symbols.length; i++) {
+          // Rename all but the first symbol to have a suffix of _2, _3, plus the scope name if available.
+          const symbol = symbols[i];
+          symbol.name = symbol.originalName + "_" + (i + 1) + "_" + (symbols[i].aliasTarget?.scope?.name ?? symbol.module ?? "");
+        }
+      }
+    });
+  }
+}

package/dist/src/symbols/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./custom-output-scope.js";
+export * from "./python-member-scope.js";
+export * from "./python-module-scope.js";
+export * from "./python-output-symbol.js";
+export * from "./reference.js";
+export * from "./scopes.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/symbols/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/symbols/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/src/symbols/index.js

@@ -0,0 +1,6 @@
+export * from "./custom-output-scope.js";
+export * from "./python-member-scope.js";
+export * from "./python-module-scope.js";
+export * from "./python-output-symbol.js";
+export * from "./reference.js";
+export * from "./scopes.js";

package/dist/src/symbols/python-member-scope.d.ts

@@ -0,0 +1,7 @@
+import { CustomOutputScope } from "./custom-output-scope.js";
+import { PythonOutputSymbol } from "./python-output-symbol.js";
+export declare class PythonMemberScope extends CustomOutputScope {
+    get kind(): "member";
+    get owner(): PythonOutputSymbol;
+}
+//# sourceMappingURL=python-member-scope.d.ts.map

package/dist/src/symbols/python-member-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-member-scope.d.ts","sourceRoot":"","sources":["../../../src/symbols/python-member-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,qBAAa,iBAAkB,SAAQ,iBAAiB;IACtD,IAAI,IAAI,IACC,QAAQ,CAChB;IAED,IAAI,KAAK,IACe,kBAAkB,CACzC;CACF"}

package/dist/src/symbols/python-member-scope.js

@@ -0,0 +1,9 @@
+import { CustomOutputScope } from "./custom-output-scope.js";
+export class PythonMemberScope extends CustomOutputScope {
+  get kind() {
+    return "member";
+  }
+  get owner() {
+    return super.owner;
+  }
+}

package/dist/src/symbols/python-module-scope.d.ts

@@ -0,0 +1,25 @@
+import { CustomOutputScope } from "./custom-output-scope.js";
+import { PythonOutputSymbol } from "./python-output-symbol.js";
+export declare class ImportedSymbol {
+    local: PythonOutputSymbol;
+    target: PythonOutputSymbol;
+    constructor(target: PythonOutputSymbol, local: PythonOutputSymbol);
+    static from(target: PythonOutputSymbol, local: PythonOutputSymbol): ImportedSymbol;
+}
+export interface ImportRecordProps {
+    symbols: Set<ImportedSymbol>;
+}
+export type ImportRecords = Map<PythonModuleScope, ImportRecordProps>;
+export declare const ImportRecords: {
+    new (): ImportRecords;
+    new (entries?: readonly (readonly [PythonModuleScope, ImportRecordProps])[] | null): ImportRecords;
+    prototype: Map<PythonModuleScope, ImportRecordProps>;
+};
+export declare class PythonModuleScope extends CustomOutputScope {
+    #private;
+    get kind(): "module";
+    get importedSymbols(): Map<PythonOutputSymbol, PythonOutputSymbol>;
+    get importedModules(): ImportRecords;
+    addImport(targetSymbol: PythonOutputSymbol, targetModule: PythonModuleScope): PythonOutputSymbol;
+}
+//# sourceMappingURL=python-module-scope.d.ts.map

package/dist/src/symbols/python-module-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-module-scope.d.ts","sourceRoot":"","sources":["../../../src/symbols/python-module-scope.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D,qBAAa,cAAc;IACzB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,kBAAkB,CAAC;gBAEf,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB;IAKjE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB;CAGlE;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;CAC9B;AAED,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;AAEtE,eAAO,MAAM,aAAa,EAAU;IAClC,QAAQ,aAAa,CAAC;IACtB,KACE,OAAO,CAAC,EACJ,SAAS,CAAC,SAAS,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,EAAE,GAC5D,IAAI,GACP,aAAa,CAAC;IACjB,SAAS,EAAE,GAAG,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;CACtD,CAAC;AAEF,qBAAa,iBAAkB,SAAQ,iBAAiB;;IACtD,IAAI,IAAI,IACC,QAAQ,CAChB;IAID,IAAI,eAAe,gDAElB;IAGD,IAAI,eAAe,kBAElB;IAED,SAAS,CAAC,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB;CAqC5E"}

package/dist/src/symbols/python-module-scope.js

@@ -0,0 +1,52 @@
+import { reactive, shallowReactive } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { CustomOutputScope } from "./custom-output-scope.js";
+export class ImportedSymbol {
+  constructor(target, local) {
+    this.target = target;
+    this.local = local;
+  }
+  static from(target, local) {
+    return new ImportedSymbol(target, local);
+  }
+}
+export const ImportRecords = Map;
+export class PythonModuleScope extends CustomOutputScope {
+  get kind() {
+    return "module";
+  }
+  #importedSymbols = shallowReactive(new Map());
+  get importedSymbols() {
+    return this.#importedSymbols;
+  }
+  #importedModules = reactive(new Map());
+  get importedModules() {
+    return this.#importedModules;
+  }
+  addImport(targetSymbol, targetModule) {
+    const existing = this.importedSymbols.get(targetSymbol);
+    if (existing) {
+      return existing;
+    }
+    if (targetModule.kind !== "module") {
+      throw new Error("Cannot import symbol that isn't in module scope");
+    }
+    if (!this.importedModules.has(targetModule)) {
+      this.importedModules.set(targetModule, {
+        symbols: new Set()
+      });
+    }
+    const localSymbol = createPythonSymbol(targetSymbol.name, {
+      binder: this.binder,
+      scope: this,
+      aliasTarget: targetSymbol
+    }, undefined, false);
+    targetSymbol.copyTo(localSymbol);
+    this.importedSymbols.set(targetSymbol, localSymbol);
+    this.importedModules.get(targetModule).symbols?.add({
+      local: localSymbol,
+      target: targetSymbol
+    });
+    return localSymbol;
+  }
+}

package/dist/src/symbols/python-output-symbol.d.ts

@@ -0,0 +1,19 @@
+import { OutputSymbol, OutputSymbolOptions } from "@alloy-js/core";
+import { PythonMemberScope } from "./python-member-scope.js";
+export interface CreatePythonSymbolOptions extends OutputSymbolOptions {
+    module?: string;
+}
+export interface CreatePythonSymbolFunctionOptions extends CreatePythonSymbolOptions {
+    name: string;
+}
+/**
+ * Represents an 'exported' symbol from a .py file. Class, enum, interface etc.
+ */
+export declare class PythonOutputSymbol extends OutputSymbol {
+    #private;
+    constructor(name: string, options: CreatePythonSymbolOptions);
+    get module(): string | undefined;
+    set module(value: string | undefined);
+    get instanceMemberScope(): PythonMemberScope | undefined;
+}
+//# sourceMappingURL=python-output-symbol.d.ts.map

package/dist/src/symbols/python-output-symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-output-symbol.d.ts","sourceRoot":"","sources":["../../../src/symbols/python-output-symbol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iCACf,SAAQ,yBAAyB;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;;gBACtC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB;IAQ5D,IAAI,MAAM,IAIQ,MAAM,GAAG,SAAS,CAFnC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAEnC;IAED,IAAI,mBAAmB,IACe,iBAAiB,GAAG,SAAS,CAClE;CACF"}

package/dist/src/symbols/python-output-symbol.js

@@ -0,0 +1,22 @@
+import { OutputSymbol } from "@alloy-js/core";
+/**
+ * Represents an 'exported' symbol from a .py file. Class, enum, interface etc.
+ */
+export class PythonOutputSymbol extends OutputSymbol {
+  constructor(name, options) {
+    super(name, options);
+    this.#module = options.module ?? undefined;
+  }
+
+  // The module in which the symbol is defined
+  #module;
+  get module() {
+    return this.#module;
+  }
+  set module(value) {
+    this.#module = value;
+  }
+  get instanceMemberScope() {
+    return super.instanceMemberScope;
+  }
+}

package/dist/src/symbols/reference.d.ts

@@ -0,0 +1,4 @@
+import { Refkey } from "@alloy-js/core";
+import { PythonOutputSymbol } from "./index.js";
+export declare function ref(refkey: Refkey): () => [string, PythonOutputSymbol | undefined];
+//# sourceMappingURL=reference.d.ts.map

package/dist/src/symbols/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/symbols/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAKP,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAIL,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,GAAG,CACjB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC,CA6DhD"}