@alloy-js/python 0.0.1

package/dist/test/functiondeclaration.test.js

@@ -0,0 +1,363 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+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([_$createComponent(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([_$createComponent(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([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "foo",
+          instanceFunction: true,
+          returnType: "int",
+          refkey: refkeyFoo
+        }), _$createComponent(py.FunctionDeclaration, {
+          name: "bar",
+          instanceFunction: true,
+          returnType: "int",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              name: "result",
+              type: "int",
+              get initializer() {
+                return _$createComponent(py.FunctionCallExpression, {
+                  target: refkeyFoo,
+                  args: []
+                });
+              }
+            });
+          }
+        })];
+      }
+    })]);
+    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([_$createComponent(py.FunctionDeclaration, {
+      name: "bar",
+      instanceFunction: true,
+      children: "print('hi')"
+    })]);
+    expect(result).toRenderTo(d`
+      def bar(self):
+          print('hi')
+
+
+    `);
+  });
+  it("renders a function with parameters", () => {
+    const result = toSourceText([_$createComponent(py.FunctionDeclaration, {
+      name: "baz",
+      parameters: [{
+        name: "x",
+        type: "int"
+      }, {
+        name: "y",
+        default: 0
+      }, {
+        name: "z",
+        type: "int",
+        default: 42
+      }],
+      args: true,
+      kwargs: true,
+      children: "print(x, y)"
+    })]);
+    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([_$createComponent(py.InitFunctionDeclaration, {
+      parameters: [{
+        name: "x"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      def __init__(self, x):
+          pass
+
+        
+    `);
+  });
+  it("can be an async function", () => {
+    expect(toSourceText([_$createComponent(py.FunctionDeclaration, {
+      async: true,
+      name: "foo"
+    })])).toBe(d`
+      async def foo():
+          pass
+
+    `);
+  });
+  it("can be an async function with returnType", () => {
+    expect(toSourceText([_$createComponent(py.FunctionDeclaration, {
+      async: true,
+      name: "foo",
+      returnType: "Foo"
+    })])).toBe(d`
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+  it("can be an async function with returnType element with Reference", () => {
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Foo"
+        }), _$createComponent(py.FunctionDeclaration, {
+          async: true,
+          name: "foo",
+          get returnType() {
+            return _$createComponent(py.Reference, {
+              get refkey() {
+                return refkey("Foo");
+              }
+            });
+          }
+        })];
+      }
+    })])).toBe(d`
+      class Foo:
+          pass
+
+      async def foo() -> Foo:
+          pass
+
+    `);
+  });
+  it("supports parameters", () => {
+    const decl = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: ["a", "b"],
+      children: "return a + b"
+    });
+    expect(toSourceText([decl])).toBe(d`
+      def foo(a, b):
+          return a + b
+
+    `);
+  });
+  it("supports type parameters", () => {
+    const decl = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: ["a", "b"],
+      typeParameters: ["T", "U"],
+      children: "return a + b"
+    });
+    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 = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      instanceFunction: true,
+      parameters: parameters,
+      children: "self.attribute = \"value\""
+    });
+    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 = _$createComponent(py.InitFunctionDeclaration, {
+      parameters: parameters,
+      children: "self.attribute = \"value\""
+    });
+    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 = _$createComponent(py.FunctionDeclaration, {
+      name: "foo",
+      parameters: parameters,
+      refkey: fooRef,
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "bar",
+          parameters: parameters_nested,
+          refkey: barRef,
+          get children() {
+            return [_$createComponent(py.FunctionDeclaration, {
+              name: "foobar",
+              parameters: parameters_nested_nested,
+              refkey: foobarRef,
+              children: "return z * 2"
+            }), "return", " ", _$createComponent(py.FunctionCallExpression, {
+              target: foobarRef,
+              get args() {
+                return [_$createComponent(py.Atom, {
+                  jsValue: 2
+                })];
+              }
+            })];
+          }
+        }), "return", " ", _$createComponent(py.FunctionCallExpression, {
+          target: barRef,
+          get args() {
+            return [_$createComponent(py.Atom, {
+              jsValue: 3
+            })];
+          }
+        })];
+      }
+    });
+    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([_$createComponent(py.SourceFile, {
+      path: "mod1.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Foo"
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "mod2.py",
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "A"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "B"
+        })];
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "usage.py",
+      get children() {
+        return _$createComponent(py.FunctionDeclaration, {
+          async: true,
+          name: "foo",
+          get parameters() {
+            return [{
+              name: "x",
+              type: _$createComponent(py.Reference, {
+                get refkey() {
+                  return refkey("A");
+                }
+              })
+            }, {
+              name: "y",
+              type: _$createComponent(py.Reference, {
+                get refkey() {
+                  return refkey("B");
+                }
+              })
+            }];
+          },
+          args: true,
+          kwargs: true,
+          get returnType() {
+            return _$createComponent(py.Reference, {
+              get refkey() {
+                return refkey("Foo");
+              }
+            });
+          }
+        });
+      }
+    })]);
+    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/dist/test/imports.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=imports.test.d.ts.map

