@typespec/emitter-framework 0.15.0-dev.2 → 0.15.0-dev.4

package/src/python/components/atom/atom.test.tsx

@@ -0,0 +1,244 @@
+import { getOutput } from "#python/test-utils.js";
+import { Tester } from "#test/test-host.js";
+import { type Model, type Program, type Value } from "@typespec/compiler";
+import { t } from "@typespec/compiler/testing";
+import { $ } from "@typespec/compiler/typekit";
+import { assert, beforeAll, describe, expect, it } from "vitest";
+import { Atom } from "../../index.js";
+
+let program: Program;
+
+beforeAll(async () => {
+  const result = await Tester.compile("");
+  program = result.program;
+});
+
+describe("NullValue", () => {
+  it("null value", async () => {
+    const value = { entityKind: "Value", valueKind: "NullValue", value: null } as Value;
+
+    await testValueExpression(value, `None`);
+  });
+});
+
+describe("StringValue", () => {
+  it("normal string", async () => {
+    const value = $(program).value.createString("test");
+
+    await testValueExpression(value, `"test"`);
+  });
+
+  it("empty string", async () => {
+    const value = $(program).value.createString("");
+
+    await testValueExpression(value, `""`);
+  });
+});
+
+describe("BooleanValue", () => {
+  it("True", async () => {
+    const value = $(program).value.createBoolean(true);
+
+    await testValueExpression(value, `True`);
+  });
+
+  it("False", async () => {
+    const value = $(program).value.createBoolean(false);
+
+    await testValueExpression(value, `False`);
+  });
+});
+
+describe("NumericValue", () => {
+  it("integers", async () => {
+    const value = $(program).value.createNumeric(42);
+
+    await testValueExpression(value, `42`);
+  });
+
+  it("decimals", async () => {
+    const fractional = $(program).value.createNumeric(42.5);
+    await testValueExpression(fractional, `42.5`);
+  });
+
+  it("decimals with .0", async () => {
+    // Generic Atom (no hint) normalizes 42.0 to 42 because it uses asNumber()
+    const value = $(program).value.createNumeric(42.0);
+    await testValueExpression(value, `42`);
+  });
+
+  it("decimals with .0 when float", async () => {
+    const value = $(program).value.createNumeric(42.0);
+    expect(getOutput(program, [<Atom value={value} float />])).toRenderTo(`42.0`);
+  });
+
+  it("negative integers", async () => {
+    const value = $(program).value.createNumeric(-42);
+    await testValueExpression(value, `-42`);
+  });
+
+  it("negative decimals", async () => {
+    const value = $(program).value.createNumeric(-42.5);
+    await testValueExpression(value, `-42.5`);
+  });
+
+  it("zero", async () => {
+    const value = $(program).value.createNumeric(0);
+    await testValueExpression(value, `0`);
+  });
+
+  it("zero with float", async () => {
+    const value = $(program).value.createNumeric(0);
+    expect(getOutput(program, [<Atom value={value} float />])).toRenderTo(`0.0`);
+  });
+
+  it("exponent that resolves to integer", async () => {
+    const value = $(program).value.createNumeric(1e3);
+    await testValueExpression(value, `1000`);
+  });
+
+  it("exponent that resolves to integer with float", async () => {
+    const value = $(program).value.createNumeric(1e3);
+    expect(getOutput(program, [<Atom value={value} float />])).toRenderTo(`1000.0`);
+  });
+
+  it("small decimal via exponent", async () => {
+    const value = $(program).value.createNumeric(1e-3);
+    await testValueExpression(value, `0.001`);
+  });
+});
+
+describe("ArrayValue", () => {
+  it("empty", async () => {
+    // Can be replaced with TypeKit once #6976 is implemented
+    const value = {
+      entityKind: "Value",
+      valueKind: "ArrayValue",
+      values: [],
+    } as unknown as Value;
+    await testValueExpression(value, `[]`);
+  });
+
+  it("with mixed values", async () => {
+    // Can be replaced with TypeKit once #6976 is implemented
+    const value = {
+      entityKind: "Value",
+      valueKind: "ArrayValue",
+      values: [
+        $(program).value.createString("some_text"),
+        $(program).value.createNumeric(42),
+        $(program).value.createBoolean(true),
+        {
+          entityKind: "Value",
+          valueKind: "ArrayValue",
+          values: [
+            $(program).value.createNumeric(1),
+            $(program).value.createNumeric(2),
+            $(program).value.createNumeric(3),
+          ],
+        } as Value,
+      ],
+    } as Value;
+    await testValueExpression(value, `["some_text", 42, True, [1, 2, 3]]`);
+  });
+});
+
+describe("ScalarValue", () => {
+  it("utcDateTime.fromISO correctly supplied", async () => {
+    const { minDate } = await Tester.compile(t.code`
+      model ${t.model("DateRange")} {
+        @encode("rfc7231")
+        ${t.modelProperty("minDate")}: ${t.type("utcDateTime")} = utcDateTime.fromISO("2024-02-15T18:36:03Z");
+      }
+    `);
+    await testValueExpression(
+      minDate.defaultValue!,
+      `from datetime import datetime
+from datetime import timezone
+
+
+datetime(2024, 2, 15, 18, 36, 3, tzinfo=timezone.utc)`,
+    );
+  });
+
+  it("Unsupported scalar constructor", async () => {
+    const { IpAddress } = await Tester.compile(t.code`
+        scalar ${t.scalar("ipv4")} extends ${t.scalar("string")} {
+          init fromInt(value: uint32);
+        }
+
+        @example (#{ip: ipv4.fromInt(2130706433)})
+        model ${t.model("IpAddress")} {
+          ${t.modelProperty("ip")}: ${t.type("ipv4")};
+        }
+      `);
+
+    const value = getExampleValue(IpAddress);
+    await expect(testValueExpression(value, ``)).rejects.toThrow(
+      /Unsupported scalar constructor fromInt/,
+    );
+  });
+});
+
+describe("ObjectValue", () => {
+  it("empty object", async () => {
+    // Can be replaced with TypeKit once #6976 is implemented
+    const { ObjectValue } = await Tester.compile(t.code`
+        @example(#{})
+        model ${t.model("ObjectValue")} {};
+      `);
+
+    const value = getExampleValue(ObjectValue);
+    await testValueExpression(value, `{}`);
+  });
+
+  it("object with properties", async () => {
+    // Can be replaced with TypeKit once #6976 is implemented
+    const { ObjectValue } = await Tester.compile(t.code`
+        @example(#{aNumber: 5, aString: "foo", aBoolean: true})
+        model ${t.model("ObjectValue")} {
+          ${t.modelProperty("aNumber")}: int32;
+          ${t.modelProperty("aString")}: string;
+          ${t.modelProperty("aBoolean")}: boolean;
+        };
+      `);
+    const value = getExampleValue(ObjectValue);
+    await testValueExpression(value, `{"aNumber": 5, "aString": "foo", "aBoolean": True}`);
+  });
+});
+
+describe("EnumValue", () => {
+  it("different EnumValue types", async () => {
+    // Can be replaced with TypeKit once #6976 is implemented
+    const { Red, Green, Blue } = await Tester.compile(t.code`
+        enum ${t.enum("Color")} {
+          Red,
+          Green: 3,
+          Blue: "cyan",
+        }
+        const ${t.value("Red")} = ${t.enumValue("Color.Red")};
+        const ${t.value("Green")} = ${t.enumValue("Color.Green")};
+        const ${t.value("Blue")} = ${t.enumValue("Color.Blue")};
+      `);
+
+    await testValueExpression(Red, `"Red"`);
+    await testValueExpression(Green, `3`);
+    await testValueExpression(Blue, `"cyan"`);
+  });
+});
+
+/**
+ * Helper that renders a value expression and checks the output against the expected value.
+ */
+async function testValueExpression(value: Value, expected: string) {
+  expect(getOutput(program, [<Atom value={value} />])).toRenderTo(`${expected}`);
+}
+
+/**
+ * Extracts the value marked with the @example decorator from a model.
+ */
+function getExampleValue(model: Model): Value {
+  const decorator = model?.decorators.find((d) => d.definition?.name === "@example");
+  assert.exists(decorator?.args[0]?.value, "unable to find example decorator");
+  return decorator.args[0].value as Value;
+}

