@alloy-js/python 0.2.0-dev.3 → 0.2.0-dev.4

package/test/factories.test.tsx

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+describe("Symbol factories", () => {
+  it("createMethodSymbol throws outside class", () => {
+    expect(() => {
+      toSourceText([<py.MethodDeclaration name="m" />]);
+    }).toThrow('Method "m" must be declared inside a class (member scope)');
+  });
+
+  it("createMethodSymbol succeeds inside class", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="C">
+        <py.MethodDeclaration name="m" />
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toContain("def m(self):");
+  });
+
+  it("createFunctionSymbol usable in member scope (top-level function component still works nested)", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="C">
+        <py.StatementList>
+          <py.FunctionDeclaration name="f" />
+        </py.StatementList>
+      </py.ClassDeclaration>,
+    ]);
+    // Nested free functions render without self/cls
+    expect(result).toContain("def f():");
+  });
+});
+
+describe("Validation Errors", () => {
+  it("throws error when PropertyDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.PropertyDeclaration name="x" />]);
+    }).toThrow('Method "x" must be declared inside a class (member scope)');
+  });
+
+  it("throws error when MethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.MethodDeclaration name="my_method" />]);
+    }).toThrow(
+      'Method "my_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when ClassMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.ClassMethodDeclaration name="my_class_method" />]);
+    }).toThrow(
+      'Method "my_class_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when StaticMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.StaticMethodDeclaration name="my_static_method" />]);
+    }).toThrow(
+      'Method "my_static_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when DunderMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.DunderMethodDeclaration name="__init__" />]);
+    }).toThrow(
+      'Method "__init__" must be declared inside a class (member scope)',
+    );
+  });
+});

package/test/functiondeclaration.test.tsx

