@alloy-js/python 0.0.1

package/dist/test/enums.test.js

@@ -0,0 +1,211 @@
+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 { enumModule } from "../src/builtins/python.js";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+describe("Python Enum", () => {
+  it("classic enum with explicit values", () => {
+    const result = toSourceText([_$createComponent(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([_$createComponent(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([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Dog"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "Cat"
+        }), _$createComponent(py.EnumDeclaration, {
+          name: "Animal",
+          baseType: "Enum",
+          get members() {
+            return [{
+              name: "DOG",
+              value: refkey("Dog")
+            }, {
+              name: "CAT",
+              value: refkey("Cat")
+            }];
+          }
+        })];
+      }
+    })], {
+      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([_$createComponent(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([_$createComponent(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([_$createComponent(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([_$createComponent(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/dist/test/externals.test.d.ts

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

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

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

package/dist/test/externals.test.js

@@ -0,0 +1,219 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+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([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$memo(() => requestsLib["."].get), _$memo(() => requestsLib["."].post), _$memo(() => requestsLib["models"].Request), _$memo(() => requestsLib["models"].Response), _$memo(() => requestsLib["models.anothermodule"].something)];
+    }
+  })], {
+    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 = [_$createComponent(py.FunctionDeclaration, {
+    name: "getUser",
+    parameters: [{
+      name: "userId",
+      type: "int"
+    }],
+    get returnType() {
+      return py.requestsModule["models"]["Response"];
+    },
+    instanceFunction: true,
+    get children() {
+      return _$createComponent(py.StatementList, {
+        get children() {
+          return [_$createComponent(py.VariableDeclaration, {
+            name: "response",
+            get initializer() {
+              return _$createComponent(py.FunctionCallExpression, {
+                get target() {
+                  return py.requestsModule["."]["get"];
+                },
+                args: [1]
+              });
+            }
+          }), code`
+          return response.json()
+        `];
+        }
+      });
+    }
+  }), _$createComponent(py.FunctionDeclaration, {
+    name: "createUser",
+    parameters: [{
+      name: "userName",
+      type: "string"
+    }],
+    get returnType() {
+      return py.requestsModule["models"]["Response"];
+    },
+    instanceFunction: true,
+    get children() {
+      return _$createComponent(py.StatementList, {
+        get children() {
+          return [_$createComponent(py.VariableDeclaration, {
+            name: "response",
+            get initializer() {
+              return _$createComponent(py.FunctionCallExpression, {
+                get target() {
+                  return py.requestsModule["."]["post"];
+                },
+                args: [1]
+              });
+            }
+          }), code`
+          return response.json()
+        `];
+        }
+      });
+    }
+  })];
+  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 = [_$createComponent(py.ClassDeclaration, {
+    name: "UserClient",
+    get children() {
+      return _$createComponent(py.StatementList, {
+        get children() {
+          return [_$createComponent(py.VariableDeclaration, {
+            name: "some_var",
+            initializer: 12,
+            instanceVariable: true
+          }), _$createComponent(py.FunctionDeclaration, {
+            name: "getUser",
+            parameters: [{
+              name: "userId",
+              type: "int"
+            }],
+            get returnType() {
+              return py.requestsModule["models"]["Response"];
+            },
+            instanceFunction: true,
+            get children() {
+              return _$createComponent(py.StatementList, {
+                get children() {
+                  return [_$createComponent(py.VariableDeclaration, {
+                    name: "response",
+                    get initializer() {
+                      return _$createComponent(py.FunctionCallExpression, {
+                        get target() {
+                          return py.requestsModule["."]["get"];
+                        },
+                        get args() {
+                          return [refkey("some_var")];
+                        }
+                      });
+                    }
+                  }), code`
+              return response.json()
+            `];
+                }
+              });
+            }
+          }), _$createComponent(py.FunctionDeclaration, {
+            name: "createUser",
+            parameters: [{
+              name: "userName",
+              type: "string"
+            }],
+            get returnType() {
+              return py.requestsModule["models"]["Response"];
+            },
+            instanceFunction: true,
+            get children() {
+              return _$createComponent(py.StatementList, {
+                get children() {
+                  return [_$createComponent(py.VariableDeclaration, {
+                    name: "response",
+                    get initializer() {
+                      return _$createComponent(py.FunctionCallExpression, {
+                        get target() {
+                          return py.requestsModule["."]["post"];
+                        },
+                        get args() {
+                          return [refkey("some_var")];
+                        }
+                      });
+                    }
+                  }), code`
+              return response.json()
+            `];
+                }
+              });
+            }
+          })];
+        }
+      });
+    }
+  })];
+  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/dist/test/functioncallexpressions.test.d.ts

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

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

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

package/dist/test/functioncallexpressions.test.js

@@ -0,0 +1,156 @@
+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 { toSourceText } from "./utils.js";
+describe("FunctionCallExpression", () => {
+  it("renders", () => {
+    const result = toSourceText([_$createComponent(py.FunctionCallExpression, {
+      target: "foo"
+    })]);
+    expect(result).toRenderTo(d`
+      foo()
+    `);
+  });
+  it("renders with args", () => {
+    const result = toSourceText([_$createComponent(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([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "runFunc",
+          refkey: methodRef
+        }), _$createComponent(py.FunctionCallExpression, {
+          target: methodRef,
+          get args() {
+            return [_$createComponent(py.Atom, {
+              jsValue: "A name"
+            }), _$createComponent(py.Atom, {
+              jsValue: 42
+            }), _$createComponent(py.Atom, {
+              jsValue: true
+            })];
+          }
+        })];
+      }
+    })]);
+    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([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.FunctionDeclaration, {
+          name: "runFunc",
+          returnType: "str",
+          refkey: methodRef,
+          parameters: [{
+            name: "name",
+            type: "str"
+          }, {
+            name: "number",
+            type: "int"
+          }, {
+            name: "flag",
+            type: "bool"
+          }]
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "result",
+          type: "str",
+          get initializer() {
+            return _$createComponent(py.FunctionCallExpression, {
+              target: methodRef,
+              get args() {
+                return [_$createComponent(py.Atom, {
+                  jsValue: "A name"
+                }), _$createComponent(py.Atom, {
+                  jsValue: 42
+                }), _$createComponent(py.Atom, {
+                  jsValue: true
+                })];
+              }
+            });
+          }
+        })];
+      }
+    })]);
+    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([_$createComponent(py.StatementList, {
+      get children() {
+        return _$createComponent(py.FunctionCallExpression, {
+          target: "example_method",
+          get args() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "name",
+              initializer: "A name",
+              callStatementVar: true
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "number",
+              initializer: 42,
+              callStatementVar: true
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "flag",
+              initializer: true,
+              callStatementVar: true
+            })];
+          }
+        });
+      }
+    })]);
+    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([_$createComponent(py.StatementList, {
+      get children() {
+        return _$createComponent(py.FunctionCallExpression, {
+          target: "example_method",
+          get args() {
+            return [_$createComponent(py.Atom, {
+              jsValue: "A name"
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "number",
+              initializer: 42,
+              callStatementVar: true
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "flag",
+              initializer: true,
+              callStatementVar: true
+            })];
+          }
+        });
+      }
+    })]);
+    const expected = d`
+      example_method("A name", number=42, flag=True)
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});

package/dist/test/functiondeclaration.test.d.ts

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

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

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