@alloy-js/python 0.0.1

package/dist/src/components/FunctionCallExpression.js

@@ -0,0 +1,40 @@
+import { memo as _$memo, createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { For, Indent, Wrap } from "@alloy-js/core";
+/**
+ * A Python function call expression.
+ *
+ * @example
+ * ```tsx
+ * <FunctionCallExpression target="foo" args={["arg1", "arg2"]} />
+ * ```
+ * This will generate:
+ * ```python
+ * foo(arg1, arg2)
+ * ```
+ */
+export function FunctionCallExpression(props) {
+  return _$createIntrinsic("group", {
+    get children() {
+      return [_$memo(() => props.target), "(", _$createComponent(Wrap, {
+        get when() {
+          return !!props.args && props.args.length > 1;
+        },
+        "with": Indent,
+        props: {
+          softline: true,
+          trailingBreak: true
+        },
+        get children() {
+          return _$createComponent(For, {
+            get each() {
+              return props.args ?? [];
+            },
+            comma: true,
+            line: true,
+            children: arg => arg
+          });
+        }
+      }), ")"];
+    }
+  });
+}

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

@@ -0,0 +1,47 @@
+import { CallSignatureProps } from "./CallSignature.jsx";
+import { BaseDeclarationProps } from "./Declaration.js";
+export interface FunctionDeclarationProps extends BaseDeclarationProps, CallSignatureProps {
+    async?: boolean;
+}
+/**
+ * A Python function declaration.
+ *
+ * @example
+ * ```tsx
+ * <FunctionDeclaration
+ *  name="my_function"
+ *  returnType="int"
+ *  parameters=[{name: "a", type: "int"},{name: "b", type: "str"}]>
+ *   return a + b
+ * </FunctionDeclaration>
+ * ```
+ * This will generate:
+ * ```python
+ * def my_function(a: int, b: str) -> int:
+ *   return a + b
+ * ```
+ */
+export declare function FunctionDeclaration(props: FunctionDeclarationProps): import("@alloy-js/core").Children;
+/**
+ * A Python `__init__` function declaration.
+ *
+ * @example
+ * ```tsx
+ * <InitFunctionDeclaration>
+ *   self.attribute = "value"
+ * </InitFunctionDeclaration>
+ * ```
+ * This will generate:
+ * ```python
+ * def __init__(self: MyClass) -> None:
+ *     self.attribute = "value"
+ * ```
+ *
+ * @remarks
+ *
+ * This is a convenience component that sets the name to `__init__`, marks it as
+ * an instance function, and forces the name to be `__init__` without applying
+ * the name policy.
+ */
+export declare function InitFunctionDeclaration(props: Omit<FunctionDeclarationProps, "name" | "instanceFunction" | "classFunction">): import("@alloy-js/core").Children;
+//# sourceMappingURL=FunctionDeclaration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionDeclaration.d.ts","sourceRoot":"","sources":["../../../src/components/FunctionDeclaration.tsx"],"names":[],"mappings":"AAYA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAe,MAAM,kBAAkB,CAAC;AAIrE,MAAM,WAAW,wBACf,SAAQ,oBAAoB,EAC1B,kBAAkB;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,qCAwClE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,IAAI,CACT,wBAAwB,EACxB,MAAM,GAAG,kBAAkB,GAAG,eAAe,CAC9C,qCAYF"}

package/dist/src/components/FunctionDeclaration.js

@@ -0,0 +1,107 @@
+import { createComponent as _$createComponent, mergeProps as _$mergeProps, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { emitSymbol, Name, OutputSymbolFlags, Scope, Show, useMemberScope, useScope } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { getCallSignatureProps } from "../utils.js";
+import { CallSignature } from "./CallSignature.js";
+import { Declaration } from "./Declaration.js";
+import { PythonBlock } from "./PythonBlock.js";
+import { NoNamePolicy } from "./index.js";
+/**
+ * A Python function declaration.
+ *
+ * @example
+ * ```tsx
+ * <FunctionDeclaration
+ *  name="my_function"
+ *  returnType="int"
+ *  parameters=[{name: "a", type: "int"},{name: "b", type: "str"}]>
+ *   return a + b
+ * </FunctionDeclaration>
+ * ```
+ * This will generate:
+ * ```python
+ * def my_function(a: int, b: str) -> int:
+ *   return a + b
+ * ```
+ */
+export function FunctionDeclaration(props) {
+  const asyncKwd = props.async ? "async " : "";
+  const callSignatureProps = getCallSignatureProps(props, {});
+  const memberScope = useMemberScope();
+  let scope = undefined;
+  if (memberScope !== undefined) {
+    scope = memberScope.instanceMembers;
+  } else {
+    scope = useScope();
+  }
+  const sym = createPythonSymbol(props.name, {
+    scope: scope,
+    refkeys: props.refkey,
+    flags: props.flags ?? OutputSymbolFlags.None
+  }, "function", false);
+  emitSymbol(sym);
+  return [_$createComponent(Declaration, _$mergeProps(props, {
+    nameKind: "function",
+    symbol: sym,
+    get children() {
+      return [asyncKwd, "def ", _$createComponent(Name, {}), _$createComponent(Scope, {
+        get name() {
+          return sym.name;
+        },
+        kind: "function",
+        get children() {
+          return [_$createComponent(CallSignature, _$mergeProps(callSignatureProps, {
+            get returnType() {
+              return props.returnType;
+            }
+          })), _$createComponent(PythonBlock, {
+            opener: ":",
+            get children() {
+              return [_$createComponent(Show, {
+                get when() {
+                  return Boolean(props.doc);
+                },
+                get children() {
+                  return props.doc;
+                }
+              }), _$memo(() => props.children ?? "pass")];
+            }
+          })];
+        }
+      })];
+    }
+  }))];
+}
+
+/**
+ * A Python `__init__` function declaration.
+ *
+ * @example
+ * ```tsx
+ * <InitFunctionDeclaration>
+ *   self.attribute = "value"
+ * </InitFunctionDeclaration>
+ * ```
+ * This will generate:
+ * ```python
+ * def __init__(self: MyClass) -> None:
+ *     self.attribute = "value"
+ * ```
+ *
+ * @remarks
+ *
+ * This is a convenience component that sets the name to `__init__`, marks it as
+ * an instance function, and forces the name to be `__init__` without applying
+ * the name policy.
+ */
+export function InitFunctionDeclaration(props) {
+  return _$createComponent(NoNamePolicy, {
+    get children() {
+      return _$createComponent(FunctionDeclaration, _$mergeProps(props, {
+        name: "__init__",
+        instanceFunction: true,
+        classFunction: false
+      }));
+    }
+  });
+}

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

@@ -0,0 +1,39 @@
+import { ImportedSymbol, ImportRecords } from "../symbols/index.js";
+export interface ImportStatementsProps {
+    records: ImportRecords;
+    joinImportsFromSameModule?: boolean;
+}
+/**
+ * A component that renders import statements based on the provided import records.
+ *
+ * @remarks
+ * This component will render import statements for each module and its symbols.
+ * If `joinImportsFromSameModule` is true, it will group imports from the same module
+ * into a single statement.
+ */
+export declare function ImportStatements(props: ImportStatementsProps): () => import("@alloy-js/core").Children[];
+export interface ImportStatementProps {
+    path: string;
+    symbols?: Set<ImportedSymbol>;
+}
+/**
+ * A Python import statement.
+ *
+ * @remarks
+ * This component renders an import statement for a given path and symbols.
+ * If no symbols are provided, it will render a simple import statement.
+ * If symbols are provided, it will render an import statement with the specified symbols.
+ *
+ * @example
+ * ```tsx
+ * <ImportStatement path="os" />
+ * <ImportStatement path="math" symbols={new Set([new ImportedSymbol("sqrt", "sqrt")])} />
+ * ```
+ * This will generate:
+ * ```python
+ * import os
+ * from math import sqrt
+ * ```
+ */
+export declare function ImportStatement(props: ImportStatementProps): () => any[];
+//# sourceMappingURL=ImportStatement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImportStatement.d.ts","sourceRoot":"","sources":["../../../src/components/ImportStatement.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,aAAa,CAAC;IACvB,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,6CA2C5D;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,eA8B1D"}

package/dist/src/components/ImportStatement.js

@@ -0,0 +1,104 @@
+import { createComponent as _$createComponent, memo as _$memo, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { computed, mapJoin, memo } from "@alloy-js/core";
+/**
+ * A component that renders import statements based on the provided import records.
+ *
+ * @remarks
+ * This component will render import statements for each module and its symbols.
+ * If `joinImportsFromSameModule` is true, it will group imports from the same module
+ * into a single statement.
+ */
+export function ImportStatements(props) {
+  // Sort the import records by module name
+  const imports = computed(() => [...props.records].sort(([a], [b]) => {
+    return a.name.localeCompare(b.name);
+  }));
+  return mapJoin(() => imports.value, ([module, properties]) => {
+    // Only handling absolute imports for now
+    const targetPath = module.name;
+    if (properties.symbols && properties.symbols.size > 0) {
+      // Sort the symbols in a module by the imported name
+      const sortedSymbols = Array.from(properties.symbols).sort((a, b) => a.local.name.localeCompare(b.local.name));
+      if (props.joinImportsFromSameModule) {
+        // If joinImportsFromSameModule is true, we will group imports from the same module
+        return _$createComponent(ImportStatement, {
+          path: targetPath,
+          symbols: new Set(sortedSymbols)
+        });
+      } else {
+        return sortedSymbols.map((symbol, idx, arr) => [_$createComponent(ImportStatement, {
+          path: targetPath,
+          symbols: new Set([symbol])
+        }), _$memo(() => _$memo(() => idx < arr.length - 1)() && _$createIntrinsic("hbr", {}))]);
+      }
+    } else {
+      // If no symbols are specified, it's either a wildcard import or a module import
+      return _$createComponent(ImportStatement, {
+        path: targetPath,
+        get symbols() {
+          return properties.symbols;
+        }
+      });
+    }
+  });
+}
+/**
+ * A Python import statement.
+ *
+ * @remarks
+ * This component renders an import statement for a given path and symbols.
+ * If no symbols are provided, it will render a simple import statement.
+ * If symbols are provided, it will render an import statement with the specified symbols.
+ *
+ * @example
+ * ```tsx
+ * <ImportStatement path="os" />
+ * <ImportStatement path="math" symbols={new Set([new ImportedSymbol("sqrt", "sqrt")])} />
+ * ```
+ * This will generate:
+ * ```python
+ * import os
+ * from math import sqrt
+ * ```
+ */
+export function ImportStatement(props) {
+  return memo(() => {
+    const {
+      path,
+      symbols
+    } = props;
+    const importSymbols = [];
+    if (symbols && symbols.size > 0) {
+      for (const sym of symbols) {
+        importSymbols.push(sym);
+      }
+    }
+    const parts = [];
+    if (!symbols || symbols.size === 0) {
+      parts.push(`import ${path}`);
+    } else {
+      importSymbols.sort((a, b) => {
+        return a.target.name.localeCompare(b.target.name);
+      });
+      parts.push(`from ${path} import `);
+      parts.push(mapJoin(() => importSymbols, nis => _$createComponent(ImportBinding, {
+        importedSymbol: nis
+      }), {
+        joiner: ", "
+      }));
+    }
+    return parts;
+  });
+}
+function ImportBinding(props) {
+  const text = memo(() => {
+    const localName = props.importedSymbol.local.name;
+    const targetName = props.importedSymbol.target.name;
+    if (localName === targetName) {
+      return targetName;
+    } else {
+      return `${targetName} as ${localName}`;
+    }
+  });
+  return [_$memo(text)];
+}

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

@@ -0,0 +1,97 @@
+import { Children, OutputSymbol, Refkey } from "@alloy-js/core";
+export interface MemberExpressionProps {
+    children: Children;
+}
+/**
+ * Create a member expression from parts. Each part can provide one of
+ * the following:
+ *
+ * * **id**: The identifier for the member expression part
+ * * **refkey**: a refkey for a symbol whose name becomes the identifier
+ * * **symbol**: a symbol whose name becomes the identifier part
+ * * **args**: create a method call with the given args
+ * * **children**: arbitrary contents for the identifier part.
+ *
+ * @example
+ *
+ * ```tsx
+ * <MemberExpression>
+ *   <MemberExpression.Part id="base" />
+ *   <MemberExpression.Part refkey={rk} />
+ *   <MemberExpression.Part symbol={sym} />
+ *   <MemberExpression.Part args={["hello", "world"]} />
+ *   <MemberExpression.Part>SomeValue</MemberExpression.Part>
+ * </MemberExpression>
+ * ```
+ *
+ * Assuming `rk` is a refkey to a symbol name "prop1", and `sym` is a symbol
+ * with a name of "prop2", this will render:
+ *
+ * ```ts
+ * base.prop1.prop2("hello", "world").SomeValue
+ * ```
+ */
+export declare function MemberExpression(props: MemberExpressionProps): Children;
+export declare namespace MemberExpression {
+    var Part: (props: MemberExpressionPartProps) => void;
+}
+export interface MemberExpressionPartProps {
+    /**
+     * The identifier for attribute access (obj.attr).
+     * Use this for Python attribute references.
+     */
+    id?: string | number;
+    /**
+     * Single key for subscription access (obj[key] or obj[0]).
+     * Use this for single subscription access.
+     */
+    key?: Children;
+    /**
+     * Multiple keys for tuple subscription access (obj[a, b] -\> obj[(a, b)]).
+     * Use this when you need tuple key access.
+     */
+    keys?: Children[];
+    /**
+     * Slice notation for subscription access (obj[start:stop:step]).
+     * Use this for Python slice syntax.
+     */
+    slice?: {
+        start?: Children;
+        stop?: Children;
+        step?: Children;
+    };
+    /**
+     * A refkey for a symbol whose name becomes the identifier.
+     */
+    refkey?: Refkey;
+    /**
+     * A symbol whose name becomes the identifier.
+     */
+    symbol?: OutputSymbol;
+    /**
+     * Arguments to construct a call expression.
+     */
+    args?: Children[] | boolean;
+}
+export interface SubscriptionProps {
+    /**
+     * Single key for subscription access (obj[key] or obj[0]).
+     * Use this for single subscription access.
+     */
+    key?: Children;
+    /**
+     * Multiple keys for tuple subscription access (obj[a, b] -\> obj[(a, b)]).
+     * Use this when you need tuple key access.
+     */
+    keys?: Children[];
+    /**
+     * Slice notation for subscription access (obj[start:stop:step]).
+     * Use this for Python slice syntax.
+     */
+    slice?: {
+        start?: Children;
+        stop?: Children;
+        step?: Children;
+    };
+}
+//# sourceMappingURL=MemberExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemberExpression.d.ts","sourceRoot":"","sources":["../../../src/components/MemberExpression.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAGZ,MAAM,EAKP,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,QAAQ,CAcvE;yBAde,gBAAgB;sBA8RS,yBAAyB;;AArDlE,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAErB;;;OAGG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,QAAQ,CAAC;QACjB,IAAI,CAAC,EAAE,QAAQ,CAAC;QAChB,IAAI,CAAC,EAAE,QAAQ,CAAC;KACjB,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,IAAI,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;CAC7B;AA4CD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,QAAQ,CAAC;QACjB,IAAI,CAAC,EAAE,QAAQ,CAAC;QAChB,IAAI,CAAC,EAAE,QAAQ,CAAC;KACjB,CAAC;CACH"}