@alloy-js/python 0.0.1

package/dist/test/classdeclarations.test.js

@@ -0,0 +1,397 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { memberRefkey, 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("Python Class", () => {
+  it("renders a class with no body as 'pass'", () => {
+    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
+      name: "Foo"
+    })]);
+    expect(result).toRenderTo(d`
+      class Foo:
+          pass
+
+
+    `);
+  });
+  it("renders a class with a body", () => {
+    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
+      name: "Bar",
+      children: "print('hi')"
+    })]);
+    expect(result).toRenderTo(d`
+      class Bar:
+          print('hi')
+
+
+    `);
+  });
+  it("renders a class with base classes", () => {
+    const result = toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Base1"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "Base2"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "Baz",
+          get bases() {
+            return [refkey("Base1"), refkey("Base2")];
+          }
+        })];
+      }
+    })]);
+    const expected = d`
+      class Base1:
+          pass
+
+      class Base2:
+          pass
+
+      class Baz(Base1, Base2):
+          pass
+
+        
+    `;
+    expect(result).toRenderTo(expected);
+  });
+  it("renders a class with base classes and body", () => {
+    const result = toSourceText([_$createComponent(py.ClassDeclaration, {
+      name: "Qux",
+      bases: ["Base"],
+      children: "print('hello')"
+    })]);
+    expect(result).toRenderTo(d`
+      class Qux(Base):
+          print('hello')
+
+
+    `);
+  });
+  it("renders classes across modules with inheritance", () => {
+    const result = toSourceTextMultiple([_$createComponent(py.SourceFile, {
+      path: "mod1.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "A"
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "folder/mod2.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "B",
+          get bases() {
+            return [refkey("A")];
+          }
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "mod3.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "C",
+          get bases() {
+            return [refkey("B")];
+          }
+        });
+      }
+    })]);
+    const mod1Expected = d`
+      class A:
+          pass
+
+
+    `;
+    const mod2Expected = d`
+      from mod1 import A
+
+      class B(A):
+          pass
+
+
+    `;
+    const mod3Expected = d`
+      from folder.mod2 import B
+
+      class C(B):
+          pass
+
+
+    `;
+    assertFileContents(result, {
+      "mod1.py": mod1Expected
+    });
+    assertFileContents(result, {
+      "folder/mod2.py": mod2Expected
+    });
+    assertFileContents(result, {
+      "mod3.py": mod3Expected
+    });
+  });
+  it("renders a class with class variables like foo: str, and also bar: A where A is another class", () => {
+    const result = toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "A"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "B",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "bar",
+                  get type() {
+                    return refkey("A");
+                  },
+                  omitNone: true
+                }), _$createComponent(py.VariableDeclaration, {
+                  name: "foo",
+                  type: "str",
+                  omitNone: true
+                })];
+              }
+            });
+          }
+        })];
+      }
+    })]);
+    const expected = d`
+      class A:
+          pass
+
+      class B:
+          bar: A
+          foo: str
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+  it("renders a class with class variables like foo: str, and another identical class", () => {
+    const result = toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "A",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  name: "foo",
+                  type: "str",
+                  omitNone: true
+                });
+              }
+            });
+          }
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "B",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  name: "foo",
+                  type: "str",
+                  omitNone: true
+                });
+              }
+            });
+          }
+        })];
+      }
+    })]);
+    const expected = d`
+      class A:
+          foo: str
+
+      class B:
+          foo: str
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});
+describe("Python Class - VariableDeclaration", () => {
+  it("renders a class with class fields", () => {
+    const result = toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.ClassDeclaration, {
+          name: "Base"
+        }), _$createComponent(py.ClassDeclaration, {
+          name: "A",
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "just_name"
+                }), _$createComponent(py.VariableDeclaration, {
+                  name: "name_and_type",
+                  type: "number"
+                }), _$createComponent(py.VariableDeclaration, {
+                  name: "name_type_and_value",
+                  type: "number",
+                  initializer: 12
+                }), _$createComponent(py.VariableDeclaration, {
+                  name: "class_based",
+                  get type() {
+                    return refkey("Base");
+                  }
+                })];
+              }
+            });
+          }
+        })];
+      }
+    })]);
+    const expected = d`
+      class Base:
+          pass
+
+      class A:
+          just_name = None
+          name_and_type: number = None
+          name_type_and_value: number = 12
+          class_based: Base = None
+
+
+    `;
+    expect(result).toRenderTo(expected);
+  });
+  it("correctly access members of its type", () => {
+    const classRk = refkey();
+    const classMemberRk = refkey();
+    const classMethodRk = refkey();
+    const v1Rk = refkey();
+    const res = toSourceTextMultiple([_$createComponent(py.SourceFile, {
+      path: "inst.py",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "one",
+              refkey: v1Rk,
+              type: classRk,
+              get initializer() {
+                return _$createComponent(py.MemberExpression, {
+                  get children() {
+                    return [_$createComponent(py.MemberExpression.Part, {
+                      refkey: classRk
+                    }), _$createComponent(py.MemberExpression.Part, {
+                      args: true
+                    })];
+                  }
+                });
+              }
+            }), [_$memo(() => memberRefkey(v1Rk, classMemberRk))], [_$memo(() => memberRefkey(v1Rk, classMethodRk)), "()"]];
+          }
+        });
+      }
+    }), _$createComponent(py.SourceFile, {
+      path: "decl.py",
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "Bar",
+          refkey: classRk,
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "instanceProp",
+                  refkey: classMemberRk,
+                  initializer: 42,
+                  instanceVariable: true
+                }), _$createComponent(py.FunctionDeclaration, {
+                  name: "instanceMethod",
+                  instanceFunction: true,
+                  refkey: classMethodRk,
+                  returnType: "int"
+                })];
+              }
+            });
+          }
+        });
+      }
+    })]);
+    assertFileContents(res, {
+      "inst.py": `
+        from decl import Bar
+
+        one: Bar = Bar()
+        one.instance_prop
+        one.instance_method()
+      `,
+      "decl.py": `
+        class Bar:
+            instance_prop = 42
+            def instance_method(self) -> int:
+                pass
+
+
+      `
+    });
+  });
+});
+describe("Python Class - FunctionDeclaration", () => {
+  it("renders a class with class fields and method", () => {
+    const result = toSourceText([[_$createComponent(py.ClassDeclaration, {
+      name: "MyClass",
+      bases: ["BaseClass"],
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "a",
+              type: "int"
+            }), _$createComponent(py.VariableDeclaration, {
+              name: "b",
+              type: "int"
+            }), _$createComponent(py.FunctionDeclaration, {
+              name: "my_method",
+              parameters: [{
+                name: "a",
+                type: "int"
+              }, {
+                name: "b",
+                type: "int"
+              }],
+              returnType: "int",
+              instanceFunction: true,
+              children: "return a + b"
+            }), _$createComponent(py.FunctionDeclaration, {
+              name: "my_class_method",
+              instanceFunction: false,
+              classFunction: true,
+              returnType: "int",
+              children: "pass"
+            }), _$createComponent(py.FunctionDeclaration, {
+              name: "my_standalone_function",
+              instanceFunction: false,
+              returnType: "int",
+              children: "pass"
+            })];
+          }
+        });
+      }
+    })]]);
+    const expected = d`
+      class MyClass(BaseClass):
+          a: int = None
+          b: int = None
+          def my_method(self, a: int, b: int) -> int:
+              return a + b
+
+          def my_class_method(cls) -> int:
+              pass
+
+          def my_standalone_function() -> int:
+              pass
+
+
+          
+    `;
+    expect(result).toRenderTo(expected);
+  });
+});

