@alloy-js/python 0.0.1

package/test/functiondeclaration.test.tsx

@@ -0,0 +1,327 @@
+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 {
+  assertFileContents,
+  toSourceText,
+  toSourceTextMultiple,
+} from "./utils.js";
+
+describe("Function Declaration", () => {
+  it("renders a function with no body as 'pass'", () => {
+    const result = toSourceText([
+      <py.FunctionDeclaration name="foo" instanceFunction={true} />,
+    ]);
+    expect(result).toRenderTo(d`
+      def foo(self):
+          pass
+
+        
+    `);
+  });
+
+  it("renders a function with no body as 'pass' with return type", () => {
+    const result = toSourceText([
+      <py.FunctionDeclaration name="foo" returnType="int" />,
+    ]);
+    expect(result).toRenderTo(d`
+      def foo() -> int:
+          pass
+
+
+    `);
+  });
+
+  it("renders a function that calls another function", () => {
+    const refkeyFoo = refkey();
+    const result = toSourceText([
+      <py.StatementList>
+        <py.FunctionDeclaration
+          name="foo"
+          instanceFunction={true}
+          returnType="int"
+          refkey={refkeyFoo}
+        />
+        <py.FunctionDeclaration
+          name="bar"
+          instanceFunction={true}
+          returnType="int"
+        >
+          <py.VariableDeclaration
+            name="result"
+            type="int"
+            initializer={
+              <py.FunctionCallExpression target={refkeyFoo} args={[]} />
+            }
+          />
+        </py.FunctionDeclaration>
+      </py.StatementList>,
+    ]);
+    expect(result).toRenderTo(d`
+      def foo(self) -> int:
+          pass
+
+      def bar(self) -> int:
+          result: int = foo()
+
+
+    `);
+  });
+
+  it("renders an instance function with a body", () => {
+    const result = toSourceText([
+      <py.FunctionDeclaration name="bar" instanceFunction={true}>
+        print('hi')
+      </py.FunctionDeclaration>,
+    ]);
+    expect(result).toRenderTo(d`
+      def bar(self):
+          print('hi')
+
+
+    `);
+  });
+
+  it("renders a function with parameters", () => {
+    const result = toSourceText([
+      <py.FunctionDeclaration
+        name="baz"
+        parameters={[
+          { name: "x", type: "int" },
+          { name: "y", default: 0 },
+          { name: "z", type: "int", default: 42 },
+        ]}
+        args={true}
+        kwargs={true}
+      >
+        print(x, y)
+      </py.FunctionDeclaration>,
+    ]);
+    expect(result).toRenderTo(
+      d`
+        def baz(x: int, y=0, z: int = 42, *args, **kwargs):
+            print(x, y)
+
+
+      `,
+    );
+  });
+
+  it("renders an __init__ function with no body as 'pass'", () => {
+    const result = toSourceText([
+      <py.InitFunctionDeclaration parameters={[{ name: "x" }]} />,
+    ]);
+    expect(result).toRenderTo(d`
+      def __init__(self, x):
+          pass
+
+        
+    `);
+  });
+
+  it("can be an async function", () => {
+    expect(toSourceText([<py.FunctionDeclaration async name="foo" />])).toBe(d`
+      async def foo():
+          pass
+
+    `);
+  });
+
+  it("can be an async function with returnType", () => {
+    expect(
+      toSourceText([
+        <py.FunctionDeclaration async name="foo" returnType="Foo" />,
+      ]),
+    ).toBe(d`
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+
+  it("can be an async function with returnType element with Reference", () => {
+    expect(
+      toSourceText([
+        <py.StatementList>
+          <py.ClassDeclaration name="Foo" />
+          <py.FunctionDeclaration
+            async
+            name="foo"
+            returnType={<py.Reference refkey={refkey("Foo")} />}
+          />
+        </py.StatementList>,
+      ]),
+    ).toBe(d`
+      class Foo:
+          pass
+
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+
+  it("supports parameters", () => {
+    const decl = (
+      <py.FunctionDeclaration name="foo" parameters={["a", "b"]}>
+        return a + b
+      </py.FunctionDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      def foo(a, b):
+          return a + b
+
+    `);
+  });
+  it("supports type parameters", () => {
+    const decl = (
+      <py.FunctionDeclaration
+        name="foo"
+        parameters={["a", "b"]}
+        typeParameters={["T", "U"]}
+      >
+        return a + b
+      </py.FunctionDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      def foo[T, U](a, b):
+          return a + b
+
+    `);
+  });
+  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>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      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>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      def __init__(self, x: int):
+          self.attribute = "value"
+
+    `);
+  });
+
+  it("renders nested functions", () => {
+    const parameters = [{ name: "x", type: "int" }];
+    const parameters_nested = [{ name: "y", type: "int" }];
+    const parameters_nested_nested = [{ name: "z", type: "int" }];
+    const fooRef = refkey();
+    const barRef = refkey();
+    const foobarRef = refkey();
+    const decl = (
+      <py.FunctionDeclaration
+        name="foo"
+        parameters={parameters}
+        refkey={fooRef}
+      >
+        <py.FunctionDeclaration
+          name="bar"
+          parameters={parameters_nested}
+          refkey={barRef}
+        >
+          <py.FunctionDeclaration
+            name="foobar"
+            parameters={parameters_nested_nested}
+            refkey={foobarRef}
+          >
+            return z * 2
+          </py.FunctionDeclaration>
+          return{" "}
+          <py.FunctionCallExpression
+            target={foobarRef}
+            args={[<py.Atom jsValue={2} />]}
+          />
+        </py.FunctionDeclaration>
+        return{" "}
+        <py.FunctionCallExpression
+          target={barRef}
+          args={[<py.Atom jsValue={3} />]}
+        />
+      </py.FunctionDeclaration>
+    );
+
+    expect(toSourceText([decl])).toBe(d`
+      def foo(x: int):
+          def bar(y: int):
+              def foobar(z: int):
+                  return z * 2
+              return foobar(2)
+          return bar(3)
+
+    `);
+  });
+  it("renders complex typing structure", () => {
+    const res = toSourceTextMultiple([
+      <py.SourceFile path="mod1.py">
+        <py.ClassDeclaration name="Foo" />
+      </py.SourceFile>,
+      <py.SourceFile path="mod2.py">
+        <py.ClassDeclaration name="A" />
+        <py.ClassDeclaration name="B" />
+      </py.SourceFile>,
+      <py.SourceFile path="usage.py">
+        <py.FunctionDeclaration
+          async
+          name="foo"
+          parameters={[
+            { name: "x", type: <py.Reference refkey={refkey("A")} /> },
+            { name: "y", type: <py.Reference refkey={refkey("B")} /> },
+          ]}
+          args={true}
+          kwargs={true}
+          returnType={<py.Reference refkey={refkey("Foo")} />}
+        />
+      </py.SourceFile>,
+    ]);
+
+    assertFileContents(res, {
+      "mod1.py": `
+            class Foo:
+                pass
+
+            `,
+      "mod2.py": `
+            class A:
+                pass
+
+
+            class B:
+                pass
+
+            `,
+      "usage.py": `
+            from mod1 import Foo
+            from mod2 import A
+            from mod2 import B
+
+            async def foo(x: A, y: B, *args, **kwargs) -> Foo:
+                pass
+
+            `,
+    });
+  });
+});

package/test/imports.test.tsx

@@ -0,0 +1,214 @@
+import { refkey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { ImportStatement } from "../src/components/ImportStatement.jsx";
+import * as py from "../src/index.js";
+import { createPythonSymbol } from "../src/symbol-creation.js";
+import { ImportedSymbol, ImportRecords } from "../src/symbols/index.js";
+import {
+  assertFileContents,
+  createPythonModuleScope,
+  toSourceText,
+  toSourceTextMultiple,
+} from "./utils.jsx";
+
+describe("ImportStatement", () => {
+  it("renders module import", () => {
+    const result = toSourceText([<ImportStatement path="sys" />]);
+    const expected = `import sys`;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("renders named imports", () => {
+    const sqrtSymbol = createPythonSymbol("sqrt", {
+      binder: undefined,
+      scope: undefined,
+    });
+    const piSymbol = createPythonSymbol("pi", {
+      binder: undefined,
+      scope: undefined,
+    });
+    const symbols = new Set<ImportedSymbol>([
+      new ImportedSymbol(sqrtSymbol, sqrtSymbol),
+      new ImportedSymbol(piSymbol, piSymbol),
+    ]);
+    const result = toSourceText([
+      <ImportStatement path="math" symbols={symbols} />,
+    ]);
+    const expected = `from math import pi, sqrt`;
+    expect(result).toRenderTo(expected);
+  });
+});
+
+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 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 requestsSymbols = new Set<ImportedSymbol>([
+      new ImportedSymbol(getSymbol, getSymbol),
+    ]);
+    const records = new ImportRecords([
+      [pythonModuleScope, { symbols: mathSymbols }],
+      [requestsScope, { symbols: requestsSymbols }],
+      [sysModuleScope, { symbols: new Set<ImportedSymbol>() }],
+    ]);
+
+    const result = toSourceText([<py.ImportStatements records={records} />]);
+    const expected = `
+    from math import pi
+    from math import sqrt
+    from requests import get
+    import sys`;
+    expect(result).toRenderTo(expected);
+  });
+  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 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 requestsSymbols = new Set<ImportedSymbol>([
+      new ImportedSymbol(getSymbol, getSymbol),
+      new ImportedSymbol(postSymbol, postSymbol),
+    ]);
+    const records = new ImportRecords([
+      [pythonModuleScope, { symbols: mathSymbols }],
+      [requestsScope, { symbols: requestsSymbols }],
+    ]);
+
+    const result = toSourceText([
+      <py.ImportStatements
+        records={records}
+        joinImportsFromSameModule={true}
+      />,
+    ]);
+    const expected = `
+    from math import pi, sqrt
+    from requests import get, post`;
+    expect(result).toRenderTo(expected);
+  });
+});
+
+describe("Imports being used", () => {
+  it("works with importing the same name many times from different files with the default name conflict resolver", () => {
+    const rk1 = refkey();
+    const rk2 = refkey();
+    const rk3 = refkey();
+    const result = toSourceTextMultiple([
+      <py.SourceFile path="test_1.py">
+        <py.VariableDeclaration name="conflict" refkey={rk1} />
+      </py.SourceFile>,
+      <py.SourceFile path="test_3.py">
+        <py.VariableDeclaration name="conflict" refkey={rk3} />
+      </py.SourceFile>,
+      <py.SourceFile path="test_2.py">
+        <py.VariableDeclaration name="conflict" refkey={rk2} />
+      </py.SourceFile>,
+      <py.SourceFile path="test.py">
+        <py.StatementList>
+          <py.VariableDeclaration name="one" initializer={rk1} />
+          <py.VariableDeclaration name="three" initializer={rk3} />
+          <py.VariableDeclaration name="two" initializer={rk2} />
+        </py.StatementList>
+      </py.SourceFile>,
+    ]);
+    assertFileContents(result, {
+      "test.py": `
+        from test_1 import conflict
+        from test_2 import conflict as conflict_3_test_2
+        from test_3 import conflict as conflict_2_test_3
+
+        one = conflict
+        three = conflict_2_test_3
+        two = conflict_3_test_2
+      `,
+    });
+  });
+  it("works with importing the same name many times from different files and with the correct order", () => {
+    const rk1 = refkey();
+    const rk2 = refkey();
+    const rk3 = refkey();
+    const rk4 = refkey();
+    const rk5 = refkey();
+    const rk6 = refkey();
+    const rk7 = refkey();
+    const result = toSourceTextMultiple([
+      <py.SourceFile path="test_1.py">
+        <py.VariableDeclaration name="conflict" refkey={rk1} />
+        <py.VariableDeclaration name="something_else" refkey={rk4} />
+      </py.SourceFile>,
+      <py.SourceFile path="test_2.py">
+        <py.VariableDeclaration name="conflict" refkey={rk2} />
+        <py.VariableDeclaration name="something" refkey={rk6} />
+        <py.VariableDeclaration name="something_else" refkey={rk5} />
+      </py.SourceFile>,
+      <py.SourceFile path="test_3.py">
+        <py.VariableDeclaration name="conflict" refkey={rk3} />
+        <py.VariableDeclaration name="something" refkey={rk7} />
+      </py.SourceFile>,
+      <py.SourceFile path="test.py">
+        <py.StatementList>
+          <py.VariableDeclaration name="one" initializer={rk1} />
+          <py.VariableDeclaration name="two" initializer={rk2} />
+          <py.VariableDeclaration name="three" initializer={rk3} />
+          <py.VariableDeclaration name="something_else" initializer={rk4} />
+          <py.VariableDeclaration name="something_else_two" initializer={rk5} />
+          <py.VariableDeclaration name="something" initializer={rk6} />
+          <py.VariableDeclaration name="something_two" initializer={rk7} />
+        </py.StatementList>
+      </py.SourceFile>,
+    ]);
+    assertFileContents(result, {
+      "test.py": `
+        from test_1 import conflict
+        from test_1 import something_else as something_else_2_test_1
+        from test_2 import conflict as conflict_2_test_2
+        from test_2 import something as something_2_test_2
+        from test_2 import something_else as something_else_3_test_2
+        from test_3 import conflict as conflict_3_test_3
+        from test_3 import something as something_3_test_3
+
+        one = conflict
+        two = conflict_2_test_2
+        three = conflict_3_test_3
+        something_else = something_else_2_test_1
+        something_else_two = something_else_3_test_2
+        something = something_2_test_2
+        something_two = something_3_test_3
+      `,
+    });
+  });
+});