@alloy-js/python 0.0.1

package/test/sourcefiles.test.tsx

@@ -0,0 +1,131 @@
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.jsx";
+
+/**
+ * toSourceText wraps the children in a SourceFile component
+ * and renders it to a string.
+ */
+it("renders an empty source file", () => {
+  const result = toSourceText([]);
+  const expected = d`
+
+
+  `;
+  expect(result).toRenderTo(expected);
+});
+
+it("correct formatting of source file", () => {
+  const result = toSourceText([
+    <py.ClassDeclaration name="someClass">
+      <py.StatementList>
+        <py.FunctionDeclaration name="someMethod" returnType="str">
+          <py.StatementList>
+            <py.VariableDeclaration
+              name="x"
+              type="int"
+              initializer={<py.Atom jsValue={42} />}
+            />
+            <py.VariableDeclaration
+              name="y"
+              type="int"
+              initializer={<py.Atom jsValue={42} />}
+            />
+            <py.FunctionCallExpression target="foo" args={["a", "b"]} />
+            <py.MemberExpression>
+              <py.MemberExpression.Part id="a" />
+              <py.MemberExpression.Part id="b" />
+              <py.MemberExpression.Part key={"special-prop"} />
+            </py.MemberExpression>
+            <py.VariableDeclaration
+              name="z"
+              type="int"
+              initializer={<py.Atom jsValue={42} />}
+            />
+          </py.StatementList>
+        </py.FunctionDeclaration>
+        <py.VariableDeclaration
+          name="someVar"
+          type="int"
+          initializer={<py.Atom jsValue={42} />}
+        />
+        <py.FunctionDeclaration name="someOtherMethod" returnType="str" />
+        <py.VariableDeclaration
+          name="someOtherVar"
+          type="int"
+          initializer={<py.Atom jsValue={42} />}
+        />
+      </py.StatementList>
+    </py.ClassDeclaration>,
+    <py.FunctionDeclaration name="someFunction">
+      <py.StatementList>
+        <py.VariableDeclaration
+          name="x"
+          type="int"
+          initializer={<py.Atom jsValue={42} />}
+        />
+        <py.VariableDeclaration
+          name="y"
+          type="int"
+          initializer={<py.Atom jsValue={42} />}
+        />
+        <py.FunctionCallExpression target="foo" args={["a", "b"]} />
+        <py.MemberExpression>
+          <py.MemberExpression.Part id="a" />
+          <py.MemberExpression.Part id="b" />
+          <py.MemberExpression.Part key={"special-prop"} />
+        </py.MemberExpression>
+        <py.VariableDeclaration
+          name="z"
+          type="int"
+          initializer={<py.Atom jsValue={42} />}
+        />
+      </py.StatementList>
+    </py.FunctionDeclaration>,
+    <py.ClassDeclaration name="someOtherClass">
+      <py.StatementList>
+        <py.FunctionDeclaration name="someMethod" returnType="str" />
+      </py.StatementList>
+    </py.ClassDeclaration>,
+    <py.MemberExpression>
+      <py.MemberExpression.Part id="a" />
+      <py.MemberExpression.Part id="b" />
+      <py.MemberExpression.Part key={"special-prop"} />
+    </py.MemberExpression>,
+  ]);
+  const expected = d`
+    class SomeClass:
+        def some_method() -> str:
+            x: int = 42
+            y: int = 42
+            foo(a, b)
+            a.b["special-prop"]
+            z: int = 42
+
+        some_var: int = 42
+        def some_other_method() -> str:
+            pass
+
+        some_other_var: int = 42
+
+
+    def some_function():
+        x: int = 42
+        y: int = 42
+        foo(a, b)
+        a.b["special-prop"]
+        z: int = 42
+
+
+    class SomeOtherClass:
+        def some_method() -> str:
+            pass
+
+
+
+    a.b["special-prop"]
+
+  `;
+  expect(result).toRenderTo(expected);
+});

package/test/utils.tsx