package/dist/test/classinstantiations.test.d.ts

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

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

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

package/dist/test/classinstantiations.test.js

@@ -0,0 +1,168 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+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.js";
+it("declaration of class instance with variables", () => {
+  // Creating the reference separately so the naming policy doesn't interfere
+  const classRef = refkey();
+  const result = toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.ClassDeclaration, {
+        name: "one-class",
+        refkey: classRef
+      }), _$createComponent(py.ClassInstantiation, {
+        target: classRef,
+        get args() {
+          return [_$createComponent(py.Atom, {
+            jsValue: "A name"
+          }), _$createComponent(py.Atom, {
+            jsValue: 42
+          }), _$createComponent(py.Atom, {
+            jsValue: true
+          })];
+        }
+      })];
+    }
+  })]);
+  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([_$createComponent(py.StatementList, {
+    get children() {
+      return _$createComponent(py.ClassInstantiation, {
+        get target() {
+          return requestsLib["models"].Request;
+        }
+      });
+    }
+  })], {
+    externals: [requestsLib]
+  });
+  const expected = d`
+    from requests.models import Request
+
+    Request()
+  `;
+  expect(result).toRenderTo(expected);
+});
+it("Class instantiation without a reference", () => {
+  const result = toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return _$createComponent(py.ClassInstantiation, {
+        target: "ExampleClass",
+        get args() {
+          return [_$createComponent(py.Atom, {
+            jsValue: "A name"
+          }), _$createComponent(py.Atom, {
+            jsValue: 42
+          }), _$createComponent(py.Atom, {
+            jsValue: true
+          })];
+        }
+      });
+    }
+  })]);
+  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([_$createComponent(py.StatementList, {
+    get children() {
+      return _$createComponent(py.ClassInstantiation, {
+        target: "ExampleClass",
+        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`
+    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([_$createComponent(py.StatementList, {
+    get children() {
+      return _$createComponent(py.ClassInstantiation, {
+        target: "ExampleClass",
+        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`
+    ExampleClass("A name", number=42, flag=True)
+  `;
+  expect(result).toRenderTo(expected);
+});
+it("incorrect Class instantiation works", () => {
+  const result = toSourceText([_$createComponent(py.ClassInstantiation, {
+    target: "MyClass",
+    get args() {
+      return [_$createComponent(py.ClassDeclaration, {
+        name: "NestedClass"
+      }), _$createComponent(py.FunctionDeclaration, {
+        name: "myFunc"
+      }), _$createComponent(py.StatementList, {
+        get children() {
+          return _$createComponent(py.VariableDeclaration, {
+            name: "x"
+          });
+        }
+      })];
+    }
+  })]);
+  const expected = d`
+    MyClass(
+        class NestedClass:
+            pass
+        ,
+        def my_func():
+            pass
+        ,
+        x = None
+    )
+  `;
+  expect(result).toRenderTo(expected);
+});

package/dist/test/enums.test.d.ts

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

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

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