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

package/test/references.test.tsx

@@ -13,7 +13,7 @@ describe("Reference", () => {
       <py.SourceFile path="services.py">
         <py.VariableDeclaration
           name="current_user"
-          type={<py.Reference refkey={rk1} />}
+          type={rk1}
           initializer={
             <py.ClassInstantiation target="User" args={['"Marvin"']} />
           }

package/test/sourcefiles.test.tsx

@@ -1,7 +1,12 @@
+import { Prose } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import * as py from "../src/index.js";
-import { toSourceText } from "./utils.jsx";
+import {
+  assertFileContents,
+  toSourceText,
+  toSourceTextMultiple,
+} from "./utils.jsx";
 
 /**
  * toSourceText wraps the children in a SourceFile component
@@ -129,3 +134,97 @@ it("correct formatting of source file", () => {
   `;
   expect(result).toRenderTo(expected);
 });
+
+it("renders module documentation correctly", () => {
+  const moduleDoc = (
+    <py.ModuleDoc
+      description={[
+        <Prose>
+          This module provides utility functions for data processing. It
+          includes functions for validation, transformation, and analysis.
+        </Prose>,
+      ]}
+      attributes={[
+        {
+          name: "DEFAULT_TIMEOUT",
+          type: "int",
+          children: "Default timeout value in seconds.",
+        },
+        {
+          name: "MAX_RETRIES",
+          type: "int",
+          children: "Maximum number of retry attempts.",
+        },
+      ]}
+      todo={["Add caching functionality", "Improve error messages"]}
+      style="google"
+    />
+  );
+
+  const content = (
+    <py.SourceFile path="utils.py" doc={moduleDoc}>
+      <py.VariableDeclaration name="DEFAULT_TIMEOUT" initializer={30} />
+      <py.VariableDeclaration name="MAX_RETRIES" initializer={3} />
+      <py.FunctionDeclaration name="process_data">pass</py.FunctionDeclaration>
+    </py.SourceFile>
+  );
+
+  const res = toSourceTextMultiple([content]);
+  const file = res.contents.find(
+    (f) => f.kind === "file" && f.path === "utils.py",
+  );
+  expect(file).toBeDefined();
+
+  assertFileContents(res, {
+    "utils.py": d`
+        """
+        This module provides utility functions for data processing. It includes
+        functions for validation, transformation, and analysis.
+
+        Attributes:
+            DEFAULT_TIMEOUT (int): Default timeout value in seconds.
+
+            MAX_RETRIES (int): Maximum number of retry attempts.
+
+        Todo:
+            * Add caching functionality
+            * Improve error messages
+        """
+
+
+        default_timeout = 30
+
+        max_retries = 3
+
+        def process_data():
+            pass
+
+
+        `,
+  });
+});
+
+it("renders source file without documentation correctly", () => {
+  const content = (
+    <py.SourceFile path="simple.py">
+      <py.FunctionDeclaration name="hello_world">
+        print("Hello, World!")
+      </py.FunctionDeclaration>
+    </py.SourceFile>
+  );
+
+  const res = toSourceTextMultiple([content]);
+  const file = res.contents.find(
+    (f) => f.kind === "file" && f.path === "simple.py",
+  );
+  expect(file).toBeDefined();
+
+  assertFileContents(res, {
+    "simple.py": d`
+        def hello_world():
+            print("Hello, World!")
+
+
+        `,
+  });
+});

package/test/staticmethoddeclaration.test.tsx

@@ -0,0 +1,49 @@
+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("StaticMethodDeclaration", () => {
+  it("renders async static method", () => {
+    const decl = (
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass">
+          <py.StatementList>
+            <py.StaticMethodDeclaration async name="util" returnType="str">
+              return "x"
+            </py.StaticMethodDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      class MyClass:
+          @staticmethod
+          async def util() -> str:
+              return "x"
+
+
+    `);
+  });
+
+  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"
+
+
+    `);
+  });
+});

package/test/typereference.test.tsx

@@ -0,0 +1,52 @@
+import { code, 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 { toSourceText } from "./utils.jsx";
+
+describe("TypeReference", () => {
+  it("renders a Python TypeReference with a refkey and type arguments", () => {
+    const classRefkey = refkey();
+
+    expect(
+      toSourceText([
+        <py.StatementList>
+          <py.ClassDeclaration
+            name="Bar"
+            refkey={classRefkey}
+          ></py.ClassDeclaration>
+          <py.TypeReference refkey={classRefkey} typeArgs={["T", "P"]} />
+          <py.TypeReference name="dict" typeArgs={["str", "int"]} />
+        </py.StatementList>,
+      ]),
+    ).toRenderTo(d`
+        class Bar:
+            pass
+
+        Bar[T, P]
+        dict[str, int]
+    `);
+  });
+
+  it("renders a Python list expression with a reference", () => {
+    const classRefkey = refkey();
+    const type = code`list[${classRefkey}]`;
+
+    expect(
+      toSourceText([
+        <py.StatementList>
+          <py.ClassDeclaration
+            name="Foo"
+            refkey={classRefkey}
+          ></py.ClassDeclaration>
+          <py.TypeReference name={type} />
+        </py.StatementList>,
+      ]),
+    ).toRenderTo(d`
+        class Foo:
+            pass
+
+        list[Foo]
+    `);
+  });
+});

package/test/uniontypeexpression.test.tsx

@@ -1,45 +1,44 @@
-import { code } from "@alloy-js/core";
+import { 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 { toSourceText } from "./utils.jsx";
+import {
+  assertFileContents,
+  toSourceText,
+  toSourceTextMultiple,
+} from "./utils.jsx";
 
 describe("UnionTypeExpression", () => {
   it("renders a Python union expression - 1 item", () => {
-    const elements = [code`int`];
     expect(
-      toSourceText([
-        <py.UnionTypeExpression>{elements}</py.UnionTypeExpression>,
-      ]),
+      toSourceText([<py.UnionTypeExpression children={["int"]} />]),
     ).toRenderTo("int");
   });
   it("renders a Python union expression - 2 items", () => {
-    const elements = [code`int`, code`str`];
     expect(
-      toSourceText([
-        <py.UnionTypeExpression>{elements}</py.UnionTypeExpression>,
-      ]),
+      toSourceText([<py.UnionTypeExpression children={["int", "str"]} />]),
     ).toRenderTo("int | str");
   });
   it("renders a Python union expression - N items", () => {
-    const elements = [
-      code`int`,
-      code`str`,
-      code`float`,
-      code`bool`,
-      code`list`,
-      code`dict`,
-      code`set`,
-      code`tuple`,
-      code`frozenset`,
-      code`bytes`,
-      code`bytearray`,
-      code`memoryview`,
-      code`complex`,
-    ];
     expect(
       toSourceText([
-        <py.UnionTypeExpression>{elements}</py.UnionTypeExpression>,
+        <py.UnionTypeExpression
+          children={[
+            "int",
+            "str",
+            "float",
+            "bool",
+            "list",
+            "dict",
+            "set",
+            "tuple",
+            "frozenset",
+            "bytes",
+            "bytearray",
+            "memoryview",
+            "complex",
+          ]}
+        />,
       ]),
     ).toRenderTo(d`
         (
@@ -58,20 +57,156 @@ describe("UnionTypeExpression", () => {
             | complex
         )`);
   });
-  it("renders a Python union expression - 2 items", () => {
-    const elements = [code`int`, code`str`];
+  it("renders a Python union expression - 2 items again", () => {
     expect(
-      toSourceText([
-        <py.UnionTypeExpression>{elements}</py.UnionTypeExpression>,
-      ]),
+      toSourceText([<py.UnionTypeExpression children={["int", "str"]} />]),
     ).toRenderTo("int | str");
   });
-  it("renders a Python union expression - 2 items with optional", () => {
-    const elements = [code`int`, code`str`];
+  it("renders a Python union expression - 2 items with None", () => {
     expect(
       toSourceText([
-        <py.UnionTypeExpression optional>{elements}</py.UnionTypeExpression>,
+        <py.UnionTypeExpression children={["int", "str", "None"]} />,
       ]),
     ).toRenderTo("int | str | None");
   });
+
+  it("renders a Python union with generic types", () => {
+    expect(
+      toSourceText([
+        <py.UnionTypeExpression
+          children={[
+            <py.TypeReference name="list" typeArgs={["int"]} />,
+            <py.TypeReference name="dict" typeArgs={["str", "int"]} />,
+          ]}
+        />,
+      ]),
+    ).toRenderTo("list[int] | dict[str, int]");
+  });
+
+  it("renders a Python type expression with references", () => {
+    const classRefkey = refkey();
+    const otherClassRefkey = refkey();
+
+    expect(
+      toSourceText([
+        <py.StatementList>
+          <py.ClassDeclaration
+            name="Bar"
+            refkey={classRefkey}
+          ></py.ClassDeclaration>
+          <py.ClassDeclaration
+            name="Foo"
+            refkey={otherClassRefkey}
+          ></py.ClassDeclaration>
+          <py.UnionTypeExpression
+            children={[
+              <py.Reference refkey={classRefkey} />,
+              <py.Reference refkey={otherClassRefkey} />,
+            ]}
+          />
+        </py.StatementList>,
+      ]),
+    ).toRenderTo(d`
+        class Bar:
+            pass
+
+        class Foo:
+            pass
+
+        Bar | Foo
+    `);
+  });
+
+  it("emits import for TypeReference with refkey and typeArgs across files", () => {
+    const classRefkey = refkey();
+    const res = toSourceTextMultiple([
+      <py.SourceFile path="defs.py">
+        <py.ClassDeclaration name="Bar" refkey={classRefkey} />
+      </py.SourceFile>,
+      <py.SourceFile path="use.py">
+        <py.StatementList>
+          <py.VariableDeclaration
+            name="v"
+            type={<py.TypeReference refkey={classRefkey} typeArgs={["T"]} />}
+          />
+        </py.StatementList>
+      </py.SourceFile>,
+    ]);
+    assertFileContents(res, {
+      "defs.py": `
+        class Bar:
+            pass
+
+      `,
+      "use.py": `
+        from defs import Bar
+
+        v: Bar[T] = None
+      `,
+    });
+  });
+});
+
+describe("TypeExpression in different scenarios", () => {
+  it("renders an UnionTypeExpression as a function type parameter and return type", () => {
+    const classRefkey = refkey();
+    const type = (
+      <py.UnionTypeExpression
+        children={["int", "str", <py.Reference refkey={classRefkey} />]}
+      />
+    );
+    expect(
+      toSourceText([
+        <py.ClassDeclaration
+          name="Foo"
+          refkey={classRefkey}
+        ></py.ClassDeclaration>,
+        <py.FunctionDeclaration
+          name="fooFunction"
+          parameters={[
+            {
+              name: "x",
+              type: type,
+            },
+          ]}
+          args={true}
+          kwargs={true}
+          returnType={type}
+        />,
+      ]),
+    ).toRenderTo(d`
+        class Foo:
+            pass
+
+
+        def foo_function(x: int | str | Foo, *args, **kwargs) -> int | str | Foo:
+            pass
+
+
+    `);
+  });
+  it("renders an UnionTypeExpression as a variable type", () => {
+    const classRefkey = refkey();
+    const type = (
+      <py.UnionTypeExpression
+        children={["int", "str", <py.Reference refkey={classRefkey} />]}
+      />
+    );
+    expect(
+      toSourceText([
+        <py.ClassDeclaration
+          name="Foo"
+          refkey={classRefkey}
+        ></py.ClassDeclaration>,
+        <py.VariableDeclaration name="fooVariable" type={type} />,
+      ]),
+    ).toRenderTo(d`
+        class Foo:
+            pass
+
+
+        foo_variable: int | str | Foo = None
+
+    `);
+  });
 });

package/test/variables.test.tsx

@@ -1,4 +1,4 @@
-import { code, namekey, refkey } from "@alloy-js/core";
+import { 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";
@@ -27,6 +27,17 @@ describe("Python Variable", () => {
     expect(res).toBe(`my_var: int = 42`);
   });
 
+  it("takes a namekey", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name={namekey("my-var")}
+        type="int"
+        initializer={42}
+      />,
+    ]);
+    expect(res).toBe(`my_var: int = 42`);
+  });
+
   it("declares a python variable without value", () => {
     const res = toSourceText([
       <py.VariableDeclaration name="myVar" type="int" omitNone />,
@@ -60,7 +71,7 @@ describe("Python Variable", () => {
     const res = toSourceText([
       <py.VariableDeclaration
         name="numbers"
-        type="list[int]"
+        type={<py.TypeReference name="list" typeArgs={["int"]} />}
         initializer={<py.Atom jsValue={[1, 2, 3]} />}
       />,
     ]);
@@ -107,13 +118,14 @@ describe("Python Variable", () => {
   });
 
   it("declares a python variable with an optional type", () => {
-    const elements = [code`int`];
-    const typing = (
-      <py.UnionTypeExpression optional>{elements}</py.UnionTypeExpression>
-    );
     const res = toSourceText([
       <py.StatementList>
-        <py.VariableDeclaration name="my_var" type={typing} />
+        <py.VariableDeclaration
+          name="my_var"
+          type={
+            <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
+          }
+        />
       </py.StatementList>,
     ]);
     expect(res).toBe(d`
@@ -121,13 +133,15 @@ describe("Python Variable", () => {
   });
 
   it("declares a python variable with an optional type omitting none", () => {
-    const elements = [code`int`];
-    const typing = (
-      <py.UnionTypeExpression optional>{elements}</py.UnionTypeExpression>
-    );
     const res = toSourceText([
       <py.StatementList>
-        <py.VariableDeclaration name="my_var" type={typing} omitNone />
+        <py.VariableDeclaration
+          name="my_var"
+          type={
+            <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
+          }
+          omitNone
+        />
       </py.StatementList>,
     ]);
     expect(res).toBe(d`
@@ -159,10 +173,7 @@ describe("Python Variable", () => {
         <py.ClassDeclaration name="MyClass" refkey={classKey} />
       </py.SourceFile>,
       <py.SourceFile path="usage.py">
-        <py.VariableDeclaration
-          name="my_var"
-          type={<py.Reference refkey={classKey} />}
-        />
+        <py.VariableDeclaration name="my_var" type={classKey} />
       </py.SourceFile>,
     ]);
     assertFileContents(res, {