package/src/python/components/atom/atom.tsx

@@ -0,0 +1,95 @@
+import { type Children } from "@alloy-js/core";
+import * as py from "@alloy-js/python";
+import { compilerAssert, type Value } from "@typespec/compiler";
+import { datetimeModule } from "../../builtins.js";
+
+/**
+ * Base properties for the {@link Atom} component.
+ */
+interface BaseAtomProps {
+  /**
+   * The TypeSpec value to be converted to a Python expression.
+   */
+  value: Value;
+}
+
+/**
+ * Properties for the {@link Atom} component when dealing with numeric values.
+ */
+interface NumericAtomProps extends BaseAtomProps {
+  /**
+   * Hint that this numeric value should be emitted as a float (e.g., 42 -> 42.0).
+   * Only affects NumericValue.
+   */
+  float?: boolean;
+}
+
+/**
+ * All possible properties for the {@link Atom} component.
+ */
+type AtomProps = BaseAtomProps | NumericAtomProps;
+
+/**
+ * Generates a Python atom from a TypeSpec value.
+ * @param props properties for the atom
+ * @returns {@link Children} representing the Python value expression
+ */
+export function Atom(props: Readonly<AtomProps>): Children {
+  switch (props.value.valueKind) {
+    case "StringValue":
+    case "BooleanValue":
+    case "NullValue":
+      return <py.Atom jsValue={props.value.value} />;
+    case "NumericValue": {
+      const num = props.value.value.asNumber();
+      const isNonInteger = num != null && !Number.isInteger(num);
+      const numericProps = props as NumericAtomProps;
+      const asFloat = isNonInteger || numericProps.float;
+      return <py.Atom jsValue={num} asFloat={asFloat} />;
+    }
+    case "ArrayValue":
+      return (
+        <py.Atom
+          jsValue={props.value.values.map((v) => (
+            <Atom value={v} />
+          ))}
+        />
+      );
+    case "ScalarValue":
+      compilerAssert(
+        props.value.value.name === "fromISO",
+        `Unsupported scalar constructor ${props.value.value.name}`,
+        props.value,
+      );
+      return handleISOStringValue(props.value);
+    case "ObjectValue":
+      const jsProperties: Record<string, Children> = {};
+      for (const [key, value] of props.value.properties) {
+        jsProperties[key] = Atom({ value: value.value });
+      }
+      return <py.Atom jsValue={jsProperties} />;
+    case "EnumValue":
+      return <py.Atom jsValue={props.value.value.value ?? props.value.value.name} />;
+  }
+}
+
+/**
+ * Handles the conversion of ISO date strings to Python datetime objects.
+ * @param value the TypeSpec value containing the ISO string
+ * @returns {@link Children} representing the Python datetime expression
+ */
+function handleISOStringValue(value: Value & { valueKind: "ScalarValue" }): Children {
+  const arg0 = value.value.args[0];
+  if (arg0.valueKind !== "StringValue") {
+    throw new Error("Expected arg0 to be a StringValue");
+  }
+  const isoString = arg0.value;
+  const date = new Date(isoString);
+  return (
+    <>
+      {datetimeModule["."]["datetime"]}({date.getUTCFullYear()}, {date.getUTCMonth() + 1},{" "}
+      {date.getUTCDate()}, {date.getUTCHours()}, {date.getUTCMinutes()}, {date.getUTCSeconds()},
+      tzinfo={datetimeModule["."]["timezone"]}.utc)
+    </>
+  );
+}