@@ -1,7 +1,8 @@
-import { namekey, refkey } from "@alloy-js/core";
+import { code, namekey, refkey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
+import { abcModule } from "../src/index.js";
 import {
   assertFileContents,
   toSourceText,
@@ -74,24 +75,6 @@ describe("Function Declaration", () => {
     `);
   });
 
-  it("renders an instance function with a body", () => {
-    const result = toSourceText([
-      <py.ClassDeclaration name="MyClass">
-        <py.FunctionDeclaration name="bar" instanceFunction={true}>
-          print('hi')
-        </py.FunctionDeclaration>
-      </py.ClassDeclaration>,
-    ]);
-    expect(result).toRenderTo(d`
-      class MyClass:
-          def bar(self):
-              print('hi')
-
-
-              
-    `);
-  });
-
   it("renders a function with parameters", () => {
     const result = toSourceText([
       <py.FunctionDeclaration
@@ -120,7 +103,10 @@ describe("Function Declaration", () => {
   it("renders an __init__ function with no body as 'pass'", () => {
     const result = toSourceText([
       <py.ClassDeclaration name="MyClass">
-        <py.InitFunctionDeclaration parameters={[{ name: "x" }]} />
+        <py.DunderMethodDeclaration
+          name="__init__"
+          parameters={[{ name: "x" }]}
+        />
       </py.ClassDeclaration>,
     ]);
     expect(result).toRenderTo(d`
@@ -144,7 +130,7 @@ describe("Function Declaration", () => {
   it("can be an async function with returnType", () => {
     expect(
       toSourceText([
-        <py.FunctionDeclaration async name="foo" returnType="Foo" />,
+        <py.FunctionDeclaration async name="foo" returnType={"Foo"} />,
       ]),
     ).toBe(d`
       async def foo() -> Foo:
@@ -154,6 +140,24 @@ describe("Function Declaration", () => {
   });
 
   it("can be an async function with returnType element with Reference", () => {
+    expect(
+      toSourceText([
+        <py.StatementList>
+          <py.ClassDeclaration name="Foo" refkey={refkey("Foo")} />
+          <py.FunctionDeclaration async name="foo" returnType={refkey("Foo")} />
+        </py.StatementList>,
+      ]),
+    ).toBe(d`
+      class Foo:
+          pass
+
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+
+  it("can be an async function with returnType element with list of References", () => {
     expect(
       toSourceText([
         <py.StatementList>
@@ -161,7 +165,7 @@ describe("Function Declaration", () => {
           <py.FunctionDeclaration
             async
             name="foo"
-            returnType={<py.Reference refkey={refkey("Foo")} />}
+            returnType={code`list[${refkey("Foo")}]`}
           />
         </py.StatementList>,
       ]),
@@ -169,15 +173,66 @@ describe("Function Declaration", () => {
       class Foo:
           pass
 
-      async def foo() -> Foo:
+      async def foo() -> list[Foo]:
           pass
 
     `);
   });
 
+  it("can be an async dunder method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.DunderMethodDeclaration
+              async
+              name="__aenter__"
+              returnType={"MyClass"}
+            >
+              return self
+            </py.DunderMethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          async def __aenter__(self) -> MyClass:
+              return self
+
+
+    `);
+  });
+
+  it("can be an async constructor", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.ConstructorDeclaration async returnType={"MyClass"}>
+              return super().__new__(cls)
+            </py.ConstructorDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          async def __new__(cls) -> MyClass:
+              return super().__new__(cls)
+
+
+    `);
+  });
+
   it("supports parameters", () => {
     const decl = (
-      <py.FunctionDeclaration name="foo" parameters={["a", "b"]}>
+      <py.FunctionDeclaration
+        name="foo"
+        parameters={[{ name: "a" }, { name: "b" }]}
+      >
         return a + b
       </py.FunctionDeclaration>
     );
@@ -192,7 +247,7 @@ describe("Function Declaration", () => {
     const decl = (
       <py.FunctionDeclaration
         name="foo"
-        parameters={["a", "b"]}
+        parameters={[{ name: "a" }, { name: "b" }]}
         typeParameters={["T", "U"]}
       >
         return a + b
@@ -205,42 +260,95 @@ describe("Function Declaration", () => {
 
     `);
   });
-  it("renders function with parameters", () => {
+  it("renders abstract methods", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.MethodDeclaration
+              name="methoddef"
+              parameters={parameters}
+              abstract
+            />
+            <py.ClassMethodDeclaration
+              name="classdef"
+              parameters={parameters}
+              abstract
+            />
+            <py.StaticMethodDeclaration
+              name="staticdef"
+              parameters={parameters}
+              abstract
+            />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+      from abc import abstractmethod
+
+      class MyClass:
+          @abstractmethod
+          def methoddef(self, x: int):
+              pass
+
+          @classmethod
+          @abstractmethod
+          def classdef(cls, x: int):
+              pass
+
+          @staticmethod
+          @abstractmethod
+          def staticdef(x: int):
+              pass
+
+
+    `);
+  });
+  it("renders dunder methods with parameters", () => {
     const parameters = [{ name: "x", type: "int" }];
     const decl = (
       <py.ClassDeclaration name="MyClass">
-        <py.FunctionDeclaration
-          name="foo"
-          instanceFunction
-          parameters={parameters}
-        >
-          self.attribute = "value"
-        </py.FunctionDeclaration>
+        <py.StatementList>
+          <py.DunderMethodDeclaration name="__init__" parameters={parameters}>
+            self.attribute = "value"
+          </py.DunderMethodDeclaration>
+          <py.DunderMethodDeclaration name="__repr__" parameters={parameters}>
+            return "MyClass"
+          </py.DunderMethodDeclaration>
+        </py.StatementList>
       </py.ClassDeclaration>
     );
 
     expect(toSourceText([decl])).toBe(d`
       class MyClass:
-          def foo(self, x: int):
+          def __init__(self, x: int):
               self.attribute = "value"
 
+          def __repr__(self, x: int):
+              return "MyClass"
+
 
     `);
   });
-  it("renders __init__ function with parameters", () => {
-    const parameters = [{ name: "x", type: "int" }];
+
+  it("renders dunder methods __new__", () => {
     const decl = (
       <py.ClassDeclaration name="MyClass">
-        <py.InitFunctionDeclaration parameters={parameters}>
-          self.attribute = "value"
-        </py.InitFunctionDeclaration>
+        <py.StatementList>
+          <py.ConstructorDeclaration args kwargs>
+            pass
+          </py.ConstructorDeclaration>
+        </py.StatementList>
       </py.ClassDeclaration>
     );
 
     expect(toSourceText([decl])).toBe(d`
       class MyClass:
-          def __init__(self, x: int):
-              self.attribute = "value"
+          def __new__(cls, *args, **kwargs):
+              pass
 
 
     `);
@@ -309,12 +417,18 @@ describe("Function Declaration", () => {
           async
           name="foo"
           parameters={[
-            { name: "x", type: <py.Reference refkey={refkey("A")} /> },
-            { name: "y", type: <py.Reference refkey={refkey("B")} /> },
+            {
+              name: "x",
+              type: refkey("A"),
+            },
+            {
+              name: "y",
+              type: refkey("B"),
+            },
           ]}
           args={true}
           kwargs={true}
-          returnType={<py.Reference refkey={refkey("Foo")} />}
+          returnType={refkey("Foo")}
         />
       </py.SourceFile>,
     ]);
@@ -345,4 +459,42 @@ describe("Function Declaration", () => {
             `,
     });
   });
+
+  it("throws error when PropertyDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.PropertyDeclaration name="x" />]);
+    }).toThrow('Method "x" must be declared inside a class (member scope)');
+  });
+
+  it("throws error when MethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.MethodDeclaration name="my_method" />]);
+    }).toThrow(
+      'Method "my_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when ClassMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.ClassMethodDeclaration name="my_class_method" />]);
+    }).toThrow(
+      'Method "my_class_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when StaticMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.StaticMethodDeclaration name="my_static_method" />]);
+    }).toThrow(
+      'Method "my_static_method" must be declared inside a class (member scope)',
+    );
+  });
+
+  it("throws error when DunderMethodDeclaration is used outside of a class", () => {
+    expect(() => {
+      toSourceText([<py.DunderMethodDeclaration name="__init__" />]);
+    }).toThrow(
+      'Method "__init__" must be declared inside a class (member scope)',
+    );
+  });
 });