package/dist/test/imports.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.test.d.ts","sourceRoot":"","sources":["../../test/imports.test.tsx"],"names":[],"mappings":""}

package/dist/test/imports.test.js

@@ -0,0 +1,262 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { refkey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { ImportStatement } from "../src/components/ImportStatement.js";
+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.js";
+describe("ImportStatement", () => {
+  it("renders module import", () => {
+    const result = toSourceText([_$createComponent(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([new ImportedSymbol(sqrtSymbol, sqrtSymbol), new ImportedSymbol(piSymbol, piSymbol)]);
+    const result = toSourceText([_$createComponent(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([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([new ImportedSymbol(getSymbol, getSymbol)]);
+    const records = new ImportRecords([[pythonModuleScope, {
+      symbols: mathSymbols
+    }], [requestsScope, {
+      symbols: requestsSymbols
+    }], [sysModuleScope, {
+      symbols: new Set()
+    }]]);
+    const result = toSourceText([_$createComponent(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([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([new ImportedSymbol(getSymbol, getSymbol), new ImportedSymbol(postSymbol, postSymbol)]);
+    const records = new ImportRecords([[pythonModuleScope, {
+      symbols: mathSymbols
+    }], [requestsScope, {
+      symbols: requestsSymbols
+    }]]);
+    const result = toSourceText([_$createComponent(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([_$createComponent(py.SourceFile, {
+      path: "test_1.py",
+      get children() {
+        return _$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk1
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test_3.py",
+      get children() {
+        return _$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk3
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test_2.py",
+      get children() {
+        return _$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk2
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test.py",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "one",
+              initializer: rk1
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "three",
+              initializer: rk3
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "two",
+              initializer: rk2
+            })];
+          }
+        });
+      }
+    })]);
+    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([_$createComponent(py.SourceFile, {
+      path: "test_1.py",
+      get children() {
+        return [_$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk1
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "something_else",
+          refkey: rk4
+        })];
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test_2.py",
+      get children() {
+        return [_$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk2
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "something",
+          refkey: rk6
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "something_else",
+          refkey: rk5
+        })];
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test_3.py",
+      get children() {
+        return [_$createComponent(py.VariableDeclaration, {
+          name: "conflict",
+          refkey: rk3
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "something",
+          refkey: rk7
+        })];
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "test.py",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "one",
+              initializer: rk1
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "two",
+              initializer: rk2
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "three",
+              initializer: rk3
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "something_else",
+              initializer: rk4
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "something_else_two",
+              initializer: rk5
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "something",
+              initializer: rk6
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "something_two",
+              initializer: rk7
+            })];
+          }
+        });
+      }
+    })]);
+    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
+      `
+    });
+  });
+});

package/dist/test/memberexpressions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memberexpressions.test.d.ts.map

package/dist/test/memberexpressions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memberexpressions.test.d.ts","sourceRoot":"","sources":["../../test/memberexpressions.test.tsx"],"names":[],"mappings":""}