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

package/test/callsignatures.test.tsx

@@ -26,8 +26,14 @@ describe("Call Signature Parameters", () => {
     const result = toSourceText([
       <py.CallSignatureParameters
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
       />,
     ]);
@@ -39,8 +45,16 @@ describe("Call Signature Parameters", () => {
     const result = toSourceText([
       <py.CallSignatureParameters
         parameters={[
-          { name: "a", type: "int", optional: true },
-          { name: "b", type: "str", optional: true },
+          {
+            name: "a",
+            type: "int",
+            default: null,
+          },
+          {
+            name: "b",
+            type: "str",
+            default: null,
+          },
         ]}
       />,
     ]);
@@ -65,8 +79,16 @@ describe("Call Signature Parameters", () => {
     const result = toSourceText([
       <py.CallSignatureParameters
         parameters={[
-          { name: "a", type: "int", optional: true, default: 5 },
-          { name: "b", type: "str", optional: true, default: "hello" },
+          {
+            name: "a",
+            type: "int",
+            default: 5,
+          },
+          {
+            name: "b",
+            type: "str",
+            default: "hello",
+          },
         ]}
       />,
     ]);
@@ -77,75 +99,60 @@ describe("Call Signature Parameters", () => {
 });
 
 describe("Call Signature", () => {
-  it("renders a simple call signature", () => {
+  it("renders a call signature with strings", () => {
     const result = toSourceText([<py.CallSignature parameters={["a", "b"]} />]);
     expect(result).toRenderTo(d`
       (a, b)
     `);
   });
-  it("renders a simple call signature with args and kwargs", () => {
-    const result = toSourceText([
-      <py.CallSignature parameters={["a", "b"]} args kwargs />,
-    ]);
-    expect(result).toRenderTo(d`
-      (a, b, *args, **kwargs)
-    `);
-  });
-  it("renders a simple call signature with type parameters", () => {
+  it("renders a call signature with parameter descriptors", () => {
     const result = toSourceText([
-      <py.CallSignature parameters={["a", "b"]} typeParameters={["T", "U"]} />,
+      <py.CallSignature parameters={[{ name: "a" }, { name: "b" }]} />,
     ]);
     expect(result).toRenderTo(d`
-      [T, U](a, b)
+      (a, b)
     `);
   });
-  it("renders a simple call signature with return type", () => {
+  it("renders a call signature with mixed strings and parameter descriptors", () => {
     const result = toSourceText([
-      <py.CallSignature parameters={["a", "b"]} returnType="int" />,
+      <py.CallSignature parameters={["a", { name: "b" }]} />,
     ]);
     expect(result).toRenderTo(d`
-      (a, b) -> int
+      (a, b)
     `);
   });
-  it("renders a simple call signature for a class function", () => {
+  it("renders a simple call signature with args and kwargs", () => {
     const result = toSourceText([
-      <py.CallSignature parameters={["a", "b"]} classFunction />,
+      <py.CallSignature
+        parameters={[{ name: "a" }, { name: "b" }]}
+        args
+        kwargs
+      />,
     ]);
     expect(result).toRenderTo(d`
-      (cls, a, b)
+      (a, b, *args, **kwargs)
     `);
   });
-  it("renders a simple call signature for an instance function", () => {
+  it("renders a simple call signature with type parameters", () => {
     const result = toSourceText([
-      <py.CallSignature parameters={["a", "b"]} instanceFunction />,
+      <py.CallSignature
+        parameters={[{ name: "a" }, { name: "b" }]}
+        typeParameters={["T", "U"]}
+      />,
     ]);
     expect(result).toRenderTo(d`
-      (self, a, b)
+      [T, U](a, b)
     `);
   });
-  it("throws an error for a call signature that's instance and class function at the same time", () => {
-    expect(() =>
-      toSourceText([
-        <py.CallSignature
-          parameters={["a", "b"]}
-          instanceFunction
-          classFunction
-        />,
-      ]),
-    ).toThrowError(/Cannot be both an instance function and a class function/);
-  });
-  it("renders a simple call signature with all properties", () => {
+  it("renders a simple call signature with return type", () => {
     const result = toSourceText([
       <py.CallSignature
-        parameters={["a", "b"]}
-        instanceFunction
-        args
-        kwargs
+        parameters={[{ name: "a" }, { name: "b" }]}
         returnType="int"
       />,
     ]);
     expect(result).toRenderTo(d`
-      (self, a, b, *args, **kwargs) -> int
+      (a, b) -> int
     `);
   });
 });
@@ -155,8 +162,14 @@ describe("Call Signature - Parameter Descriptors", () => {
     const result = toSourceText([
       <py.CallSignature
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
       />,
     ]);
@@ -168,8 +181,14 @@ describe("Call Signature - Parameter Descriptors", () => {
     const result = toSourceText([
       <py.CallSignature
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
         args
         kwargs
@@ -183,8 +202,14 @@ describe("Call Signature - Parameter Descriptors", () => {
     const result = toSourceText([
       <py.CallSignature
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
         returnType="int"
       />,
@@ -197,45 +222,41 @@ describe("Call Signature - Parameter Descriptors", () => {
     const result = toSourceText([
       <py.CallSignature
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
-        classFunction
       />,
     ]);
     expect(result).toRenderTo(d`
-      (cls, a: int, b: str)
-    `);
-  });
-  it("renders a call signature with parameter descriptors for an instance function", () => {
-    const result = toSourceText([
-      <py.CallSignature
-        parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
-        ]}
-        instanceFunction
-      />,
-    ]);
-    expect(result).toRenderTo(d`
-      (self, a: int, b: str)
+      (a: int, b: str)
     `);
   });
   it("renders a call signature with all", () => {
     const result = toSourceText([
       <py.CallSignature
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+          },
         ]}
-        instanceFunction
         args
         kwargs
         returnType="int"
       />,
     ]);
     expect(result).toRenderTo(d`
-      (self, a: int, b: str, *args, **kwargs) -> int
+      (a: int, b: str, *args, **kwargs) -> int
     `);
   });
   it("renders a more complex call signature with parameter descriptors", () => {
@@ -243,8 +264,15 @@ describe("Call Signature - Parameter Descriptors", () => {
       <py.CallSignature
         typeParameters={["T", "U"]}
         parameters={[
-          { name: "a", type: "int" },
-          { name: "b", type: "str", default: "default_value" },
+          {
+            name: "a",
+            type: "int",
+          },
+          {
+            name: "b",
+            type: "str",
+            default: "default_value",
+          },
         ]}
         returnType="int"
       />,

package/test/class-method-declaration.test.tsx

@@ -0,0 +1,53 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+describe("ClassMethodDeclaration", () => {
+  it("renders async class method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.ClassMethodDeclaration
+              async
+              name="create"
+              returnType={"MyClass"}
+            >
+              return cls()
+            </py.ClassMethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @classmethod
+          async def create(cls) -> MyClass:
+              return cls()
+
+
+    `);
+  });
+
+  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"
+
+
+    `);
+  });
+});

package/test/classdeclarations.test.tsx

@@ -207,9 +207,9 @@ describe("Python Class - VariableDeclaration", () => {
           <py.StatementList>
             <py.VariableDeclaration instanceVariable name="just_name" />
             <py.VariableDeclaration
-              instanceVariable
               name="name_and_type"
               type="number"
+              instanceVariable
             />
             <py.VariableDeclaration
               instanceVariable
@@ -269,9 +269,8 @@ describe("Python Class - VariableDeclaration", () => {
               initializer={42}
               instanceVariable
             />
-            <py.FunctionDeclaration
+            <py.MethodDeclaration
               name="instanceMethod"
-              instanceFunction
               refkey={classMethodRk}
               returnType="int"
             />
@@ -312,26 +311,24 @@ describe("Python Class - FunctionDeclaration", () => {
           <py.StatementList>
             <py.VariableDeclaration name="a" type="int" instanceVariable />
             <py.VariableDeclaration name="b" type="int" instanceVariable />
-            <py.FunctionDeclaration
+            <py.MethodDeclaration
               name="my_method"
               parameters={[
                 { name: "a", type: "int" },
                 { name: "b", type: "int" },
               ]}
               returnType="int"
-              instanceFunction
               refkey={methodRefkey}
             >
               return a + b
-            </py.FunctionDeclaration>
-            <py.FunctionDeclaration
+            </py.MethodDeclaration>
+            <py.ClassMethodDeclaration
               name="my_class_method"
-              classFunction
               returnType="int"
               refkey={classMethodRefkey}
             >
               pass
-            </py.FunctionDeclaration>
+            </py.ClassMethodDeclaration>
             <py.FunctionDeclaration
               name="my_standalone_function"
               returnType="int"
@@ -352,6 +349,7 @@ describe("Python Class - FunctionDeclaration", () => {
           def my_method(self, a: int, b: int) -> int:
               return a + b
 
+          @classmethod
           def my_class_method(cls) -> int:
               pass
 

package/test/constructordeclaration.test.tsx

@@ -0,0 +1,48 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+describe("ConstructorDeclaration", () => {
+  it("renders async constructor with return type", () => {
+    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("renders __new__ with spread args", () => {
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <py.StatementList>
+          <py.ConstructorDeclaration args kwargs>
+            pass
+          </py.ConstructorDeclaration>
+        </py.StatementList>
+      </py.ClassDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          def __new__(cls, *args, **kwargs):
+              pass
+
+
+    `);
+  });
+});

package/test/dundermethoddeclaration.test.tsx

@@ -0,0 +1,53 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+describe("Dunder/Constructor Declarations", () => {
+  it("renders dunder methods with parameters", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <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 __init__(self, x: int):
+              self.attribute = "value"
+
+          def __repr__(self, x: int):
+              return "MyClass"
+
+
+    `);
+  });
+
+  it("renders dunder methods __new__", () => {
+    const decl = (
+      <py.ClassDeclaration name="MyClass">
+        <py.StatementList>
+          <py.ConstructorDeclaration args kwargs>
+            pass
+          </py.ConstructorDeclaration>
+        </py.StatementList>
+      </py.ClassDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          def __new__(cls, *args, **kwargs):
+              pass
+
+
+    `);
+  });
+});

package/test/enums.test.tsx

@@ -6,10 +6,10 @@ import * as py from "../src/index.js";
 import { toSourceText } from "./utils.jsx";
 
 describe("Python Enum", () => {
-  it("classic enum with explicit values", () => {
+  it("class enum with explicit values", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.ClassEnumDeclaration
           name="Color"
           baseType="IntEnum"
           members={[
@@ -34,10 +34,10 @@ describe("Python Enum", () => {
     expect(result).toRenderTo(expected);
   });
 
-  it("classic enum with jsValues", () => {
+  it("class enum with jsValues", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.ClassEnumDeclaration
           name="Color"
           baseType="IntEnum"
           members={[
@@ -62,13 +62,13 @@ describe("Python Enum", () => {
     expect(result).toRenderTo(expected);
   });
 
-  it("classic enum with a refkey as jsValue", () => {
+  it("class enum with a refkey as jsValue", () => {
     const result = toSourceText(
       [
         <py.StatementList>
           <py.ClassDeclaration name="Dog" refkey={refkey("Dog")} />
           <py.ClassDeclaration name="Cat" refkey={refkey("Cat")} />
-          <py.EnumDeclaration
+          <py.ClassEnumDeclaration
             name="Animal"
             baseType="Enum"
             members={[
@@ -98,12 +98,12 @@ describe("Python Enum", () => {
     expect(result).toRenderTo(expected);
   });
 
-  it("enum with auto() values", () => {
+  it("class enum with auto() values", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.ClassEnumDeclaration
           name="Animal"
-          style="auto"
+          auto
           members={[{ name: "DOG" }, { name: "CAT" }, { name: "RABBIT" }]}
         />,
       ],
@@ -123,13 +123,13 @@ describe("Python Enum", () => {
     expect(result).toRenderTo(expected);
   });
 
-  it("enum with mixed manual and auto() values", () => {
+  it("class enum with mixed manual and auto() values", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.ClassEnumDeclaration
           name="Permission"
           baseType="Flag"
-          style="auto"
+          auto
           members={[
             { name: "READ", value: 1 },
             { name: "WRITE" },
@@ -157,9 +157,8 @@ describe("Python Enum", () => {
   it("functional enum with list", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.FunctionalEnumDeclaration
           name="Direction"
-          style="functional"
           members={[
             { name: "NORTH" },
             { name: "SOUTH" },
@@ -181,9 +180,8 @@ describe("Python Enum", () => {
   it("functional enum with mapping", () => {
     const result = toSourceText(
       [
-        <py.EnumDeclaration
+        <py.FunctionalEnumDeclaration
           name="Priority"
-          style="functional"
           members={[
             { name: "HIGH", value: 1 },
             { name: "MEDIUM", value: 2 },

package/test/externals.test.tsx

@@ -118,11 +118,10 @@ it("uses import from external library in multiple class methods", () => {
           instanceVariable
           refkey={refkey("some_var")}
         />
-        <py.FunctionDeclaration
-          name="getUser"
+        <py.MethodDeclaration
+          name={"getUser"}
           parameters={[{ name: "userId", type: "int" }]}
           returnType={py.requestsModule["models"]["Response"]}
-          instanceFunction
         >
           <py.StatementList>
             <py.VariableDeclaration
@@ -138,12 +137,11 @@ it("uses import from external library in multiple class methods", () => {
               return response.json()
             `}
           </py.StatementList>
-        </py.FunctionDeclaration>
-        <py.FunctionDeclaration
+        </py.MethodDeclaration>
+        <py.MethodDeclaration
           name={"createUser"}
           parameters={[{ name: "userName", type: "string" }]}
           returnType={py.requestsModule["models"]["Response"]}
-          instanceFunction
         >
           <py.StatementList>
             <py.VariableDeclaration
@@ -159,7 +157,7 @@ it("uses import from external library in multiple class methods", () => {
               return response.json()
             `}
           </py.StatementList>
-        </py.FunctionDeclaration>
+        </py.MethodDeclaration>
       </py.StatementList>
     </py.ClassDeclaration>,
   ];