@alloy-js/python 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog - @alloy-js/python
+
+This package is currently in development. No releases yet.

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/api-extractor.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+  "extends": "../../api-extractor.base.json"
+}

package/dist/src/builtins/python.d.ts

@@ -0,0 +1,9 @@
+import { SymbolCreator } from "@alloy-js/core";
+export declare const enumModule: import("../create-module.js").ModuleRefkeys<{
+    readonly ".": ["auto", "Enum", "Flag", "IntEnum", "IntFlag", "StrEnum"];
+}> & SymbolCreator;
+export declare const requestsModule: import("../create-module.js").ModuleRefkeys<{
+    readonly ".": ["get", "post", "put", "delete", "patch", "head", "options"];
+    readonly models: ["Response", "Request"];
+}> & SymbolCreator;
+//# sourceMappingURL=python.d.ts.map

package/dist/src/builtins/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../../src/builtins/python.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAM/C,eAAO,MAAM,UAAU;;kBAKrB,CAAC;AAEH,eAAO,MAAM,cAAc;;;kBAMzB,CAAC"}

package/dist/src/builtins/python.js

@@ -0,0 +1,17 @@
+import { createModule } from "../create-module.js";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+export const enumModule = createModule({
+  name: "enum",
+  descriptor: {
+    ".": ["auto", "Enum", "Flag", "IntEnum", "IntFlag", "StrEnum"]
+  }
+});
+export const requestsModule = createModule({
+  name: "requests",
+  descriptor: {
+    ".": ["get", "post", "put", "delete", "patch", "head", "options"],
+    models: ["Response", "Request"]
+  }
+});

package/dist/src/components/Atom.d.ts

@@ -0,0 +1,19 @@
+export interface AtomProps {
+    jsValue?: unknown;
+}
+/**
+ * A component that renders a JavaScript value as a Python atom (atomic value).
+ * It handles various types of atomic values including numbers, booleans, strings,
+ * functions, arrays, and objects, converting them to Python-like syntax.
+ *
+ * @example
+ * ```tsx
+ * <Atom jsValue={42} /> // renders "42"
+ * <Atom jsValue={true} /> // renders "True"
+ * <Atom jsValue="Hello" /> // renders '"Hello"'
+ * <Atom jsValue={[1, 2, 3]} /> // renders "[1, 2, 3]"
+ * <Atom jsValue={{ key: "value" }} />
+ * ```
+ */
+export declare function Atom(props: AtomProps): any;
+//# sourceMappingURL=Atom.d.ts.map

package/dist/src/components/Atom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atom.d.ts","sourceRoot":"","sources":["../../../src/components/Atom.tsx"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAuD1C"}

package/dist/src/components/Atom.js

@@ -0,0 +1,82 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { For, Indent, memo } from "@alloy-js/core";
+/**
+ * A component that renders a JavaScript value as a Python atom (atomic value).
+ * It handles various types of atomic values including numbers, booleans, strings,
+ * functions, arrays, and objects, converting them to Python-like syntax.
+ *
+ * @example
+ * ```tsx
+ * <Atom jsValue={42} /> // renders "42"
+ * <Atom jsValue={true} /> // renders "True"
+ * <Atom jsValue="Hello" /> // renders '"Hello"'
+ * <Atom jsValue={[1, 2, 3]} /> // renders "[1, 2, 3]"
+ * <Atom jsValue={{ key: "value" }} />
+ * ```
+ */
+export function Atom(props) {
+  return memo(() => {
+    const jsValue = props.jsValue;
+    if (typeof jsValue === "undefined") {
+      return "None";
+    } else if (typeof jsValue === "number") {
+      return String(jsValue);
+    } else if (typeof jsValue === "boolean") {
+      return jsValue ? "True" : "False";
+    } else if (typeof jsValue === "string") {
+      return `"${jsValue.replace(/"/g, '\\"')}"`;
+    } else if (typeof jsValue === "function") {
+      // functions are inserted as-is.
+      return jsValue;
+    } else if (typeof jsValue === "object") {
+      if (jsValue === null) {
+        return "None";
+      } else if (Array.isArray(jsValue)) {
+        // Recursively emit each element of arrays
+        return _$createIntrinsic("group", {
+          get children() {
+            return ["[", _$createComponent(Indent, {
+              softline: true,
+              trailingBreak: true,
+              get children() {
+                return _$createComponent(For, {
+                  each: jsValue,
+                  comma: true,
+                  line: true,
+                  children: v => _$createComponent(Atom, {
+                    jsValue: v
+                  })
+                });
+              }
+            }), "]"];
+          }
+        });
+      } else {
+        const entries = Object.entries(jsValue);
+        if (entries.length === 0) {
+          return "{}";
+        }
+        // Recursively emit each key-value pair of objects
+        return _$createIntrinsic("group", {
+          get children() {
+            return ["{", _$createComponent(Indent, {
+              softline: true,
+              get children() {
+                return _$createComponent(For, {
+                  each: entries,
+                  comma: true,
+                  line: true,
+                  children: ([k, v]) => [_$createComponent(Atom, {
+                    jsValue: k
+                  }), ": ", _$createComponent(Atom, {
+                    jsValue: v
+                  })]
+                });
+              }
+            }), "}"];
+          }
+        });
+      }
+    }
+  });
+}

