@alloy-js/python 0.0.1

package/test/callsignatures.test.tsx

@@ -0,0 +1,256 @@
+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("Call Signature Parameters", () => {
+  it("renders simple function parameters", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters parameters={["a", "b"]} />,
+    ]);
+    expect(result).toRenderTo(d`
+      a, b
+    `);
+  });
+  it("renders ParameterDescriptor parameters", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters
+        parameters={[{ name: "a" }, { name: "b" }]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      a, b
+    `);
+  });
+  it("renders ParameterDescriptor parameters with types", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters
+        parameters={[
+          { name: "a", type: "int" },
+          { name: "b", type: "str" },
+        ]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      a: int, b: str
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters with types", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters
+        parameters={[
+          { name: "a", type: "int", optional: true },
+          { name: "b", type: "str", optional: true },
+        ]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      a: int = None, b: str = None
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters default", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters
+        parameters={[
+          { name: "a", default: 5 },
+          { name: "b", default: "hello" },
+        ]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      a=5, b="hello"
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters with types and default", () => {
+    const result = toSourceText([
+      <py.CallSignatureParameters
+        parameters={[
+          { name: "a", type: "int", optional: true, default: 5 },
+          { name: "b", type: "str", optional: true, default: "hello" },
+        ]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      a: int = 5, b: str = "hello"
+    `);
+  });
+});
+
+describe("Call Signature", () => {
+  it("renders a simple call signature", () => {
+    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", () => {
+    const result = toSourceText([
+      <py.CallSignature parameters={["a", "b"]} typeParameters={["T", "U"]} />,
+    ]);
+    expect(result).toRenderTo(d`
+      [T, U](a, b)
+    `);
+  });
+  it("renders a simple call signature with return type", () => {
+    const result = toSourceText([
+      <py.CallSignature parameters={["a", "b"]} returnType="int" />,
+    ]);
+    expect(result).toRenderTo(d`
+      (a, b) -> int
+    `);
+  });
+  it("renders a simple call signature for a class function", () => {
+    const result = toSourceText([
+      <py.CallSignature parameters={["a", "b"]} classFunction />,
+    ]);
+    expect(result).toRenderTo(d`
+      (cls, a, b)
+    `);
+  });
+  it("renders a simple call signature for an instance function", () => {
+    const result = toSourceText([
+      <py.CallSignature parameters={["a", "b"]} instanceFunction />,
+    ]);
+    expect(result).toRenderTo(d`
+      (self, 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", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={["a", "b"]}
+        instanceFunction
+        args
+        kwargs
+        returnType="int"
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      (self, a, b, *args, **kwargs) -> int
+    `);
+  });
+});
+
+describe("Call Signature - Parameter Descriptors", () => {
+  it("renders a call signature with parameter descriptors", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={[
+          { name: "a", type: "int" },
+          { name: "b", type: "str" },
+        ]}
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str)
+    `);
+  });
+  it("renders a call signature with parameter descriptors, args and kwargs", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={[
+          { name: "a", type: "int" },
+          { name: "b", type: "str" },
+        ]}
+        args
+        kwargs
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str, *args, **kwargs)
+    `);
+  });
+  it("renders a call signature with parameter descriptors and return type", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={[
+          { name: "a", type: "int" },
+          { name: "b", type: "str" },
+        ]}
+        returnType="int"
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str) -> int
+    `);
+  });
+  it("renders a call signature with parameter descriptors for a class function", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={[
+          { 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)
+    `);
+  });
+  it("renders a call signature with all", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        parameters={[
+          { 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
+    `);
+  });
+  it("renders a more complex call signature with parameter descriptors", () => {
+    const result = toSourceText([
+      <py.CallSignature
+        typeParameters={["T", "U"]}
+        parameters={[
+          { name: "a", type: "int" },
+          { name: "b", type: "str", default: "default_value" },
+        ]}
+        returnType="int"
+      />,
+    ]);
+    expect(result).toRenderTo(d`
+      [T, U](a: int, b: str = "default_value") -> int
+    `);
+  });
+});

package/test/classdeclarations.test.tsx

@@ -0,0 +1,320 @@
+import { memberRefkey, 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 {
+  assertFileContents,
+  toSourceText,
+  toSourceTextMultiple,
+} from "./utils.jsx";
+
+describe("Python Class", () => {
+  it("renders a class with no body as 'pass'", () => {
+    const result = toSourceText([<py.ClassDeclaration name="Foo" />]);
+    expect(result).toRenderTo(d`
+      class Foo:
+          pass
+
+
+    `);
+  });
+
+  it("renders a class with a body", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="Bar">print('hi')</py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      class Bar:
+          print('hi')
+
+
+    `);
+  });
+
+  it("renders a class with base classes", () => {
+    const result = toSourceText([
+      <py.StatementList>
+        <py.ClassDeclaration name="Base1" />
+        <py.ClassDeclaration name="Base2" />
+        <py.ClassDeclaration
+          name="Baz"
+          bases={[refkey("Base1"), refkey("Base2")]}
+        />
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      class Base1:
+          pass
+
+      class Base2:
+          pass
+
+      class Baz(Base1, Base2):
+          pass
+
+        
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("renders a class with base classes and body", () => {
+    const result = toSourceText([
+      <py.ClassDeclaration name="Qux" bases={["Base"]}>
+        print('hello')
+      </py.ClassDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      class Qux(Base):
+          print('hello')
+
+
+    `);
+  });
+
+  it("renders classes across modules with inheritance", () => {
+    const result = toSourceTextMultiple([
+      <py.SourceFile path="mod1.py">
+        <py.ClassDeclaration name="A" />
+      </py.SourceFile>,
+      <py.SourceFile path="folder/mod2.py">
+        <py.ClassDeclaration name="B" bases={[refkey("A")]} />
+      </py.SourceFile>,
+      <py.SourceFile path="mod3.py">
+        <py.ClassDeclaration name="C" bases={[refkey("B")]} />
+      </py.SourceFile>,
+    ]);
+    const mod1Expected = d`
+      class A:
+          pass
+
+
+    `;
+    const mod2Expected = d`
+      from mod1 import A
+
+      class B(A):
+          pass
+
+
+    `;
+    const mod3Expected = d`
+      from folder.mod2 import B
+
+      class C(B):
+          pass
+
+
+    `;
+    assertFileContents(result, { "mod1.py": mod1Expected });
+    assertFileContents(result, { "folder/mod2.py": mod2Expected });
+    assertFileContents(result, { "mod3.py": mod3Expected });
+  });
+
+  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="B">
+          <py.StatementList>
+            <py.VariableDeclaration name="bar" type={refkey("A")} omitNone />
+            <py.VariableDeclaration name="foo" type="str" omitNone />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      class A:
+          pass
+
+      class B:
+          bar: A
+          foo: str
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("renders a class with class variables like foo: str, and another identical class", () => {
+    const result = toSourceText([
+      <py.StatementList>
+        <py.ClassDeclaration name="A">
+          <py.StatementList>
+            <py.VariableDeclaration name="foo" type="str" omitNone />
+          </py.StatementList>
+        </py.ClassDeclaration>
+        <py.ClassDeclaration name="B">
+          <py.StatementList>
+            <py.VariableDeclaration name="foo" type="str" omitNone />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      class A:
+          foo: str
+
+      class B:
+          foo: str
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});
+
+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.StatementList>
+            <py.VariableDeclaration name="just_name" />
+            <py.VariableDeclaration name="name_and_type" type="number" />
+            <py.VariableDeclaration
+              name="name_type_and_value"
+              type="number"
+              initializer={12}
+            />
+            <py.VariableDeclaration name="class_based" type={refkey("Base")} />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      class Base:
+          pass
+
+      class A:
+          just_name = None
+          name_and_type: number = None
+          name_type_and_value: number = 12
+          class_based: Base = None
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("correctly access members of its type", () => {
+    const classRk = refkey();
+    const classMemberRk = refkey();
+    const classMethodRk = refkey();
+    const v1Rk = refkey();
+
+    const res = toSourceTextMultiple([
+      <py.SourceFile path="inst.py">
+        <py.StatementList>
+          <py.VariableDeclaration
+            name="one"
+            refkey={v1Rk}
+            type={classRk}
+            initializer={
+              <py.MemberExpression>
+                <py.MemberExpression.Part refkey={classRk} />
+                <py.MemberExpression.Part args />
+              </py.MemberExpression>
+            }
+          />
+          <>{memberRefkey(v1Rk, classMemberRk)}</>
+          <>{memberRefkey(v1Rk, classMethodRk)}()</>
+        </py.StatementList>
+      </py.SourceFile>,
+      <py.SourceFile path="decl.py">
+        <py.ClassDeclaration name="Bar" refkey={classRk}>
+          <py.StatementList>
+            <py.VariableDeclaration
+              name="instanceProp"
+              refkey={classMemberRk}
+              initializer={42}
+              instanceVariable={true}
+            />
+            <py.FunctionDeclaration
+              name="instanceMethod"
+              instanceFunction={true}
+              refkey={classMethodRk}
+              returnType="int"
+            />
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </py.SourceFile>,
+    ]);
+
+    assertFileContents(res, {
+      "inst.py": `
+        from decl import Bar
+
+        one: Bar = Bar()
+        one.instance_prop
+        one.instance_method()
+      `,
+      "decl.py": `
+        class Bar:
+            instance_prop = 42
+            def instance_method(self) -> int:
+                pass
+
+
+      `,
+    });
+  });
+});
+
+describe("Python Class - FunctionDeclaration", () => {
+  it("renders a class with class fields and method", () => {
+    const result = toSourceText([
+      <>
+        <py.ClassDeclaration name="MyClass" bases={["BaseClass"]}>
+          <py.StatementList>
+            <py.VariableDeclaration name="a" type="int" />
+            <py.VariableDeclaration name="b" type="int" />
+            <py.FunctionDeclaration
+              name="my_method"
+              parameters={[
+                { name: "a", type: "int" },
+                { name: "b", type: "int" },
+              ]}
+              returnType="int"
+              instanceFunction={true}
+            >
+              return a + b
+            </py.FunctionDeclaration>
+            <py.FunctionDeclaration
+              name="my_class_method"
+              instanceFunction={false}
+              classFunction={true}
+              returnType="int"
+            >
+              pass
+            </py.FunctionDeclaration>
+            <py.FunctionDeclaration
+              name="my_standalone_function"
+              instanceFunction={false}
+              returnType="int"
+            >
+              pass
+            </py.FunctionDeclaration>
+          </py.StatementList>
+        </py.ClassDeclaration>
+      </>,
+    ]);
+    const expected = d`
+      class MyClass(BaseClass):
+          a: int = None
+          b: int = None
+          def my_method(self, a: int, b: int) -> int:
+              return a + b
+
+          def my_class_method(cls) -> int:
+              pass
+
+          def my_standalone_function() -> int:
+              pass
+
+
+          
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});