package/src/python/components/atom/index.ts

@@ -0,0 +1 @@
+export * from "./atom.js";

package/src/python/components/class-declaration/class-bases.tsx

@@ -0,0 +1,92 @@
+import { abcModule } from "#python/builtins.js";
+import { type Children } from "@alloy-js/core";
+import * as py from "@alloy-js/python";
+import { isTemplateDeclarationOrInstance, type Interface, type Model } from "@typespec/compiler";
+import { useTsp } from "../../../core/context/tsp-context.js";
+import { efRefkey } from "../../utils/refkey.js";
+import { TypeExpression } from "../type-expression/type-expression.js";
+
+export interface ClassBasesProps {
+  /**
+   * The TypeSpec type to derive bases from. If not provided, only explicit bases are used.
+   */
+  type?: Model | Interface;
+
+  /**
+   * Explicit base classes to include.
+   */
+  bases?: Children[];
+
+  /**
+   * Whether the class is abstract. If true, ABC is added to the bases.
+   */
+  abstract?: boolean;
+
+  /**
+   * Additional bases to include (e.g., for future Generic[T] support).
+   */
+  extraBases?: Children[];
+}
+
+/**
+ * Computes the base classes for a Python class declaration.
+ *
+ * Combines:
+ * - Explicit bases from props
+ * - Type-derived bases (from TypeSpec model inheritance):
+ *   - Template instances (e.g., `Response<string>` → `Response[str]`)
+ *   - Regular models (e.g., `BaseWidget`) via py.Reference
+ *   - Arrays via TypeExpression for `typing.Sequence[T]` rendering
+ *   - Records are not supported and ignored
+ * - Extra bases (for future generics support)
+ * - ABC if abstract (always last for proper Python MRO)
+ *
+ * For interfaces, type-derived bases are empty because TypeSpec flattens interface inheritance.
+ *
+ * @returns Array of base class Children, or empty array if none.
+ *
+ * @example
+ * ```tsx
+ * const bases = ClassBases({ type: model, abstract: true });
+ * <py.ClassDeclaration bases={bases.length ? bases : undefined} />
+ * ```
+ */
+export function ClassBases(props: ClassBasesProps): Children[] {
+  const { $ } = useTsp();
+  const extraBases = [...(props.extraBases ?? [])];
+
+  // Add extends/inheritance from the TypeSpec type if present
+  if (props.type && $.model.is(props.type)) {
+    const type = props.type;
+
+    if (type.baseModel) {
+      if ($.array.is(type.baseModel)) {
+        extraBases.push(<TypeExpression type={type.baseModel} />);
+      } else if ($.record.is(type.baseModel)) {
+        // Record-based scenarios are not supported, do nothing here
+      } else if (isTemplateDeclarationOrInstance(type.baseModel)) {
+        // Template type (declaration or instance) - needs TypeExpression for type parameter handling
+        extraBases.push(<TypeExpression type={type.baseModel} />);
+      } else {
+        // Regular model - use py.Reference for proper symbol resolution
+        extraBases.push(<py.Reference refkey={efRefkey(type.baseModel)} />);
+      }
+    }
+
+    // Handle index types: Arrays (int indexes) are supported, Records are not
+    const indexType = $.model.getIndexType(type);
+    if (indexType && !$.record.is(indexType)) {
+      extraBases.push(<TypeExpression type={indexType} />);
+    }
+  }
+
+  // Combine explicit bases from props with extraBases (Generic, extends, etc.)
+  const allBases = (props.bases ?? []).concat(extraBases);
+
+  // For abstract classes, always include ABC (last for proper MRO)
+  if (props.abstract) {
+    return [...allBases, abcModule["."]["ABC"]];
+  }
+
+  return allBases;
+}

