@alloy-js/python 0.5.0-dev.0 → 0.5.0-dev.2

package/dist/test/pydanticclassdeclarations.test.js

@@ -0,0 +1,773 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Prose, code, refkey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { pydanticModule, pydanticSettingsModule, typingModule } from "../src/builtins/python.js";
+import * as py from "../src/index.js";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
+describe("PydanticClassDeclaration", () => {
+  it("forwards class-level decorators above `class`", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule, typingModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          get decorators() {
+            return [code`@${typingModule["."].final}`];
+          },
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from typing import final
+
+
+        @final
+        class User(BaseModel):
+            id: int
+
+      `);
+  });
+  it("emits a pydantic model with BaseModel, fields, and Field import", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              name: "name",
+              type: "str",
+              get initializer() {
+                return code`${pydanticModule["."].Field}(default="anon")`;
+              }
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import Field
+
+
+        class User(BaseModel):
+            id: int
+            name: str = Field(default="anon")
+
+      `);
+  });
+  it("inherits from another pydantic model via bases", () => {
+    const baseRef = refkey();
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return [_$createComponent(py.PydanticClassDeclaration, {
+              name: "User",
+              refkey: baseRef,
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "id",
+                  type: "int"
+                });
+              }
+            }), _$createComponent(py.PydanticClassDeclaration, {
+              name: "Admin",
+              bases: [baseRef],
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "role",
+                  type: "str"
+                });
+              }
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+
+
+        class User(BaseModel):
+            id: int
+
+        class Admin(User):
+            role: str
+
+      `);
+  });
+  it("supports required, optional, Field default, and plain default", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Item",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "sku",
+              type: "str"
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              name: "notes",
+              get type() {
+                return _$createComponent(py.UnionTypeExpression, {
+                  children: ["str", "None"]
+                });
+              }
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              name: "label",
+              type: "str",
+              get initializer() {
+                return code`${pydanticModule["."].Field}(default="untitled")`;
+              }
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              name: "qty",
+              type: "int",
+              initializer: 1
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import Field
+
+
+        class Item(BaseModel):
+            sku: str
+            notes: str | None = None
+            label: str = Field(default="untitled")
+            qty: int = 1
+
+      `);
+  });
+  it("emits class docstring", () => {
+    const doc = _$createComponent(py.ClassDoc, {
+      get description() {
+        return [_$createComponent(Prose, {
+          children: "Payload for an API request."
+        })];
+      }
+    });
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "RequestBody",
+          doc: doc,
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "value",
+              type: "str"
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+
+
+        class RequestBody(BaseModel):
+            """
+            Payload for an API request.
+            """
+
+            value: str
+
+      `);
+  });
+  it("resolves refkey across files with pydantic imports", () => {
+    const modelRef = refkey();
+    expect(_$createComponent(TestOutputDirectory, {
+      externals: [pydanticModule],
+      get children() {
+        return [_$createComponent(py.SourceFile, {
+          path: "models.py",
+          get children() {
+            return _$createComponent(py.PydanticClassDeclaration, {
+              name: "User",
+              refkey: modelRef,
+              get children() {
+                return _$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "id",
+                  type: "int"
+                });
+              }
+            });
+          }
+        }), _$createComponent(py.SourceFile, {
+          path: "service.py",
+          get children() {
+            return _$createComponent(py.FunctionDeclaration, {
+              name: "load_user",
+              returnType: modelRef,
+              parameters: [{
+                name: "user_id",
+                type: "int"
+              }],
+              children: "return User(id=user_id)"
+            });
+          }
+        })];
+      }
+    })).toRenderTo({
+      "models.py": `
+          from pydantic import BaseModel
+
+
+          class User(BaseModel):
+              id: int
+
+          `,
+      "service.py": `
+          from typing import TYPE_CHECKING
+
+          if TYPE_CHECKING:
+              from models import User
+
+
+          def load_user(user_id: int) -> User:
+              return User(id=user_id)
+
+          `
+    });
+  });
+  it("emits model_config = ConfigDict(...) from top-level config props", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          frozen: true,
+          extra: "forbid",
+          validateAssignment: true,
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+
+
+        class User(BaseModel):
+            model_config = ConfigDict(frozen=True, extra="forbid", validate_assignment=True)
+            id: int
+
+      `);
+  });
+  it("emits model_config = ConfigDict(...) from modelConfig", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          modelConfig: {
+            frozen: true,
+            extra: "forbid",
+            validateAssignment: true
+          },
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+
+
+        class User(BaseModel):
+            model_config = ConfigDict(frozen=True, extra="forbid", validate_assignment=True)
+            id: int
+
+      `);
+  });
+  it("gives precedence to top-level config props over modelConfig", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          modelConfig: {
+            frozen: false,
+            extra: "allow"
+          },
+          frozen: true,
+          extra: "forbid"
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+
+
+        class User(BaseModel):
+            model_config = ConfigDict(frozen=True, extra="forbid")
+
+      `);
+  });
+  it("supports additional typed ConfigDict props", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          useEnumValues: true,
+          coerceNumbersToStr: true,
+          validateReturn: true,
+          strMinLength: 1,
+          strMaxLength: 128,
+          serJsonBytes: "base64",
+          valJsonBytes: "hex"
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+
+
+        class User(BaseModel):
+            model_config = ConfigDict(coerce_numbers_to_str=True, ser_json_bytes="base64", str_min_length=1, str_max_length=128, use_enum_values=True, val_json_bytes="hex", validate_return=True)
+
+      `);
+  });
+  it("imports SecretStr when used as a field type", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Credentials",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "token",
+              get type() {
+                return pydanticModule["."].SecretStr;
+              }
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            from pydantic import SecretStr
+
+
+        class Credentials(BaseModel):
+            token: SecretStr
+
+      `);
+  });
+  it("emits arbitrary model_config via modelConfigExpression", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "M",
+          get modelConfigExpression() {
+            return code`${pydanticModule["."].ConfigDict}(frozen=True, extra="allow")`;
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+
+
+        class M(BaseModel):
+            model_config = ConfigDict(frozen=True, extra="allow")
+
+      `);
+  });
+  it("supports RootModel as explicit bases entry", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Tags",
+          get bases() {
+            return [code`${pydanticModule["."].RootModel}[list[str]]`];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import RootModel
+
+
+        class Tags(RootModel[list[str]]):
+            pass
+
+      `);
+  });
+  it("places Pydantic validators above classmethod", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "name",
+              type: "str"
+            }), _$createComponent(py.ClassMethodDeclaration, {
+              name: "strip_name",
+              get decorators() {
+                return [code`@${pydanticModule["."].field_validator}("name", mode="before")`];
+              },
+              parameters: [{
+                name: "value",
+                type: "str"
+              }],
+              returnType: "str",
+              children: "return value.strip()"
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import field_validator
+
+
+        class User(BaseModel):
+            name: str
+            @field_validator("name", mode="before")
+            @classmethod
+            def strip_name(cls, value: str) -> str:
+                return value.strip()
+
+
+      `);
+  });
+});
+describe("Pydantic ecosystem emitters", () => {
+  it("typing module resolves Any and similar annotations", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [typingModule],
+      get children() {
+        return _$createComponent(py.FunctionDeclaration, {
+          name: "identity",
+          get parameters() {
+            return [{
+              name: "x",
+              type: typingModule["."].Any
+            }];
+          },
+          get returnType() {
+            return typingModule["."].Any;
+          },
+          children: "return x"
+        });
+      }
+    })).toRenderTo(`
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            from typing import Any
+
+
+        def identity(x: Any) -> Any:
+            return x
+
+      `);
+  });
+  it("pydantic.types constrains field annotations", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Score",
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "points",
+              get type() {
+                return pydanticModule.types.PositiveInt;
+              }
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            from pydantic.types import PositiveInt
+
+
+        class Score(BaseModel):
+            points: PositiveInt
+
+      `);
+  });
+  it("postponed annotations support forward references in fields", () => {
+    expect(_$createComponent(TestOutputDirectory, {
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.SourceFile, {
+          path: "models.py",
+          get futureImports() {
+            return [_$createComponent(py.FutureStatement, {
+              feature: "annotations"
+            })];
+          },
+          get children() {
+            return _$createComponent(py.PydanticClassDeclaration, {
+              name: "Node",
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  omitNone: true,
+                  name: "label",
+                  type: "str"
+                }), _$createComponent(py.VariableDeclaration, {
+                  instanceVariable: true,
+                  name: "child",
+                  type: code`"Node" | None`
+                })];
+              }
+            });
+          }
+        });
+      }
+    })).toRenderTo({
+      "models.py": `
+          from __future__ import annotations
+
+          from pydantic import BaseModel
+
+
+          class Node(BaseModel):
+              label: str
+              child: "Node" | None = None
+
+        `
+    });
+  });
+  it("model_config can use pydantic.alias_generators", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "M",
+          get modelConfigExpression() {
+            return code`${pydanticModule["."].ConfigDict}(alias_generator=${pydanticModule.alias_generators.to_camel})`;
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import ConfigDict
+        from pydantic.alias_generators import to_camel
+
+
+        class M(BaseModel):
+            model_config = ConfigDict(alias_generator=to_camel)
+
+      `);
+  });
+  it("pydantic_settings exposes BaseSettings", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "config.py",
+      externals: [pydanticSettingsModule],
+      get children() {
+        return _$createComponent(py.ClassDeclaration, {
+          name: "AppSettings",
+          get bases() {
+            return [pydanticSettingsModule["."].BaseSettings];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic_settings import BaseSettings
+
+
+        class AppSettings(BaseSettings):
+            pass
+
+      `);
+  });
+  it("emits @computed_field above @property via PropertyDeclaration", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Square",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "width",
+              type: "float"
+            }), _$createComponent(py.PropertyDeclaration, {
+              name: "area",
+              type: "float",
+              get decorators() {
+                return [code`@${pydanticModule["."].computed_field}`];
+              },
+              children: "return self.width ** 2"
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import computed_field
+
+
+        class Square(BaseModel):
+            width: float
+            @computed_field
+            @property
+            def area(self) -> float:
+                return self.width ** 2
+
+
+      `);
+  });
+  it("emits computed_field on an instance method", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Square",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "width",
+              type: "float"
+            }), _$createComponent(py.MethodDeclaration, {
+              name: "area",
+              get decorators() {
+                return [code`@${pydanticModule["."].computed_field}`];
+              },
+              returnType: "float",
+              children: "return self.width ** 2"
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import computed_field
+
+
+        class Square(BaseModel):
+            width: float
+            @computed_field
+            def area(self) -> float:
+                return self.width ** 2
+
+
+      `);
+  });
+  it("emits model_validator above classmethod", () => {
+    expect(_$createComponent(TestOutput, {
+      path: "models.py",
+      externals: [pydanticModule],
+      get children() {
+        return _$createComponent(py.PydanticClassDeclaration, {
+          name: "Bag",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "items",
+              type: "list"
+            }), _$createComponent(py.ClassMethodDeclaration, {
+              name: "ensure_items",
+              get decorators() {
+                return [code`@${pydanticModule["."].model_validator}(mode="before")`];
+              },
+              parameters: [{
+                name: "data",
+                type: "dict"
+              }],
+              returnType: "dict",
+              children: "return data"
+            })];
+          }
+        });
+      }
+    })).toRenderTo(`
+        from pydantic import BaseModel
+        from pydantic import model_validator
+
+
+        class Bag(BaseModel):
+            items: list
+            @model_validator(mode="before")
+            @classmethod
+            def ensure_items(cls, data: dict) -> dict:
+                return data
+
+
+      `);
+  });
+});
+//# sourceMappingURL=pydanticclassdeclarations.test.js.map