cadwyn 3.15.10__py3-none-any.whl → 4.0.0__py3-none-any.whl

cadwyn/__init__.py

@@ -1,22 +1,39 @@
 import importlib.metadata
 
 from .applications import Cadwyn
-from .codegen import generate_code_for_versioned_packages
-from .route_generation import (
-    InternalRepresentationOf,  # pyright: ignore[reportDeprecated]
-    VersionedAPIRouter,
-    generate_versioned_routers,
+from .route_generation import VersionedAPIRouter, generate_versioned_routers
+from .schema_generation import migrate_response_body
+from .structure import (
+    HeadVersion,
+    RequestInfo,
+    ResponseInfo,
+    Version,
+    VersionBundle,
+    VersionChange,
+    VersionChangeWithSideEffects,
+    convert_request_to_next_version_for,
+    convert_response_to_previous_version_for,
+    endpoint,
+    enum,
+    schema,
 )
-from .structure import HeadVersion, Version, VersionBundle
 
 __version__ = importlib.metadata.version("cadwyn")
 __all__ = [
     "Cadwyn",
     "VersionedAPIRouter",
-    "generate_code_for_versioned_packages",
     "VersionBundle",
     "HeadVersion",
     "Version",
+    "migrate_response_body",
     "generate_versioned_routers",
-    "InternalRepresentationOf",
+    "VersionChange",
+    "VersionChangeWithSideEffects",
+    "endpoint",
+    "schema",
+    "enum",
+    "convert_response_to_previous_version_for",
+    "convert_request_to_next_version_for",
+    "RequestInfo",
+    "ResponseInfo",
 ]

cadwyn/__main__.py

@@ -1,13 +1,14 @@
-import importlib
-import sys
-import warnings
-from pathlib import Path
-from typing import Any
+from datetime import date
+from typing import Annotated
 
 import typer
+from rich.console import Console
+from rich.syntax import Syntax
 
-from cadwyn.exceptions import CadwynError
-from cadwyn.structure.versions import VersionBundle
+from cadwyn._render import render_model_by_path, render_module_by_path
+
+_CONSOLE = Console()
+_RAW_ARG = Annotated[bool, typer.Option(help="Output code without color")]
 
 app = typer.Typer(
     name="cadwyn",
@@ -15,6 +16,14 @@ app = typer.Typer(
     help="Modern Stripe-like API versioning in FastAPI",
 )
 
+render_subapp = typer.Typer(
+    name="render",
+    add_completion=False,
+    help="Render pydantic models and enums from a certainn version and output them to stdout",
+)
+
+app.add_typer(render_subapp)
+
 
 def version_callback(value: bool):
     if value:
@@ -24,92 +33,39 @@ def version_callback(value: bool):
         raise typer.Exit
 
 
-@app.command(name="generate-code-for-versioned-packages", hidden=True)
-def deprecated_generate_versioned_packages(
-    path_to_template_package: str = typer.Argument(
-        ...,
-        help=(
-            "The python path to the template package, from which we will generate the versioned packages. "
-            "Format: 'path.to.template_package'"
-        ),
-        show_default=False,
-    ),
-    full_path_to_version_bundle: str = typer.Argument(
-        ...,
-        help="The python path to the version bundle. Format: 'path.to.version_bundle:my_version_bundle_variable'",
-        show_default=False,
-    ),
-    ignore_coverage_for_latest_aliases: bool = typer.Option(
-        default=True,
-        help="Add a pragma: no cover comment to the star imports in the generated version of the latest module.",
-    ),
+def output_code(code: str, raw: bool):
+    if raw:
+        typer.echo(code)
+    else:
+        _CONSOLE.print(Syntax(code, "python", line_numbers=True))
+
+
+@render_subapp.command(
+    name="model",
+    help="Render a concrete pydantic model or enum from a certain version and output it to stdout",
+    short_help="Render a single model or enum",
+)
+def render(
+    model: Annotated[str, typer.Argument(metavar="<module>:<attribute>", help="Python path to the model to render")],
+    app: Annotated[str, typer.Option(metavar="<module>:<attribute>", help="Python path to the main Cadwyn app")],
+    version: Annotated[str, typer.Option(parser=lambda s: str(date.fromisoformat(s)), metavar="ISO-VERSION")],
+    raw: _RAW_ARG = False,
 ) -> None:
-    """For each version in the version bundle, generate a versioned package based on the template package"""
-    warnings.warn(
-        "`cadwyn generate-code-for-versioned-packages` is deprecated. Please, use `cadwyn codegen` instead",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-
-    from .codegen._main import generate_code_for_versioned_packages
-
-    sys.path.append(str(Path.cwd()))
-    template_package = importlib.import_module(path_to_template_package)
-    path_to_version_bundle, version_bundle_variable_name = full_path_to_version_bundle.split(":")
-    version_bundle_module = importlib.import_module(path_to_version_bundle)
-    possibly_version_bundle = getattr(version_bundle_module, version_bundle_variable_name)
-    version_bundle = _get_version_bundle(possibly_version_bundle)
-
-    return generate_code_for_versioned_packages(  # pyright: ignore[reportDeprecated]
-        template_package,
-        version_bundle,
-        ignore_coverage_for_latest_aliases=ignore_coverage_for_latest_aliases,
-    )
-
-
-@app.command(
-    name="codegen",
-    help=(
-        "For each version in the version bundle, generate a versioned package based on the "
-        "`head_schema_package` package"
-    ),
-    short_help="Generate code for all versions of schemas",
+    output_code(render_model_by_path(model, app, version), raw)
+
+
+@render_subapp.command(
+    name="module",
+    help="Render all versioned models and enums within a module from a certain version and output them to stdout",
+    short_help="Render all models and enums from an entire module",
 )
-def generate_versioned_packages(
-    full_path_to_version_bundle: str = typer.Argument(
-        ...,
-        help="The python path to the version bundle. Format: 'path.to.version_bundle:my_version_bundle_var'",
-        show_default=False,
-    ),
+def render_module(
+    module: Annotated[str, typer.Argument(metavar="<module>", help="Python path to the module to render")],
+    app: Annotated[str, typer.Option(metavar="<module>:<attribute>", help="Python path to the main Cadwyn app")],
+    version: Annotated[str, typer.Option(parser=lambda s: str(date.fromisoformat(s)), metavar="ISO-VERSION")],
+    raw: _RAW_ARG = False,
 ) -> None:
-    from .codegen._main import generate_code_for_versioned_packages
-
-    sys.path.append(str(Path.cwd()))
-    path_to_version_bundle, version_bundle_variable_name = full_path_to_version_bundle.split(":")
-    version_bundle_module = importlib.import_module(path_to_version_bundle)
-    possibly_version_bundle = getattr(version_bundle_module, version_bundle_variable_name)
-    version_bundle = _get_version_bundle(possibly_version_bundle)
-
-    if version_bundle.head_schemas_package is None:  # pragma: no cover
-        raise CadwynError("VersionBundle requires a 'head_schemas_package' argument to generate schemas.")
-
-    return generate_code_for_versioned_packages(version_bundle.head_schemas_package, version_bundle)
-
-
-def _get_version_bundle(possibly_version_bundle: Any) -> VersionBundle:
-    if not isinstance(possibly_version_bundle, VersionBundle):
-        err = TypeError(
-            "The provided version bundle is not a version bundle and "
-            "is not a zero-argument callable that returns the version bundle. "
-            f"Instead received: {possibly_version_bundle}",
-        )
-        if callable(possibly_version_bundle):
-            try:
-                return _get_version_bundle(possibly_version_bundle())
-            except TypeError as e:
-                raise err from e
-        raise err
-    return possibly_version_bundle
+    output_code(render_module_by_path(module, app, version), raw)
 
 
 @app.callback()

cadwyn/_asts.py

@@ -1,13 +1,9 @@
 import ast
 import inspect
-import re
 from collections.abc import Callable
-from dataclasses import dataclass
 from enum import Enum, auto
-from pathlib import Path
-from types import GenericAlias, LambdaType, ModuleType, NoneType
+from types import GenericAlias, LambdaType, NoneType
 from typing import (  # noqa: UP035
-    TYPE_CHECKING,
     Any,
     List,
     cast,
@@ -15,21 +11,12 @@ from typing import (  # noqa: UP035
     get_origin,
 )
 
-from cadwyn._compat import (
-    PYDANTIC_V2,
-    is_pydantic_1_constrained_type,
-)
-from cadwyn._package_utils import (
-    get_absolute_python_path_of_import,
-)
-from cadwyn._utils import PlainRepr, UnionType
-from cadwyn.exceptions import CodeGenerationError, InvalidGenerationInstructionError, ModuleIsNotAvailableAsTextError
+import annotated_types
 
-if TYPE_CHECKING:
-    import annotated_types
+from cadwyn._utils import PlainRepr, UnionType
+from cadwyn.exceptions import InvalidGenerationInstructionError
 
 _LambdaFunctionName = (lambda: None).__name__  # pragma: no branch
-_RE_CAMEL_TO_SNAKE = re.compile(r"(?<!^)(?=[A-Z])")
 
 
 # A parent type of typing._GenericAlias
@@ -42,11 +29,8 @@ GenericAliasUnion = GenericAlias | _BaseGenericAlias
 
 
 def get_fancy_repr(value: Any):
-    if PYDANTIC_V2:
-        import annotated_types
-
-        if isinstance(value, annotated_types.GroupedMetadata) and hasattr(type(value), "__dataclass_fields__"):
-            return transform_grouped_metadata(value)
+    if isinstance(value, annotated_types.GroupedMetadata) and hasattr(type(value), "__dataclass_fields__"):
+        return transform_grouped_metadata(value)
     if isinstance(value, list | tuple | set | frozenset):
         return transform_collection(value)
     if isinstance(value, dict):
@@ -59,7 +43,7 @@ def get_fancy_repr(value: Any):
         return transform_type(value)
     if isinstance(value, Enum):
         return transform_enum(value)
-    if isinstance(value, auto):
+    if isinstance(value, auto):  # pragma: no cover # it works but we no longer use auto
         return transform_auto(value)
     if isinstance(value, UnionType):
         return transform_union(value)
@@ -101,29 +85,11 @@ def transform_generic_alias(value: GenericAliasUnion) -> Any:
     return f"{get_fancy_repr(get_origin(value))}[{', '.join(get_fancy_repr(a) for a in get_args(value))}]"
 
 
-def transform_none(_: Any) -> Any:
+def transform_none(_: NoneType) -> Any:
     return "None"
 
 
 def transform_type(value: type) -> Any:
-    # This is a hack for pydantic's Constrained types
-    if is_pydantic_1_constrained_type(value):
-        parent = value.mro()[1]
-        snake_case = _RE_CAMEL_TO_SNAKE.sub("_", value.__name__)
-        cls_name = "con" + "".join(snake_case.split("_")[1:-1])
-        return (
-            cls_name.lower()
-            + "("
-            + ", ".join(
-                [
-                    f"{key}={get_fancy_repr(val)}"
-                    for key, val in value.__dict__.items()
-                    if not key.startswith("_") and val is not None and val != parent.__dict__[key]
-                ],
-            )
-            + ")"
-        )
-
     return value.__name__
 
 
@@ -131,7 +97,7 @@ def transform_enum(value: Enum) -> Any:
     return PlainRepr(f"{value.__class__.__name__}.{value.name}")
 
 
-def transform_auto(_: auto) -> Any:
+def transform_auto(_: auto) -> Any:  # pragma: no cover # it works but we no longer use auto
     return PlainRepr("auto()")
 
 
@@ -172,68 +138,6 @@ def _get_lambda_source_from_default_factory(source: str) -> str:
         )
 
 
-def read_python_module(module: ModuleType) -> str:
-    # Can be cached in the future to gain some speedups
-    try:
-        return inspect.getsource(module)
-    except OSError as e:
-        if module.__file__ is None:  # pragma: no cover
-            raise CodeGenerationError(f"Failed to get file path to the module {module}") from e
-        path = Path(module.__file__)
-        if path.is_file() and path.read_text() == "":
-            return ""
-        raise ModuleIsNotAvailableAsTextError(  # pragma: no cover
-            f"Failed to get source code for module {module}. "
-            "This is likely because this module is not available as code "
-            "(it could be a compiled C extension or even a .pyc file). "
-            "Cadwyn does not support models from such code. "
-            "Please, open an issue on Cadwyn's issue tracker if you believe that your use case is valid "
-            "and if you believe that it is possible for Cadwyn to support it.",
-        ) from e
-
-
-def get_all_names_defined_at_toplevel_of_module(body: ast.Module, module_python_path: str) -> dict[str, str]:
-    """Some day we will want to use this to auto-add imports for new symbols in versions. Some day..."""
-    defined_names = {}
-    for node in body.body:
-        if isinstance(node, ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef):
-            defined_names[node.name] = module_python_path
-        elif isinstance(node, ast.Assign):
-            for target in node.targets:
-                if isinstance(target, ast.Name):
-                    defined_names[target.id] = module_python_path
-        elif isinstance(node, ast.ImportFrom):
-            for name in node.names:
-                defined_names[name.name] = get_absolute_python_path_of_import(node, module_python_path)
-        elif isinstance(node, ast.Import):
-            for name in node.names:
-                defined_names[name.name] = name.name
-    return defined_names
-
-
-def add_keyword_to_call(attr_name: str, attr_value: Any, call: ast.Call):
-    new_keyword = get_ast_keyword_from_argument_name_and_value(attr_name, attr_value)
-    for i, keyword in enumerate(call.keywords):
-        if keyword.arg == attr_name:
-            call.keywords[i] = new_keyword
-            break
-    else:
-        call.keywords.append(new_keyword)
-
-
-def delete_keyword_from_call(attr_name: str, call: ast.Call):
-    for i, keyword in enumerate(call.keywords):  # pragma: no branch
-        if keyword.arg == attr_name:
-            call.keywords.pop(i)
-            break
-
-
-def get_ast_keyword_from_argument_name_and_value(name: str, value: Any):
-    if not isinstance(value, ast.AST):
-        value = ast.parse(get_fancy_repr(value), mode="eval").body
-    return ast.keyword(arg=name, value=value)  # pyright: ignore[reportArgumentType, reportCallIssue]
-
-
 def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:
     if (
         len(cls_body) > 0
@@ -244,31 +148,3 @@ def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:
         return [cls_body.pop(0)]
     else:
         return []
-
-
-@dataclass(slots=True)
-class _ValidatorWrapper:
-    func_ast: ast.FunctionDef
-    index_of_validator_decorator: int
-    field_names: set[str | ast.expr] | None
-    is_deleted: bool = False
-
-
-def get_validator_info_or_none(method: ast.FunctionDef) -> _ValidatorWrapper | None:
-    for index, decorator in enumerate(method.decorator_list):
-        # The cases we handle here:
-        # * `Name(id="root_validator")`
-        # * `Call(func=Name(id="validator"), args=[Constant(value="foo")])`
-        # * `Attribute(value=Name(id="pydantic"), attr="root_validator")`
-        # * `Call(func=Attribute(value=Name(id="pydantic"), attr="root_validator"), args=[])`
-
-        if isinstance(decorator, ast.Call) and ast.unparse(decorator.func).endswith("validator"):
-            if len(decorator.args) == 0:
-                return _ValidatorWrapper(method, index, None)
-            else:
-                return _ValidatorWrapper(
-                    method, index, {arg.value if isinstance(arg, ast.Constant) else arg for arg in decorator.args}
-                )
-        elif isinstance(decorator, ast.Name | ast.Attribute) and ast.unparse(decorator).endswith("validator"):
-            return _ValidatorWrapper(method, index, None)
-    return None

cadwyn/_importer.py

@@ -0,0 +1,31 @@
+import importlib
+from typing import Any
+
+from cadwyn.exceptions import ImportFromStringError
+
+
+def import_attribute_from_string(import_str: str) -> Any:
+    module_str, _, attrs_str = import_str.partition(":")
+    if not module_str or not attrs_str:
+        message = 'Import string "{import_str}" must be in format "<module>:<attribute>".'
+        raise ImportFromStringError(message.format(import_str=import_str))
+
+    module = import_module_from_string(module_str)
+
+    instance = module
+    try:
+        for attr_str in attrs_str.split("."):
+            instance = getattr(instance, attr_str)
+    except AttributeError as e:
+        raise ImportFromStringError(f'Attribute "{attrs_str}" not found in module "{module_str}".') from e
+
+    return instance
+
+
+def import_module_from_string(module_str: str):
+    try:
+        return importlib.import_module(module_str)
+    except ModuleNotFoundError as e:
+        if e.name != module_str:  # pragma: no cover
+            raise e from None
+        raise ImportFromStringError(f'Could not import module "{module_str}".') from e

cadwyn/_render.py

@@ -0,0 +1,152 @@
+import ast
+import inspect
+import textwrap
+from enum import Enum
+from typing import TYPE_CHECKING
+
+import typer
+from issubclass import issubclass as lenient_issubclass
+from pydantic import BaseModel
+
+from cadwyn._asts import get_fancy_repr, pop_docstring_from_cls_body
+from cadwyn.exceptions import CadwynRenderError
+from cadwyn.schema_generation import (
+    PydanticFieldWrapper,
+    _EnumWrapper,
+    _generate_versioned_models,
+    _PydanticRuntimeModelWrapper,
+)
+from cadwyn.structure.versions import VersionBundle, get_cls_pythonpath
+
+from ._importer import import_attribute_from_string, import_module_from_string
+
+if TYPE_CHECKING:
+    from cadwyn.applications import Cadwyn
+
+
+def render_module_by_path(module_path: str, app_path: str, version: str):
+    module = import_module_from_string(module_path)
+    app: Cadwyn = import_attribute_from_string(app_path)
+    attributes_to_alter = [
+        name
+        for name, value in module.__dict__.items()
+        if lenient_issubclass(value, Enum | BaseModel) and value.__module__ == module.__name__
+    ]
+
+    try:
+        module_ast = ast.parse(inspect.getsource(module))
+    except (OSError, SyntaxError, ValueError) as e:  # pragma: no cover
+        raise CadwynRenderError(f"Failed to find the source for module {module.__name__}") from e
+
+    return ast.unparse(
+        ast.Module(
+            body=[
+                _render_model_from_ast(node, getattr(module, node.name), app.versions, version)
+                if isinstance(node, ast.ClassDef) and node.name in attributes_to_alter
+                else node
+                for node in module_ast.body
+            ],
+            type_ignores=module_ast.type_ignores,
+        )
+    )
+
+
+def render_model_by_path(model_path: str, app_path: str, version: str) -> str:
+    # cadwyn render model schemas:MySchema --app=run:app --version=2000-01-01
+    model: type[BaseModel | Enum] = import_attribute_from_string(model_path)
+    app: Cadwyn = import_attribute_from_string(app_path)
+    return render_model(model, app.versions, version)
+
+
+def render_model(model: type[BaseModel | Enum], versions: VersionBundle, version: str) -> str:
+    try:
+        original_cls_node = ast.parse(textwrap.dedent(inspect.getsource(model))).body[0]
+    except (OSError, SyntaxError, ValueError):  # pragma: no cover
+        typer.echo(f"Failed to find the source for model {get_cls_pythonpath(model)}")
+        return f"class {model.__name__}: 'failed to find the original class source'"
+    if not isinstance(original_cls_node, ast.ClassDef):
+        raise TypeError(f"{get_cls_pythonpath(model)} is not a class")
+
+    return ast.unparse(_render_model_from_ast(original_cls_node, model, versions, version))
+
+
+def _render_model_from_ast(
+    model_ast: ast.ClassDef, model: type[BaseModel | Enum], versions: VersionBundle, version: str
+):
+    versioned_models = _generate_versioned_models(versions)
+    generator = versioned_models[version]
+    wrapper = generator._get_wrapper_for_model(model)
+
+    if isinstance(wrapper, _EnumWrapper):
+        return _render_enum_model(wrapper, model_ast)
+    else:
+        return _render_pydantic_model(wrapper, model_ast)
+
+
+def _render_enum_model(wrapper: _EnumWrapper, original_cls_node: ast.ClassDef):
+    # This is for possible schema renaming
+    original_cls_node.name = wrapper.cls.__name__
+
+    new_body = [
+        ast.Assign(
+            targets=[ast.Name(member, ctx=ast.Store())],
+            value=ast.Name(get_fancy_repr(member_value)),
+            lineno=0,
+        )
+        for member, member_value in wrapper.members.items()
+    ]
+
+    old_body = [
+        n for n in original_cls_node.body if not isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)
+    ]
+    docstring = pop_docstring_from_cls_body(old_body)
+
+    original_cls_node.body = docstring + new_body + old_body
+    if not original_cls_node.body:
+        original_cls_node.body = [ast.Pass()]
+    return original_cls_node
+
+
+def _render_pydantic_model(wrapper: _PydanticRuntimeModelWrapper, original_cls_node: ast.ClassDef):
+    # This is for possible schema renaming
+    original_cls_node.name = wrapper.name
+
+    field_definitions = [
+        ast.AnnAssign(
+            target=ast.Name(name),
+            annotation=ast.Name(get_fancy_repr(field.annotation)),
+            value=_generate_field_ast(field),
+            simple=1,
+        )
+        for name, field in wrapper.fields.items()
+    ]
+    validator_definitions = [
+        ast.parse(textwrap.dedent(inspect.getsource(validator.func))).body[0]
+        for validator in wrapper.validators.values()
+        if not validator.is_deleted
+    ]
+
+    old_body = [
+        n
+        for n in original_cls_node.body
+        if not (
+            isinstance(n, ast.AnnAssign | ast.Assign | ast.Pass | ast.Constant)
+            or (isinstance(n, ast.FunctionDef) and n.name in wrapper.validators)
+        )
+    ]
+    docstring = pop_docstring_from_cls_body(old_body)
+    original_cls_node.body = docstring + field_definitions + validator_definitions + old_body
+    if not original_cls_node.body:
+        original_cls_node.body = [ast.Pass()]
+    return original_cls_node
+
+
+def _generate_field_ast(field: PydanticFieldWrapper) -> ast.Call:
+    return ast.Call(
+        func=ast.Name("Field"),
+        args=[],
+        keywords=[
+            ast.keyword(arg=attr, value=ast.parse(get_fancy_repr(attr_value), mode="eval").body)
+            for attr, attr_value in field.passed_field_attributes.items()
+        ],
+    )