package/dist/src/components/CallSignature.d.ts

@@ -0,0 +1,79 @@
+import { Children } from "@alloy-js/core";
+import { ParameterDescriptor } from "../parameter-descriptor.js";
+export interface CallSignatureParametersProps {
+    readonly parameters?: ParameterDescriptor[] | string[];
+    readonly args?: boolean;
+    readonly kwargs?: boolean;
+    readonly instanceFunction?: boolean;
+    readonly classFunction?: boolean;
+}
+/**
+ * A call signature parameters declaration, which can be used to define the
+ * parameters of a function or other callables.
+ *
+ * @example
+ * ```tsx
+ * <py.CallSignatureParameters parameters={[ "a", "b" ]} />
+ * ```
+ * This will generate:
+ * ```python
+ * a, b
+ * ```
+ */
+export declare function CallSignatureParameters(props: CallSignatureParametersProps): Children;
+export interface CallSignatureProps {
+    /**
+     * The parameters to the call signature. Can be an array of strings for parameters
+     * which don't have a type or a default value. Otherwise, it's an array of
+     * {@link ParameterDescriptor}s.
+     */
+    parameters?: ParameterDescriptor[] | string[];
+    /**
+     * The type parameters of the call signature, e.g. for a generic function.
+     * This is only supported in Python 3.12+.
+     */
+    typeParameters?: string[];
+    /**
+     * Indicates if there are positional arguments (`*args`) in the function
+     */
+    args?: boolean;
+    /**
+     * Indicates if there are keyword arguments (`**kwargs`) in the function
+     */
+    kwargs?: boolean;
+    /**
+     * Indicates that this is an instance function.
+     */
+    instanceFunction?: boolean;
+    /**
+     * Indicates that this is a class function.
+     */
+    classFunction?: boolean;
+    /**
+     * The return type of the function.
+     */
+    returnType?: Children;
+}
+/**
+ * A Python call signature, e.g. the part after the `def` keyword and the name in a
+ * function expression.
+ *
+ * @example
+ * ```tsx
+ * <CallSignature
+ *   parameters={[{ name: "a", type: "int" }, { name: "b", type: "str" }]}
+ *   returnType="int"
+ * />
+ * ```
+ * renders to
+ * ```py
+ * (a: int, b: str) -> int
+ * ```
+ * @remarks
+ *
+ * Any parameters or type parameters declared in this signature will be placed
+ * in the current scope. This component does not make a scope to hold its
+ * parameters.
+ */
+export declare function CallSignature(props: CallSignatureProps): Children;
+//# sourceMappingURL=CallSignature.d.ts.map

package/dist/src/components/CallSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallSignature.d.ts","sourceRoot":"","sources":["../../../src/components/CallSignature.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAMjE,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAAC;IACvD,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,4BAA4B,YAmD1E;AA+ED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAAC;IAE9C;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,UAAU,CAAC,EAAE,QAAQ,CAAC;CACvB;AACD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,YAyBtD"}

package/dist/src/components/CallSignature.js

