@alloy-js/python 0.0.1

package/test/classinstantiations.test.tsx

@@ -0,0 +1,159 @@
+import { refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { createModule } from "../src/create-module.js";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.jsx";
+
+it("declaration of class instance with variables", () => {
+  // Creating the reference separately so the naming policy doesn't interfere
+  const classRef = refkey();
+  const result = toSourceText([
+    <py.StatementList>
+      <py.ClassDeclaration name="one-class" refkey={classRef} />
+      <py.ClassInstantiation
+        target={classRef}
+        args={[
+          <py.Atom jsValue={"A name"} />,
+          <py.Atom jsValue={42} />,
+          <py.Atom jsValue={true} />,
+        ]}
+      />
+    </py.StatementList>,
+  ]);
+  const expected = d`
+    class OneClass:
+        pass
+
+    OneClass("A name", 42, True)
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("correct resolving of external module", () => {
+  const requestsLib = createModule({
+    name: "requests",
+    descriptor: {
+      models: ["Request"],
+    },
+  });
+  const result = toSourceText(
+    [
+      <py.StatementList>
+        <py.ClassInstantiation target={requestsLib["models"].Request} />
+      </py.StatementList>,
+    ],
+    { externals: [requestsLib] },
+  );
+  const expected = d`
+    from requests.models import Request
+
+    Request()
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("Class instantiation without a reference", () => {
+  const result = toSourceText([
+    <py.StatementList>
+      <py.ClassInstantiation
+        target={"ExampleClass"}
+        args={[
+          <py.Atom jsValue={"A name"} />,
+          <py.Atom jsValue={42} />,
+          <py.Atom jsValue={true} />,
+        ]}
+      />
+    </py.StatementList>,
+  ]);
+  const expected = d`
+    ExampleClass("A name", 42, True)
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("Class instantiation without a reference and with call statement vars", () => {
+  const result = toSourceText([
+    <py.StatementList>
+      <py.ClassInstantiation
+        target={"ExampleClass"}
+        args={[
+          <py.VariableDeclaration
+            name="name"
+            initializer={"A name"}
+            callStatementVar
+          />,
+          <py.VariableDeclaration
+            name="number"
+            initializer={42}
+            callStatementVar
+          />,
+          <py.VariableDeclaration
+            name="flag"
+            initializer={true}
+            callStatementVar
+          />,
+        ]}
+      />
+    </py.StatementList>,
+  ]);
+  const expected = d`
+    ExampleClass(name="A name", number=42, flag=True)
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("Class instantiation without a reference mixing unnamed and named vars", () => {
+  const result = toSourceText([
+    <py.StatementList>
+      <py.ClassInstantiation
+        target={"ExampleClass"}
+        args={[
+          <py.Atom jsValue={"A name"} />,
+          <py.VariableDeclaration
+            name="number"
+            initializer={42}
+            callStatementVar
+          />,
+          <py.VariableDeclaration
+            name="flag"
+            initializer={true}
+            callStatementVar
+          />,
+        ]}
+      />
+    </py.StatementList>,
+  ]);
+  const expected = d`
+    ExampleClass("A name", number=42, flag=True)
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("incorrect Class instantiation works", () => {
+  const result = toSourceText([
+    <py.ClassInstantiation
+      target="MyClass"
+      args={[
+        <py.ClassDeclaration name="NestedClass" />,
+        <py.FunctionDeclaration name="myFunc" />,
+        <py.StatementList>
+          <py.VariableDeclaration name="x" />
+        </py.StatementList>,
+      ]}
+    />,
+  ]);
+
+  const expected = d`
+    MyClass(
+        class NestedClass:
+            pass
+        ,
+        def my_func():
+            pass
+        ,
+        x = None
+    )
+  `;
+  expect(result).toRenderTo(expected);
+});

package/test/enums.test.tsx

@@ -0,0 +1,203 @@
+import { refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { enumModule } from "../src/builtins/python.js";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.jsx";
+
+describe("Python Enum", () => {
+  it("classic enum with explicit values", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Color"
+          baseType="IntEnum"
+          members={[
+            { name: "RED", value: "1" },
+            { name: "GREEN", value: "2" },
+            { name: "BLUE", value: "3" },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import IntEnum
+
+      class Color(IntEnum):
+          RED = 1
+          GREEN = 2
+          BLUE = 3
+
+        
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("classic enum with jsValues", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Color"
+          baseType="IntEnum"
+          members={[
+            { name: "RED", jsValue: "1" },
+            { name: "GREEN", jsValue: 2 },
+            { name: "BLUE", jsValue: "3" },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import IntEnum
+
+      class Color(IntEnum):
+          RED = "1"
+          GREEN = 2
+          BLUE = "3"
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("classic enum with a refkey as jsValue", () => {
+    const result = toSourceText(
+      [
+        <py.StatementList>
+          <py.ClassDeclaration name="Dog" />
+          <py.ClassDeclaration name="Cat" />
+          <py.EnumDeclaration
+            name="Animal"
+            baseType="Enum"
+            members={[
+              { name: "DOG", value: refkey("Dog") },
+              { name: "CAT", value: refkey("Cat") },
+            ]}
+          />
+        </py.StatementList>,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import Enum
+
+      class Dog:
+          pass
+
+      class Cat:
+          pass
+
+      class Animal(Enum):
+          DOG = Dog
+          CAT = Cat
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("enum with auto() values", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Animal"
+          style="auto"
+          members={[{ name: "DOG" }, { name: "CAT" }, { name: "RABBIT" }]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import auto
+      from enum import Enum
+
+      class Animal(Enum):
+          DOG = auto()
+          CAT = auto()
+          RABBIT = auto()
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("enum with mixed manual and auto() values", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Permission"
+          baseType="Flag"
+          style="auto"
+          members={[
+            { name: "READ", value: 1 },
+            { name: "WRITE" },
+            { name: "EXECUTE" },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+
+    const expected = d`
+      from enum import auto
+      from enum import Flag
+
+      class Permission(Flag):
+          READ = 1
+          WRITE = auto()
+          EXECUTE = auto()
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("functional enum with list", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Direction"
+          style="functional"
+          members={[
+            { name: "NORTH" },
+            { name: "SOUTH" },
+            { name: "EAST" },
+            { name: "WEST" },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import Enum
+
+      Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("functional enum with mapping", () => {
+    const result = toSourceText(
+      [
+        <py.EnumDeclaration
+          name="Priority"
+          style="functional"
+          members={[
+            { name: "HIGH", value: 1 },
+            { name: "MEDIUM", value: 2 },
+            { name: "LOW", value: 3 },
+          ]}
+        />,
+      ],
+      { externals: [enumModule] },
+    );
+    const expected = d`
+      from enum import Enum
+
+      Priority = Enum('Priority', {'HIGH' : 1, 'MEDIUM' : 2, 'LOW' : 3})
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});

package/test/externals.test.tsx

@@ -0,0 +1,190 @@
+import { code, refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { createModule } from "../src/index.js";
+import { toSourceText } from "./utils.js";
+
+it("uses import from external library", () => {
+  const requestsLib = createModule({
+    name: "requests",
+    descriptor: {
+      ".": ["get", "post"],
+      models: ["Response", "Request"],
+      "models.anothermodule": ["something"],
+    },
+  });
+  const result = toSourceText(
+    [
+      <py.StatementList>
+        {requestsLib["."].get}
+        {requestsLib["."].post}
+        {requestsLib["models"].Request}
+        {requestsLib["models"].Response}
+        {requestsLib["models.anothermodule"].something}
+      </py.StatementList>,
+    ],
+    { externals: [requestsLib] },
+  );
+  const expected = d`
+    from requests import get
+    from requests import post
+    from requests.models import Request
+    from requests.models import Response
+    from requests.models.anothermodule import something
+
+    get
+    post
+    Request
+    Response
+    something
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("uses import from external library in multiple functions", () => {
+  const functionDeclarations = [
+    <py.FunctionDeclaration
+      name={"getUser"}
+      parameters={[{ name: "userId", type: "int" }]}
+      returnType={py.requestsModule["models"]["Response"]}
+      instanceFunction={true}
+    >
+      <py.StatementList>
+        <py.VariableDeclaration
+          name="response"
+          initializer={
+            <py.FunctionCallExpression
+              target={py.requestsModule["."]["get"]}
+              args={[1]}
+            />
+          }
+        />
+        {code`
+          return response.json()
+        `}
+      </py.StatementList>
+    </py.FunctionDeclaration>,
+    <py.FunctionDeclaration
+      name={"createUser"}
+      parameters={[{ name: "userName", type: "string" }]}
+      returnType={py.requestsModule["models"]["Response"]}
+      instanceFunction={true}
+    >
+      <py.StatementList>
+        <py.VariableDeclaration
+          name="response"
+          initializer={
+            <py.FunctionCallExpression
+              target={py.requestsModule["."]["post"]}
+              args={[1]}
+            />
+          }
+        />
+        {code`
+          return response.json()
+        `}
+      </py.StatementList>
+    </py.FunctionDeclaration>,
+  ];
+
+  const result = toSourceText(functionDeclarations, {
+    externals: [py.requestsModule],
+  });
+  const expected = d`
+    from requests import get
+    from requests import post
+    from requests.models import Response
+
+    def get_user(self, user_id: int) -> Response:
+        response = get(1)
+        return response.json()
+
+
+    def create_user(self, user_name: string) -> Response:
+        response = post(1)
+        return response.json()
+
+
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("uses import from external library in multiple class methods", () => {
+  const functionDeclarations = [
+    <py.ClassDeclaration name="UserClient">
+      <py.StatementList>
+        <py.VariableDeclaration
+          name="some_var"
+          initializer={12}
+          instanceVariable
+        />
+        <py.FunctionDeclaration
+          name={"getUser"}
+          parameters={[{ name: "userId", type: "int" }]}
+          returnType={py.requestsModule["models"]["Response"]}
+          instanceFunction={true}
+        >
+          <py.StatementList>
+            <py.VariableDeclaration
+              name="response"
+              initializer={
+                <py.FunctionCallExpression
+                  target={py.requestsModule["."]["get"]}
+                  args={[refkey("some_var")]}
+                />
+              }
+            />
+            {code`
+              return response.json()
+            `}
+          </py.StatementList>
+        </py.FunctionDeclaration>
+        <py.FunctionDeclaration
+          name={"createUser"}
+          parameters={[{ name: "userName", type: "string" }]}
+          returnType={py.requestsModule["models"]["Response"]}
+          instanceFunction={true}
+        >
+          <py.StatementList>
+            <py.VariableDeclaration
+              name="response"
+              initializer={
+                <py.FunctionCallExpression
+                  target={py.requestsModule["."]["post"]}
+                  args={[refkey("some_var")]}
+                />
+              }
+            />
+            {code`
+              return response.json()
+            `}
+          </py.StatementList>
+        </py.FunctionDeclaration>
+      </py.StatementList>
+    </py.ClassDeclaration>,
+  ];
+
+  const result = toSourceText(functionDeclarations, {
+    externals: [py.requestsModule],
+  });
+  const expected = d`
+    from requests import get
+    from requests import post
+    from requests.models import Response
+
+    class UserClient:
+        some_var = 12
+        def get_user(self, user_id: int) -> Response:
+            response = get(self.some_var)
+            return response.json()
+
+        def create_user(self, user_name: string) -> Response:
+            response = post(self.some_var)
+            return response.json()
+
+
+
+  `;
+  expect(result).toRenderTo(expected);
+});

package/test/functioncallexpressions.test.tsx

@@ -0,0 +1,145 @@
+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";
+
+describe("FunctionCallExpression", () => {
+  it("renders", () => {
+    const result = toSourceText([<py.FunctionCallExpression target="foo" />]);
+    expect(result).toRenderTo(d`
+      foo()
+    `);
+  });
+  it("renders with args", () => {
+    const result = toSourceText([
+      <py.FunctionCallExpression target="foo" args={["a", "b"]} />,
+    ]);
+    expect(result).toRenderTo(d`
+      foo(a, b)
+    `);
+  });
+
+  it("function call with variables", () => {
+    // Creating the reference separately so the naming policy doesn't interfere
+    const methodRef = refkey();
+    const result = toSourceText([
+      <py.StatementList>
+        <py.FunctionDeclaration name="runFunc" refkey={methodRef} />
+        <py.FunctionCallExpression
+          target={methodRef}
+          args={[
+            <py.Atom jsValue={"A name"} />,
+            <py.Atom jsValue={42} />,
+            <py.Atom jsValue={true} />,
+          ]}
+        />
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      def run_func():
+          pass
+      
+      run_func("A name", 42, True)
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("function call with variables and assignment", () => {
+    // Creating the reference separately so the naming policy doesn't interfere
+    const methodRef = refkey();
+    const result = toSourceText([
+      <py.StatementList>
+        <py.FunctionDeclaration
+          name="runFunc"
+          returnType="str"
+          refkey={methodRef}
+          parameters={[
+            { name: "name", type: "str" },
+            { name: "number", type: "int" },
+            { name: "flag", type: "bool" },
+          ]}
+        />
+        <py.VariableDeclaration
+          name="result"
+          type="str"
+          initializer={
+            <py.FunctionCallExpression
+              target={methodRef}
+              args={[
+                <py.Atom jsValue={"A name"} />,
+                <py.Atom jsValue={42} />,
+                <py.Atom jsValue={true} />,
+              ]}
+            />
+          }
+        />
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      def run_func(name: str, number: int, flag: bool) -> str:
+          pass
+      
+      result: str = run_func("A name", 42, True)
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("Method call without a reference and with call statement vars", () => {
+    const result = toSourceText([
+      <py.StatementList>
+        <py.FunctionCallExpression
+          target={"example_method"}
+          args={[
+            <py.VariableDeclaration
+              name="name"
+              initializer={"A name"}
+              callStatementVar
+            />,
+            <py.VariableDeclaration
+              name="number"
+              initializer={42}
+              callStatementVar
+            />,
+            <py.VariableDeclaration
+              name="flag"
+              initializer={true}
+              callStatementVar
+            />,
+          ]}
+        />
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      example_method(name="A name", number=42, flag=True)
+    `;
+    expect(result).toRenderTo(expected);
+  });
+
+  it("Method call without a reference mixing unnamed and named vars", () => {
+    const result = toSourceText([
+      <py.StatementList>
+        <py.FunctionCallExpression
+          target={"example_method"}
+          args={[
+            <py.Atom jsValue={"A name"} />,
+            <py.VariableDeclaration
+              name="number"
+              initializer={42}
+              callStatementVar
+            />,
+            <py.VariableDeclaration
+              name="flag"
+              initializer={true}
+              callStatementVar
+            />,
+          ]}
+        />
+      </py.StatementList>,
+    ]);
+    const expected = d`
+      example_method("A name", number=42, flag=True)
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});