package/test/memberexpressions.test.tsx

@@ -424,7 +424,12 @@ describe("with refkeys", () => {
     const fooRef = refkey();
     const modelRef = refkey();
     const parameters: ParameterDescriptor[] = [
-      { name: "foo", optional: true, refkey: fooRef, type: modelRef },
+      {
+        name: "foo",
+        default: null,
+        refkey: fooRef,
+        type: modelRef,
+      },
     ];
     const messageRef = refkey();
     const template = (
@@ -480,7 +485,7 @@ describe("with refkeys", () => {
             <VariableDeclaration
               name="prop1"
               refkey={interfaceMemberRefkey}
-              type={"str"}
+              type="str"
               omitNone={true}
             />
           </ClassDeclaration>

package/test/methoddeclaration.test.tsx

@@ -0,0 +1,202 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { abcModule } from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+describe("Method-like Declarations", () => {
+  it("renders an instance function with a body", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="MyClass">
+        <py.MethodDeclaration name="bar">print('hi')</py.MethodDeclaration>
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      class MyClass:
+          def bar(self):
+              print('hi')
+
+
+              
+    `);
+  });
+
+  it("can be an async method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.MethodDeclaration async name="my_method" returnType="str">
+              return "async result"
+            </py.MethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          async def my_method(self) -> str:
+              return "async result"
+
+
+    `);
+  });
+
+  it("can be an async class method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.ClassMethodDeclaration
+              async
+              name="create_async"
+              returnType={"MyClass"}
+            >
+              return cls()
+            </py.ClassMethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @classmethod
+          async def create_async(cls) -> MyClass:
+              return cls()
+
+
+    `);
+  });
+
+  it("can be an async static method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.StaticMethodDeclaration async name="utility" returnType="str">
+              return "utility result"
+            </py.StaticMethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @staticmethod
+          async def utility() -> str:
+              return "utility result"
+
+
+    `);
+  });
+
+  it("renders method with parameters", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <py.MethodDeclaration name="foo" parameters={parameters}>
+          self.attribute = "value"
+        </py.MethodDeclaration>
+      </py.ClassDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          def foo(self, x: int):
+              self.attribute = "value"
+
+
+    `);
+  });
+
+  it("renders class method with parameters", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <py.ClassMethodDeclaration name="foo" parameters={parameters}>
+          self.attribute = "value"
+        </py.ClassMethodDeclaration>
+      </py.ClassDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @classmethod
+          def foo(cls, x: int):
+              self.attribute = "value"
+
+
+    `);
+  });
+
+  it("renders static method with parameters", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <py.StaticMethodDeclaration name="foo" parameters={parameters}>
+          attribute = "value"
+        </py.StaticMethodDeclaration>
+      </py.ClassDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @staticmethod
+          def foo(x: int):
+              attribute = "value"
+
+
+    `);
+  });
+
+  it("renders abstract methods", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.MethodDeclaration
+              name="methoddef"
+              parameters={parameters}
+              abstract
+            />
+            <py.ClassMethodDeclaration
+              name="classdef"
+              parameters={parameters}
+              abstract
+            />
+            <py.StaticMethodDeclaration
+              name="staticdef"
+              parameters={parameters}
+              abstract
+            />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl], { externals: [abcModule] })).toBe(d`
+      from abc import abstractmethod
+
+      class MyClass:
+          @abstractmethod
+          def methoddef(self, x: int):
+              pass
+
+          @classmethod
+          @abstractmethod
+          def classdef(cls, x: int):
+              pass
+
+          @staticmethod
+          @abstractmethod
+          def staticdef(x: int):
+              pass
+
+
+    `);
+  });
+});

package/test/namepolicies.test.tsx

@@ -20,9 +20,8 @@ it("correct formatting of class name", () => {
 it("correct formatting of Enum name and EnumMember names", () => {
   const result = toSourceText(
     [
-      <py.EnumDeclaration
+      <py.FunctionalEnumDeclaration
         name="priority"
-        style="functional"
         members={[
           { name: "high", value: 1 },
           { name: "Medium", value: 2 },