@@ -0,0 +1,201 @@
+import { createComponent as _$createComponent, memo as _$memo, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { computed, createSymbolSlot, For, Show, useContext } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { Atom } from "./Atom.js";
+import { PythonSourceFileContext } from "./SourceFile.js";
+/**
+ * A call signature parameters declaration, which can be used to define the
+ * parameters of a function or other callables.
+ *
+ * @example
+ * ```tsx
+ * <py.CallSignatureParameters parameters={[ "a", "b" ]} />
+ * ```
+ * This will generate:
+ * ```python
+ * a, b
+ * ```
+ */
+export function CallSignatureParameters(props) {
+  // Validate that only one of instanceFunction or classFunction is true
+  if (props.instanceFunction && props.classFunction) {
+    throw new Error("Cannot be both an instance function and a class function");
+  }
+  const sfContext = useContext(PythonSourceFileContext);
+  const module = sfContext?.module;
+  const parameters = normalizeAndDeclareParameters(props.parameters ?? []);
+  const parameterList = computed(() => {
+    const params = [];
+
+    // Add self/cls parameter if instance or class function
+    if (props.instanceFunction) {
+      params.push(parameter({
+        symbol: createPythonSymbol("self", {
+          module: module
+        })
+      }));
+    } else if (props.classFunction) {
+      params.push(parameter({
+        symbol: createPythonSymbol("cls", {
+          module: module
+        })
+      }));
+    }
+
+    // Add regular parameters
+    parameters.forEach(param => {
+      params.push(parameter(param));
+    });
+
+    // Add *args if specified
+    if (props.args) {
+      params.push("*args");
+    }
+
+    // Add **kwargs if specified
+    if (props.kwargs) {
+      params.push("**kwargs");
+    }
+    return params;
+  });
+  return _$createComponent(For, {
+    each: parameterList,
+    comma: true,
+    space: true,
+    children: param => param
+  });
+}
+function parameter(param) {
+  const SymbolSlot = createSymbolSlot();
+  SymbolSlot.instantiateInto(param.symbol);
+  return _$createIntrinsic("group", {
+    get children() {
+      return [_$memo(() => param.symbol.name), _$createComponent(Show, {
+        get when() {
+          return !!param.type;
+        },
+        get children() {
+          return [": ", _$createComponent(SymbolSlot, {
+            get children() {
+              return param.type;
+            }
+          })];
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return !!param.optional;
+        },
+        get children() {
+          return [_$createComponent(Show, {
+            get when() {
+              return !param.type;
+            },
+            children: "="
+          }), _$createComponent(Show, {
+            get when() {
+              return !!param.type;
+            },
+            children: " = "
+          }), [_$memo(() => _$memo(() => !!param.default)() ? _$createComponent(Atom, {
+            get jsValue() {
+              return param.default;
+            }
+          }) : "None")]];
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return !param.optional && param.default !== undefined;
+        },
+        get children() {
+          return [_$createComponent(Show, {
+            get when() {
+              return !param.type;
+            },
+            children: "="
+          }), _$createComponent(Show, {
+            get when() {
+              return !!param.type;
+            },
+            children: " = "
+          }), [_$createComponent(Atom, {
+            get jsValue() {
+              return param.default;
+            }
+          })]];
+        }
+      })];
+    }
+  });
+}
+function normalizeAndDeclareParameters(parameters) {
+  const sfContext = useContext(PythonSourceFileContext);
+  const module = sfContext?.module;
+  if (parameters.length === 0) {
+    return [];
+  }
+  if (typeof parameters[0] === "string") {
+    return parameters.map(paramName => {
+      const symbol = createPythonSymbol(paramName, {
+        module: module
+      }, "parameter", false);
+      return {
+        refkeys: symbol.refkeys,
+        symbol
+      };
+    });
+  } else {
+    return parameters.map(param => {
+      const symbol = createPythonSymbol(param.name, {
+        refkeys: param.refkey,
+        module: module
+      }, "parameter", false);
+      return {
+        ...param,
+        symbol
+      };
+    });
+  }
+}
+/**
+ * A Python call signature, e.g. the part after the `def` keyword and the name in a
+ * function expression.
+ *
+ * @example
+ * ```tsx
+ * <CallSignature
+ *   parameters={[{ name: "a", type: "int" }, { name: "b", type: "str" }]}
+ *   returnType="int"
+ * />
+ * ```
+ * renders to
+ * ```py
+ * (a: int, b: str) -> int
+ * ```
+ * @remarks
+ *
+ * Any parameters or type parameters declared in this signature will be placed
+ * in the current scope. This component does not make a scope to hold its
+ * parameters.
+ */
+export function CallSignature(props) {
+  const sParams = _$createComponent(CallSignatureParameters, {
+    get parameters() {
+      return props.parameters;
+    },
+    get args() {
+      return props.args;
+    },
+    get kwargs() {
+      return props.kwargs;
+    },
+    get instanceFunction() {
+      return props.instanceFunction;
+    },
+    get classFunction() {
+      return props.classFunction;
+    }
+  });
+  const typeParams = props.typeParameters ? `[${props.typeParameters.join(", ")}]` : "";
+  const sReturnType = props.returnType ? [" -> ", _$memo(() => props.returnType)] : undefined;
+  return [typeParams, "(", sParams, ")", sReturnType];
+}

package/dist/src/components/ClassDeclaration.d.ts

@@ -0,0 +1,37 @@
+import { Children } from "@alloy-js/core";
+import { BaseDeclarationProps } from "./Declaration.js";
+export interface ClassDeclarationProps extends BaseDeclarationProps {
+    /**
+     * The base classes that this class inherits from.
+     */
+    bases?: Children[];
+}
+/**
+ * Create a Python class declaration.
+ *
+ * @example
+ * ```tsx
+ * <ClassDeclaration name="MyClass" bases={["BaseClass"]}>
+ *   <VariableDeclaration name="a" type="int" />
+ *   <VariableDeclaration name="b" type="str" />
+ *   <py.FunctionDeclaration name="my_method" parameters={[{ name: "a", type: "int" }, { name: "b", type: "str" }]} returnType="int">
+ *     return a + b
+ *   </py.FunctionDeclaration>
+ * </ClassDeclaration>
+ * ```
+ * renders to
+ * ```py
+ * class MyClass(BaseClass):
+ *   a: int = None
+ *   b: str = None
+ *   def my_method(self, a: int, b: str) -> int:
+ *     return a + b
+ * ```
+ * @remarks
+ *
+ * Any child declarations (methods, fields, nested classes) will be placed
+ * in the class scope. This component creates a class scope to hold its
+ * members.
+ */
+export declare function ClassDeclaration(props: ClassDeclarationProps): Children;
+//# sourceMappingURL=ClassDeclaration.d.ts.map

package/dist/src/components/ClassDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassDeclaration.d.ts","sourceRoot":"","sources":["../../../src/components/ClassDeclaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,oBAAoB,EAGrB,MAAM,kBAAkB,CAAC;AAG1B,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IACjE;;OAEG;IACH,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,YA6C5D"}

package/dist/src/components/ClassDeclaration.js

@@ -0,0 +1,83 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { List, Name, OutputSymbolFlags, Scope, Show, childrenArray, takeSymbols } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { Declaration } from "./Declaration.js";
+import { PythonBlock } from "./PythonBlock.js";
+/**
+ * Create a Python class declaration.
+ *
+ * @example
+ * ```tsx
+ * <ClassDeclaration name="MyClass" bases={["BaseClass"]}>
+ *   <VariableDeclaration name="a" type="int" />
+ *   <VariableDeclaration name="b" type="str" />
+ *   <py.FunctionDeclaration name="my_method" parameters={[{ name: "a", type: "int" }, { name: "b", type: "str" }]} returnType="int">
+ *     return a + b
+ *   </py.FunctionDeclaration>
+ * </ClassDeclaration>
+ * ```
+ * renders to
+ * ```py
+ * class MyClass(BaseClass):
+ *   a: int = None
+ *   b: str = None
+ *   def my_method(self, a: int, b: str) -> int:
+ *     return a + b
+ * ```
+ * @remarks
+ *
+ * Any child declarations (methods, fields, nested classes) will be placed
+ * in the class scope. This component creates a class scope to hold its
+ * members.
+ */
+export function ClassDeclaration(props) {
+  const basesPart = props.bases && ["(", _$createComponent(List, {
+    get children() {
+      return props.bases;
+    },
+    comma: true,
+    space: true
+  }), ")"];
+  const sym = createPythonSymbol(props.name, {
+    refkeys: props.refkey,
+    flags: (props.flags ?? OutputSymbolFlags.None) | OutputSymbolFlags.MemberContainer
+  }, "class", true);
+  takeSymbols(memberSymbol => {
+    // Transform emitted symbols into instance/class members
+    memberSymbol.flags |= OutputSymbolFlags.InstanceMember;
+  });
+
+  // Propagate the name after the name policy was applied
+  const updatedProps = {
+    ...props,
+    name: sym.name,
+    nameKind: "class"
+  };
+  const hasChildren = childrenArray(() => props.children).filter(c => Boolean(c)).length > 0;
+  return _$createComponent(Declaration, {
+    symbol: sym,
+    get children() {
+      return ["class ", _$createComponent(Name, {}), _$createComponent(Scope, {
+        get name() {
+          return updatedProps.name;
+        },
+        kind: "class",
+        get children() {
+          return [basesPart, _$createComponent(PythonBlock, {
+            opener: ":",
+            get children() {
+              return [_$createComponent(Show, {
+                get when() {
+                  return Boolean(props.doc);
+                },
+                get children() {
+                  return props.doc;
+                }
+              }), _$memo(() => hasChildren ? props.children : "pass")];
+            }
+          })];
+        }
+      })];
+    }
+  });
+}

package/dist/src/components/ClassInstantiation.d.ts

@@ -0,0 +1,24 @@
+import { FunctionCallExpressionProps } from "./FunctionCallExpression.jsx";
+export interface ClassInstantiationProps extends FunctionCallExpressionProps {
+}
+/**
+ * Used to create new instances of classes in Python.
+ *
+ * @example
+ * ```tsx
+ * <ClassInstantiation target="MyClass" args={["arg1", "arg2"]} />
+ * ```
+ * This will generate:
+ * ```python
+ * MyClass(arg1, arg2)
+ * ```
+ * @remarks
+ *
+ * It is similar to FunctionCallExpression but specifically for class instantiation.
+ * Args should be a list arguments that can be either simple js values or py.Atoms, which will render as positional arguments,
+ * or py.VariableDeclarations, which will render as named arguments in the call statement. This component will
+ * not check for the correctness of the python grammar and will just work with any children you provide.
+ * It is up to you to ensure that the arguments you provide are valid in the context of a class instantiation.
+ */
+export declare function ClassInstantiation(props: ClassInstantiationProps): import("@alloy-js/core").Children;
+//# sourceMappingURL=ClassInstantiation.d.ts.map

package/dist/src/components/ClassInstantiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassInstantiation.d.ts","sourceRoot":"","sources":["../../../src/components/ClassInstantiation.tsx"],"names":[],"mappings":"AAOA,OAAO,EAEL,2BAA2B,EAC5B,MAAM,8BAA8B,CAAC;AAGtC,MAAM,WAAW,uBAAwB,SAAQ,2BAA2B;CAAG;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,qCAmBhE"}

package/dist/src/components/ClassInstantiation.js

@@ -0,0 +1,35 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { emitSymbol, instantiateTakenMembersTo as instantiateTakenSymbolsTo, OutputSymbolFlags, useContext } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { FunctionCallExpression } from "./FunctionCallExpression.js";
+import { PythonSourceFileContext } from "./SourceFile.js";
+/**
+ * Used to create new instances of classes in Python.
+ *
+ * @example
+ * ```tsx
+ * <ClassInstantiation target="MyClass" args={["arg1", "arg2"]} />
+ * ```
+ * This will generate:
+ * ```python
+ * MyClass(arg1, arg2)
+ * ```
+ * @remarks
+ *
+ * It is similar to FunctionCallExpression but specifically for class instantiation.
+ * Args should be a list arguments that can be either simple js values or py.Atoms, which will render as positional arguments,
+ * or py.VariableDeclarations, which will render as named arguments in the call statement. This component will
+ * not check for the correctness of the python grammar and will just work with any children you provide.
+ * It is up to you to ensure that the arguments you provide are valid in the context of a class instantiation.
+ */
+export function ClassInstantiation(props) {
+  const sfContext = useContext(PythonSourceFileContext);
+  const module = sfContext?.module;
+  const sym = createPythonSymbol("", {
+    flags: OutputSymbolFlags.Transient,
+    module: module
+  }, undefined, false);
+  instantiateTakenSymbolsTo(sym);
+  emitSymbol(sym);
+  return [_$createComponent(FunctionCallExpression, props)];
+}