@@ -0,0 +1,131 @@
+import {
+  Binder,
+  Children,
+  ContentOutputFile,
+  NamePolicy,
+  Output,
+  OutputDirectory,
+  OutputFile,
+  PrintTreeOptions,
+  SymbolCreator,
+  render,
+} from "@alloy-js/core";
+import { dedent } from "@alloy-js/core/testing";
+import { expect } from "vitest";
+import * as py from "../src/components/index.js";
+import { createPythonNamePolicy } from "../src/name-policy.js";
+import { CustomOutputScope } from "../src/symbols/custom-output-scope.js";
+import { PythonModuleScope } from "../src/symbols/index.js";
+
+export function findFile(
+  res: OutputDirectory,
+  path: string,
+): ContentOutputFile {
+  const result = findFileWorker(res, path);
+
+  if (!result) {
+    throw new Error("Expected to find file " + path);
+  }
+  return result as ContentOutputFile;
+
+  function findFileWorker(
+    res: OutputDirectory,
+    path: string,
+  ): OutputFile | null {
+    for (const item of res.contents) {
+      if (item.kind === "file") {
+        if (item.path === path) {
+          return item;
+        }
+        continue;
+      } else {
+        const found = findFileWorker(item, path);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+}
+
+export function assertFileContents(
+  res: OutputDirectory,
+  expectedFiles: Record<string, string>,
+) {
+  for (const [path, contents] of Object.entries(expectedFiles)) {
+    const file = findFile(res, path);
+    expect(file.contents).toBe(dedent(contents));
+  }
+}
+
+export function toSourceTextMultiple(
+  sourceFiles: Children[],
+  {
+    policy,
+    externals,
+    options,
+    printOptions,
+  }: {
+    policy?: NamePolicy<string>;
+    externals?: SymbolCreator[];
+    options?: { externals?: SymbolCreator[] };
+    printOptions?: PrintTreeOptions;
+  } = {},
+): OutputDirectory {
+  if (!policy) {
+    policy = createPythonNamePolicy();
+  }
+  const mergedExternals = options?.externals ?? externals;
+  if (printOptions === undefined) {
+    printOptions = {
+      printWidth: 80,
+      tabWidth: 4,
+    };
+  } else {
+    printOptions.tabWidth = 4;
+  }
+  const content = (
+    <Output externals={mergedExternals} namePolicy={policy}>
+      {sourceFiles}
+    </Output>
+  );
+  return render(content, printOptions);
+}
+
+export function toSourceText(
+  c: Children[],
+  {
+    policy,
+    externals,
+    options,
+    printOptions,
+  }: {
+    policy?: NamePolicy<string>;
+    externals?: SymbolCreator[];
+    options?: { externals?: SymbolCreator[] };
+    printOptions?: PrintTreeOptions;
+  } = {},
+): string {
+  const content = <py.SourceFile path="test.py">{c}</py.SourceFile>;
+  const res = toSourceTextMultiple([content], {
+    policy,
+    externals,
+    options,
+    printOptions,
+  });
+  const file = findFile(res, "test.py");
+  return file.contents;
+}
+
+// Helper function to create a PythonModuleScope to be used in tests
+export function createPythonModuleScope(
+  name: string,
+  parent: CustomOutputScope | undefined,
+  binder: Binder | undefined = undefined,
+): PythonModuleScope {
+  return new PythonModuleScope(name, {
+    parent: parent,
+    binder: binder,
+  });
+}

package/test/values.test.tsx

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.jsx";
+
+describe("Atom", () => {
+  it("renders string value", () => {
+    expect(toSourceText([<py.Atom jsValue={"Test"} />])).toRenderTo('"Test"');
+  });
+
+  it("renders null/undefined object", () => {
+    expect(toSourceText([<py.Atom jsValue={undefined} />])).toRenderTo("None");
+  });
+
+  it("renders number", () => {
+    expect(toSourceText([<py.Atom jsValue={123} />])).toRenderTo("123");
+  });
+
+  it("renders boolean - True", () => {
+    expect(toSourceText([<py.Atom jsValue={true} />])).toRenderTo("True");
+  });
+
+  it("renders boolean - False", () => {
+    expect(toSourceText([<py.Atom jsValue={false} />])).toRenderTo("False");
+  });
+
+  it("renders array", () => {
+    expect(toSourceText([<py.Atom jsValue={[1, 2, 3]} />])).toRenderTo(
+      "[1, 2, 3]",
+    );
+  });
+
+  it("renders object", () => {
+    expect(toSourceText([<py.Atom jsValue={{ a: 1, b: 2 }} />])).toRenderTo(
+      '{"a": 1, "b": 2}',
+    );
+  });
+
+  it("renders more complex object", () => {
+    expect(
+      toSourceText([<py.Atom jsValue={{ a: "1", b: 2, c: true }} />]),
+    ).toRenderTo('{"a": "1", "b": 2, "c": True}');
+  });
+
+  it("renders empty object", () => {
+    expect(toSourceText([<py.Atom jsValue={{}} />])).toRenderTo("{}");
+  });
+
+  it("renders function", () => {
+    function Test() {
+      return <>Test</>;
+    }
+
+    expect(toSourceText([<py.Atom jsValue={Test} />])).toRenderTo("Test");
+  });
+
+  it("renders nested object", () => {
+    expect(
+      toSourceText([<py.Atom jsValue={{ a: { b: { c: 1 } }, d: 2 }} />]),
+    ).toRenderTo('{"a": {"b": {"c": 1}}, "d": 2}');
+  });
+});

package/test/variables.test.tsx

@@ -0,0 +1,153 @@
+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.jsx";
+
+describe("Python Variable", () => {
+  it("declares a python variable", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration name="myVar" 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 />,
+    ]);
+    expect(res).toBe(`my_var: int`);
+  });
+
+  it("declares a python variable without typeAnnotations", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration name="myVar" initializer={42} />,
+    ]);
+    expect(res).toBe(`my_var = 42`);
+  });
+
+  it("declares a python variable as None when undefined", () => {
+    const res = toSourceText([<py.VariableDeclaration name="myVar" />]);
+    expect(res).toBe(`my_var = None`);
+  });
+
+  it("declares a python variable as None when null", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name="myVar"
+        initializer={<py.Atom jsValue={null} />}
+      />,
+    ]);
+    expect(res).toBe(`my_var = None`);
+  });
+
+  it("declares a python variable that's an array", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name="numbers"
+        type="list[int]"
+        initializer={<py.Atom jsValue={[1, 2, 3]} />}
+      />,
+    ]);
+    expect(res).toBe(`numbers: list[int] = [1, 2, 3]`);
+  });
+
+  it("declares a python variable with a python value", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name="nameIdPairs"
+        initializer={<py.Atom jsValue={{ John: 123, Doe: 234 }} />}
+      />,
+    ]);
+    expect(res).toBe(`name_id_pairs = {"John": 123, "Doe": 234}`);
+  });
+
+  it("declares a python variable with omitNone", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration name="omitNoneVar" type="int" omitNone={true} />,
+    ]);
+    expect(res).toBe(`omit_none_var: int`);
+  });
+
+  it("declares a call statement python variable", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name="callStmtVar"
+        initializer={12}
+        callStatementVar={true}
+      />,
+    ]);
+    expect(res).toBe(`call_stmt_var=12`);
+  });
+
+  it("declares a call statement python variable without name", () => {
+    const res = toSourceText([
+      <py.VariableDeclaration
+        name=""
+        initializer={12}
+        callStatementVar={true}
+      />,
+    ]);
+    expect(res).toBe(`12`);
+  });
+
+  it("declares a python variable with a class type", () => {
+    const res = toSourceText([
+      <py.StatementList>
+        <py.ClassDeclaration name="MyClass" />
+        <py.VariableDeclaration
+          name="my_var"
+          type={<py.Reference refkey={refkey("MyClass")} />}
+        />
+      </py.StatementList>,
+    ]);
+    expect(res).toBe(d`
+      class MyClass:
+          pass
+
+      my_var: MyClass = None`);
+  });
+
+  it("declares a python variable with a class type from a different module", () => {
+    const res = toSourceTextMultiple([
+      <py.SourceFile path="classes.py">
+        <py.ClassDeclaration name="MyClass" />
+      </py.SourceFile>,
+      <py.SourceFile path="usage.py">
+        <py.VariableDeclaration
+          name="my_var"
+          type={<py.Reference refkey={refkey("MyClass")} />}
+        />
+      </py.SourceFile>,
+    ]);
+    assertFileContents(res, {
+      "classes.py": `
+        class MyClass:
+            pass
+
+      `,
+      "usage.py": `
+        from classes import MyClass
+
+        my_var: MyClass = None
+      `,
+    });
+  });
+
+  it("declares a python variable receiving other variable as value", () => {
+    const res = toSourceText([
+      <py.StatementList>
+        <py.VariableDeclaration name="my_var" initializer={42} />
+        <py.VariableDeclaration
+          name="my_other_var"
+          initializer={refkey("my_var")}
+        />
+      </py.StatementList>,
+    ]);
+    expect(res).toBe(`my_var = 42\nmy_other_var = my_var`);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "outDir": "dist",
+    "types": ["@alloy-js/core/testing/matchers"]
+  },
+  "references": [{ "path": "../core" }],
+  "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "test/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.52.8"
+    }
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import alloyPlugin from "@alloy-js/rollup-plugin";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  esbuild: {
+    jsx: "preserve",
+    sourcemap: "both",
+  },
+  plugins: [alloyPlugin()],
+});

package/vitest.setup.ts

@@ -0,0 +1 @@
+import "@alloy-js/core/testing";