package/src/python/components/class-declaration/class-body.tsx

@@ -0,0 +1,56 @@
+import { For, type Children } from "@alloy-js/core";
+import { type Interface, type Model, type ModelProperty, type Operation } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
+import { createRekeyableMap } from "@typespec/compiler/utils";
+import { useTsp } from "../../../core/context/tsp-context.js";
+import { ClassMember } from "./class-member.js";
+
+export interface ClassBodyProps {
+  type: Model | Interface;
+  abstract?: boolean;
+  methodType?: "method" | "class" | "static";
+  children?: Children;
+}
+
+/**
+ * Gets type members (properties or operations) from a Model or Interface.
+ */
+function getTypeMembers($: Typekit, type: Model | Interface): (ModelProperty | Operation)[] {
+  if ($.model.is(type)) {
+    return Array.from($.model.getProperties(type).values());
+  } else if (type.kind === "Interface") {
+    return Array.from(createRekeyableMap(type.operations).values());
+  } else {
+    throw new Error("Expected Model or Interface type");
+  }
+}
+
+/**
+ * Renders the body of a class declaration.
+ * For models, renders properties as dataclass fields.
+ * For interfaces, renders operations as abstract methods.
+ * Includes any additional children provided.
+ */
+export function ClassBody(props: ClassBodyProps): Children {
+  const { $ } = useTsp();
+  const typeMembers = getTypeMembers($, props.type);
+
+  // Throw error for models with additional properties (Record-based scenarios)
+  if ($.model.is(props.type)) {
+    const additionalPropsRecord = $.model.getAdditionalPropertiesRecord(props.type);
+    if (additionalPropsRecord) {
+      throw new Error("Models with additional properties (Record[…]) are not supported");
+    }
+  }
+
+  return (
+    <>
+      <For each={typeMembers} line>
+        {(typeMember) => (
+          <ClassMember type={typeMember} abstract={props.abstract} methodType={props.methodType} />
+        )}
+      </For>
+      {props.children}
+    </>
+  );
+}