@alloy-js/python 0.1.0-dev.4 → 0.1.0-dev.6

package/test/classdeclarations.test.tsx

@@ -34,8 +34,8 @@ describe("Python Class", () => {
   it("renders a class with base classes", () => {
     const result = toSourceText([
       <py.StatementList>
-        <py.ClassDeclaration name="Base1" />
-        <py.ClassDeclaration name="Base2" />
+        <py.ClassDeclaration name="Base1" refkey={refkey("Base1")} />
+        <py.ClassDeclaration name="Base2" refkey={refkey("Base2")} />
         <py.ClassDeclaration
           name="Baz"
           bases={[refkey("Base1"), refkey("Base2")]}
@@ -74,10 +74,14 @@ describe("Python Class", () => {
   it("renders classes across modules with inheritance", () => {
     const result = toSourceTextMultiple([
       <py.SourceFile path="mod1.py">
-        <py.ClassDeclaration name="A" />
+        <py.ClassDeclaration name="A" refkey={refkey("A")} />
       </py.SourceFile>,
       <py.SourceFile path="folder/mod2.py">
-        <py.ClassDeclaration name="B" bases={[refkey("A")]} />
+        <py.ClassDeclaration
+          name="B"
+          refkey={refkey("B")}
+          bases={[refkey("A")]}
+        />
       </py.SourceFile>,
       <py.SourceFile path="mod3.py">
         <py.ClassDeclaration name="C" bases={[refkey("B")]} />
@@ -113,7 +117,7 @@ describe("Python Class", () => {
   it("renders a class with class variables like foo: str, and also bar: A where A is another class", () => {
     const result = toSourceText([
       <py.StatementList>
-        <py.ClassDeclaration name="A" />
+        <py.ClassDeclaration name="A" refkey={refkey("A")} />
         <py.ClassDeclaration name="B">
           <py.StatementList>
             <py.VariableDeclaration name="bar" type={refkey("A")} omitNone />
@@ -136,18 +140,33 @@ describe("Python Class", () => {
   });
 
   it("renders a class with class variables like foo: str, and another identical class", () => {
+    const fooKey = refkey();
+    const barKey = refkey();
+
     const result = toSourceText([
       <py.StatementList>
         <py.ClassDeclaration name="A">
           <py.StatementList>
-            <py.VariableDeclaration name="foo" type="str" omitNone />
+            <py.VariableDeclaration
+              name="foo"
+              type="str"
+              refkey={fooKey}
+              omitNone
+            />
           </py.StatementList>
         </py.ClassDeclaration>
         <py.ClassDeclaration name="B">
           <py.StatementList>
-            <py.VariableDeclaration name="foo" type="str" omitNone />
+            <py.VariableDeclaration
+              name="foo"
+              type="str"
+              refkey={barKey}
+              omitNone
+            />
           </py.StatementList>
         </py.ClassDeclaration>
+        {fooKey}
+        {barKey}
       </py.StatementList>,
     ]);
     const expected = d`
@@ -157,7 +176,8 @@ describe("Python Class", () => {
       class B:
           foo: str
 
-
+      A.foo
+      B.foo
     `;
     expect(result).toRenderTo(expected);
   });
@@ -167,17 +187,29 @@ describe("Python Class - VariableDeclaration", () => {
   it("renders a class with class fields", () => {
     const result = toSourceText([
       <py.StatementList>
-        <py.ClassDeclaration name="Base"></py.ClassDeclaration>
-        <py.ClassDeclaration name="A">
+        <py.ClassDeclaration
+          refkey={refkey("Base")}
+          name="Base"
+        ></py.ClassDeclaration>
+        <py.ClassDeclaration refkey={refkey("A")} name="A">
           <py.StatementList>
-            <py.VariableDeclaration name="just_name" />
-            <py.VariableDeclaration name="name_and_type" type="number" />
+            <py.VariableDeclaration instanceVariable name="just_name" />
             <py.VariableDeclaration
+              instanceVariable
+              name="name_and_type"
+              type="number"
+            />
+            <py.VariableDeclaration
+              instanceVariable
               name="name_type_and_value"
               type="number"
               initializer={12}
             />
-            <py.VariableDeclaration name="class_based" type={refkey("Base")} />
+            <py.VariableDeclaration
+              instanceVariable
+              name="class_based"
+              type={refkey("Base")}
+            />
           </py.StatementList>
         </py.ClassDeclaration>
       </py.StatementList>,
@@ -210,12 +242,7 @@ describe("Python Class - VariableDeclaration", () => {
             name="one"
             refkey={v1Rk}
             type={classRk}
-            initializer={
-              <py.MemberExpression>
-                <py.MemberExpression.Part refkey={classRk} />
-                <py.MemberExpression.Part args />
-              </py.MemberExpression>
-            }
+            initializer={<py.ClassInstantiation target={classRk} />}
           />
           <>{memberRefkey(v1Rk, classMemberRk)}</>
           <>{memberRefkey(v1Rk, classMethodRk)}()</>
@@ -228,11 +255,11 @@ describe("Python Class - VariableDeclaration", () => {
               name="instanceProp"
               refkey={classMemberRk}
               initializer={42}
-              instanceVariable={true}
+              instanceVariable
             />
             <py.FunctionDeclaration
               name="instanceMethod"
-              instanceFunction={true}
+              instanceFunction
               refkey={classMethodRk}
               returnType="int"
             />
@@ -263,12 +290,16 @@ describe("Python Class - VariableDeclaration", () => {
 
 describe("Python Class - FunctionDeclaration", () => {
   it("renders a class with class fields and method", () => {
+    const methodRefkey = refkey();
+    const classMethodRefkey = refkey();
+    const staticMethodRefkey = refkey();
+
     const result = toSourceText([
-      <>
+      <py.StatementList>
         <py.ClassDeclaration name="MyClass" bases={["BaseClass"]}>
           <py.StatementList>
-            <py.VariableDeclaration name="a" type="int" />
-            <py.VariableDeclaration name="b" type="int" />
+            <py.VariableDeclaration name="a" type="int" instanceVariable />
+            <py.VariableDeclaration name="b" type="int" instanceVariable />
             <py.FunctionDeclaration
               name="my_method"
               parameters={[
@@ -276,28 +307,31 @@ describe("Python Class - FunctionDeclaration", () => {
                 { name: "b", type: "int" },
               ]}
               returnType="int"
-              instanceFunction={true}
+              instanceFunction
+              refkey={methodRefkey}
             >
               return a + b
             </py.FunctionDeclaration>
             <py.FunctionDeclaration
               name="my_class_method"
-              instanceFunction={false}
-              classFunction={true}
+              classFunction
               returnType="int"
+              refkey={classMethodRefkey}
             >
               pass
             </py.FunctionDeclaration>
             <py.FunctionDeclaration
               name="my_standalone_function"
-              instanceFunction={false}
               returnType="int"
+              refkey={staticMethodRefkey}
             >
               pass
             </py.FunctionDeclaration>
           </py.StatementList>
         </py.ClassDeclaration>
-      </>,
+        {classMethodRefkey}
+        {staticMethodRefkey}
+      </py.StatementList>,
     ]);
     const expected = d`
       class MyClass(BaseClass):
@@ -312,8 +346,9 @@ describe("Python Class - FunctionDeclaration", () => {
           def my_standalone_function() -> int:
               pass
 
-
-          
+      
+      MyClass.my_class_method
+      MyClass.my_standalone_function
     `;
     expect(result).toRenderTo(expected);
   });

package/test/enums.test.tsx

@@ -66,8 +66,8 @@ describe("Python Enum", () => {
     const result = toSourceText(
       [
         <py.StatementList>
-          <py.ClassDeclaration name="Dog" />
-          <py.ClassDeclaration name="Cat" />
+          <py.ClassDeclaration name="Dog" refkey={refkey("Dog")} />
+          <py.ClassDeclaration name="Cat" refkey={refkey("Cat")} />
           <py.EnumDeclaration
             name="Animal"
             baseType="Enum"

package/test/externals.test.tsx

@@ -48,7 +48,6 @@ it("uses import from external library in multiple functions", () => {
       name={"getUser"}
       parameters={[{ name: "userId", type: "int" }]}
       returnType={py.requestsModule["models"]["Response"]}
-      instanceFunction={true}
     >
       <py.StatementList>
         <py.VariableDeclaration
@@ -69,7 +68,6 @@ it("uses import from external library in multiple functions", () => {
       name={"createUser"}
       parameters={[{ name: "userName", type: "string" }]}
       returnType={py.requestsModule["models"]["Response"]}
-      instanceFunction={true}
     >
       <py.StatementList>
         <py.VariableDeclaration
@@ -96,12 +94,12 @@ it("uses import from external library in multiple functions", () => {
     from requests import post
     from requests.models import Response
 
-    def get_user(self, user_id: int) -> Response:
+    def get_user(user_id: int) -> Response:
         response = get(1)
         return response.json()
 
 
-    def create_user(self, user_name: string) -> Response:
+    def create_user(user_name: string) -> Response:
         response = post(1)
         return response.json()
 
@@ -118,12 +116,13 @@ it("uses import from external library in multiple class methods", () => {
           name="some_var"
           initializer={12}
           instanceVariable
+          refkey={refkey("some_var")}
         />
         <py.FunctionDeclaration
-          name={"getUser"}
+          name="getUser"
           parameters={[{ name: "userId", type: "int" }]}
           returnType={py.requestsModule["models"]["Response"]}
-          instanceFunction={true}
+          instanceFunction
         >
           <py.StatementList>
             <py.VariableDeclaration
@@ -144,7 +143,7 @@ it("uses import from external library in multiple class methods", () => {
           name={"createUser"}
           parameters={[{ name: "userName", type: "string" }]}
           returnType={py.requestsModule["models"]["Response"]}
-          instanceFunction={true}
+          instanceFunction
         >
           <py.StatementList>
             <py.VariableDeclaration

package/test/functiondeclaration.test.tsx

@@ -10,11 +10,9 @@ import {
 
 describe("Function Declaration", () => {
   it("renders a function with no body as 'pass'", () => {
-    const result = toSourceText([
-      <py.FunctionDeclaration name="foo" instanceFunction={true} />,
-    ]);
+    const result = toSourceText([<py.FunctionDeclaration name="foo" />]);
     expect(result).toRenderTo(d`
-      def foo(self):
+      def foo():
           pass
 
         
@@ -39,15 +37,10 @@ describe("Function Declaration", () => {
       <py.StatementList>
         <py.FunctionDeclaration
           name="foo"
-          instanceFunction={true}
           returnType="int"
           refkey={refkeyFoo}
         />
-        <py.FunctionDeclaration
-          name="bar"
-          instanceFunction={true}
-          returnType="int"
-        >
+        <py.FunctionDeclaration name="bar" returnType="int">
           <py.VariableDeclaration
             name="result"
             type="int"
@@ -59,10 +52,10 @@ describe("Function Declaration", () => {
       </py.StatementList>,
     ]);
     expect(result).toRenderTo(d`
-      def foo(self) -> int:
+      def foo() -> int:
           pass
 
-      def bar(self) -> int:
+      def bar() -> int:
           result: int = foo()
 
 
@@ -71,15 +64,19 @@ describe("Function Declaration", () => {
 
   it("renders an instance function with a body", () => {
     const result = toSourceText([
-      <py.FunctionDeclaration name="bar" instanceFunction={true}>
-        print('hi')
-      </py.FunctionDeclaration>,
+      <py.ClassDeclaration name="MyClass">
+        <py.FunctionDeclaration name="bar" instanceFunction={true}>
+          print('hi')
+        </py.FunctionDeclaration>
+      </py.ClassDeclaration>,
     ]);
     expect(result).toRenderTo(d`
-      def bar(self):
-          print('hi')
+      class MyClass:
+          def bar(self):
+              print('hi')
 
 
+              
     `);
   });
 
@@ -110,13 +107,17 @@ describe("Function Declaration", () => {
 
   it("renders an __init__ function with no body as 'pass'", () => {
     const result = toSourceText([
-      <py.InitFunctionDeclaration parameters={[{ name: "x" }]} />,
+      <py.ClassDeclaration name="MyClass">
+        <py.InitFunctionDeclaration parameters={[{ name: "x" }]} />
+      </py.ClassDeclaration>,
     ]);
     expect(result).toRenderTo(d`
-      def __init__(self, x):
-          pass
+      class MyClass:
+          def __init__(self, x):
+              pass
 
-        
+      
+      
     `);
   });
 
@@ -144,7 +145,7 @@ describe("Function Declaration", () => {
     expect(
       toSourceText([
         <py.StatementList>
-          <py.ClassDeclaration name="Foo" />
+          <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
           <py.FunctionDeclaration
             async
             name="foo"
@@ -195,32 +196,40 @@ describe("Function Declaration", () => {
   it("renders function with parameters", () => {
     const parameters = [{ name: "x", type: "int" }];
     const decl = (
-      <py.FunctionDeclaration
-        name="foo"
-        instanceFunction={true}
-        parameters={parameters}
-      >
-        self.attribute = "value"
-      </py.FunctionDeclaration>
+      <py.ClassDeclaration name="MyClass">
+        <py.FunctionDeclaration
+          name="foo"
+          instanceFunction
+          parameters={parameters}
+        >
+          self.attribute = "value"
+        </py.FunctionDeclaration>
+      </py.ClassDeclaration>
     );
 
     expect(toSourceText([decl])).toBe(d`
-      def foo(self, x: int):
-          self.attribute = "value"
+      class MyClass:
+          def foo(self, x: int):
+              self.attribute = "value"
+
 
     `);
   });
   it("renders __init__ function with parameters", () => {
     const parameters = [{ name: "x", type: "int" }];
     const decl = (
-      <py.InitFunctionDeclaration parameters={parameters}>
-        self.attribute = "value"
-      </py.InitFunctionDeclaration>
+      <py.ClassDeclaration name="MyClass">
+        <py.InitFunctionDeclaration parameters={parameters}>
+          self.attribute = "value"
+        </py.InitFunctionDeclaration>
+      </py.ClassDeclaration>
     );
 
     expect(toSourceText([decl])).toBe(d`
-      def __init__(self, x: int):
-          self.attribute = "value"
+      class MyClass:
+          def __init__(self, x: int):
+              self.attribute = "value"
+
 
     `);
   });
@@ -277,11 +286,11 @@ describe("Function Declaration", () => {
   it("renders complex typing structure", () => {
     const res = toSourceTextMultiple([
       <py.SourceFile path="mod1.py">
-        <py.ClassDeclaration name="Foo" />
+        <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
       </py.SourceFile>,
       <py.SourceFile path="mod2.py">
-        <py.ClassDeclaration name="A" />
-        <py.ClassDeclaration name="B" />
+        <py.ClassDeclaration name="A" refkey={refkey("A")} />
+        <py.ClassDeclaration name="B" refkey={refkey("B")} />
       </py.SourceFile>,
       <py.SourceFile path="usage.py">
         <py.FunctionDeclaration

package/test/imports.test.tsx

@@ -19,14 +19,8 @@ describe("ImportStatement", () => {
   });
 
   it("renders named imports", () => {
-    const sqrtSymbol = createPythonSymbol("sqrt", {
-      binder: undefined,
-      scope: undefined,
-    });
-    const piSymbol = createPythonSymbol("pi", {
-      binder: undefined,
-      scope: undefined,
-    });
+    const sqrtSymbol = createPythonSymbol("sqrt", undefined);
+    const piSymbol = createPythonSymbol("pi", undefined);
     const symbols = new Set<ImportedSymbol>([
       new ImportedSymbol(sqrtSymbol, sqrtSymbol),
       new ImportedSymbol(piSymbol, piSymbol),
@@ -42,27 +36,20 @@ describe("ImportStatement", () => {
 describe("ImportStatements", () => {
   it("renders multiple import statements", () => {
     const pythonModuleScope = createPythonModuleScope("math", undefined);
-    const sqrtSymbol = createPythonSymbol("sqrt", {
-      binder: undefined,
-      scope: undefined,
-    });
-    const piSymbol = createPythonSymbol("pi", {
-      binder: undefined,
-      scope: undefined,
-    });
+    const sqrtSymbol = createPythonSymbol("sqrt", undefined);
+    const piSymbol = createPythonSymbol("pi", undefined);
+
     const mathSymbols = new Set<ImportedSymbol>([
       new ImportedSymbol(sqrtSymbol, sqrtSymbol),
       new ImportedSymbol(piSymbol, piSymbol),
     ]);
     const sysModuleScope = createPythonModuleScope("sys", undefined);
     const requestsScope = createPythonModuleScope("requests", undefined);
-    const getSymbol = createPythonSymbol("get", {
-      binder: undefined,
-      scope: undefined,
-    });
+    const getSymbol = createPythonSymbol("get", undefined);
     const requestsSymbols = new Set<ImportedSymbol>([
       new ImportedSymbol(getSymbol, getSymbol),
     ]);
+
     const records = new ImportRecords([
       [pythonModuleScope, { symbols: mathSymbols }],
       [requestsScope, { symbols: requestsSymbols }],
@@ -79,27 +66,15 @@ describe("ImportStatements", () => {
   });
   it("renders multiple import statements, but joining imports from the same module", () => {
     const pythonModuleScope = createPythonModuleScope("math", undefined);
-    const sqrtSymbol = createPythonSymbol("sqrt", {
-      binder: undefined,
-      scope: undefined,
-    });
-    const piSymbol = createPythonSymbol("pi", {
-      binder: undefined,
-      scope: undefined,
-    });
+    const sqrtSymbol = createPythonSymbol("sqrt", undefined);
+    const piSymbol = createPythonSymbol("pi", undefined);
     const mathSymbols = new Set<ImportedSymbol>([
       new ImportedSymbol(sqrtSymbol, sqrtSymbol),
       new ImportedSymbol(piSymbol, piSymbol),
     ]);
     const requestsScope = createPythonModuleScope("requests", undefined);
-    const getSymbol = createPythonSymbol("get", {
-      binder: undefined,
-      scope: undefined,
-    });
-    const postSymbol = createPythonSymbol("post", {
-      binder: undefined,
-      scope: undefined,
-    });
+    const getSymbol = createPythonSymbol("get", undefined);
+    const postSymbol = createPythonSymbol("post", undefined);
     const requestsSymbols = new Set<ImportedSymbol>([
       new ImportedSymbol(getSymbol, getSymbol),
       new ImportedSymbol(postSymbol, postSymbol),

package/test/utils.tsx

@@ -6,6 +6,7 @@ import {
   Output,
   OutputDirectory,
   OutputFile,
+  OutputScope,
   PrintTreeOptions,
   SymbolCreator,
   render,
@@ -13,8 +14,8 @@ import {
 import { dedent } from "@alloy-js/core/testing";
 import { expect } from "vitest";
 import * as py from "../src/components/index.js";
+import { pythonNameConflictResolver } from "../src/name-conflict-resolver.js";
 import { createPythonNamePolicy } from "../src/name-policy.js";
-import { CustomOutputScope } from "../src/symbols/custom-output-scope.js";
 import { PythonModuleScope } from "../src/symbols/index.js";
 
 export function findFile(
@@ -81,12 +82,18 @@ export function toSourceTextMultiple(
     printOptions = {
       printWidth: 80,
       tabWidth: 4,
+      insertFinalNewLine: false,
     };
   } else {
+    printOptions.insertFinalNewLine = false;
     printOptions.tabWidth = 4;
   }
   const content = (
-    <Output externals={mergedExternals} namePolicy={policy}>
+    <Output
+      externals={mergedExternals}
+      namePolicy={policy}
+      nameConflictResolver={pythonNameConflictResolver}
+    >
       {sourceFiles}
     </Output>
   );
@@ -121,11 +128,10 @@ export function toSourceText(
 // Helper function to create a PythonModuleScope to be used in tests
 export function createPythonModuleScope(
   name: string,
-  parent: CustomOutputScope | undefined,
+  parent: OutputScope | undefined,
   binder: Binder | undefined = undefined,
 ): PythonModuleScope {
-  return new PythonModuleScope(name, {
-    parent: parent,
+  return new PythonModuleScope(name, parent, {
     binder: binder,
   });
 }

package/test/variables.test.tsx

@@ -124,12 +124,13 @@ describe("Python Variable", () => {
   });
 
   it("declares a python variable with a class type", () => {
+    const classKey = refkey();
     const res = toSourceText([
       <py.StatementList>
-        <py.ClassDeclaration name="MyClass" />
+        <py.ClassDeclaration name="MyClass" refkey={classKey} />
         <py.VariableDeclaration
           name="my_var"
-          type={<py.Reference refkey={refkey("MyClass")} />}
+          type={<py.Reference refkey={classKey} />}
         />
       </py.StatementList>,
     ]);
@@ -141,14 +142,15 @@ describe("Python Variable", () => {
   });
 
   it("declares a python variable with a class type from a different module", () => {
+    const classKey = refkey();
     const res = toSourceTextMultiple([
       <py.SourceFile path="classes.py">
-        <py.ClassDeclaration name="MyClass" />
+        <py.ClassDeclaration name="MyClass" refkey={classKey} />
       </py.SourceFile>,
       <py.SourceFile path="usage.py">
         <py.VariableDeclaration
           name="my_var"
-          type={<py.Reference refkey={refkey("MyClass")} />}
+          type={<py.Reference refkey={classKey} />}
         />
       </py.SourceFile>,
     ]);
@@ -167,13 +169,15 @@ describe("Python Variable", () => {
   });
 
   it("declares a python variable receiving other variable as value", () => {
+    const varKey = refkey();
     const res = toSourceText([
       <py.StatementList>
-        <py.VariableDeclaration name="my_var" initializer={42} />
         <py.VariableDeclaration
-          name="my_other_var"
-          initializer={refkey("my_var")}
+          name="my_var"
+          refkey={varKey}
+          initializer={42}
         />
+        <py.VariableDeclaration name="my_other_var" initializer={varKey} />
       </py.StatementList>,
     ]);
     expect(res).toBe(`my_var = 42\nmy_other_var = my_var`);

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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,25 +0,0 @@
-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 ?? "");
-        }
-      }
-    });
-  }
-}