cadwyn 5.4.6__py3-none-any.whl

cadwyn/__init__.py

@@ -0,0 +1,44 @@
+import importlib.metadata
+
+from .applications import Cadwyn
+from .changelogs import hidden
+from .dependencies import current_dependency_solver
+from .route_generation import VersionedAPIRouter, generate_versioned_routers
+from .schema_generation import generate_versioned_models, 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,
+)
+
+__version__ = importlib.metadata.version("cadwyn")
+__all__ = [
+    "Cadwyn",
+    "HeadVersion",
+    "RequestInfo",
+    "ResponseInfo",
+    "Version",
+    "VersionBundle",
+    "VersionChange",
+    "VersionChangeWithSideEffects",
+    "VersionedAPIRouter",
+    "convert_request_to_next_version_for",
+    "convert_response_to_previous_version_for",
+    "current_dependency_solver",
+    "endpoint",
+    "enum",
+    "generate_versioned_models",
+    "generate_versioned_routers",
+    "hidden",
+    "migrate_response_body",
+    "schema",
+]

cadwyn/__main__.py

@@ -0,0 +1,78 @@
+from datetime import date
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+
+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",
+    add_completion=False,
+    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:
+        from . import __version__
+
+        typer.echo(f"Cadwyn {__version__}")
+        raise typer.Exit
+
+
+def output_code(code: str, raw: bool):
+    if raw:
+        typer.echo(code)
+    else:  # pragma: no cover
+        _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:
+    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 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:
+    output_code(render_module_by_path(module, app, version), raw)
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(None, "-V", "--version", callback=version_callback, is_eager=True),
+): ...
+
+
+if __name__ == "__main__":
+    app()

cadwyn/_asts.py

@@ -0,0 +1,155 @@
+import ast
+import inspect
+from collections.abc import Callable
+from enum import Enum, auto
+from types import GenericAlias, LambdaType
+from typing import (  # noqa: UP035
+    Any,
+    List,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
+
+import annotated_types
+
+from cadwyn._utils import PlainRepr, UnionType
+from cadwyn.exceptions import InvalidGenerationInstructionError
+
+_LambdaFunctionName = (lambda: None).__name__  # pragma: no branch
+NoneType = type(None)
+
+
+# A parent type of typing._GenericAlias
+_BaseGenericAlias = cast("type", type(List[int])).mro()[1]  # noqa: UP006
+
+# type(list[int]) and type(List[int]) are different which is why we have to do this.
+# Please note that this problem is much wider than just lists which is why we use typing._BaseGenericAlias
+# instead of typing._GenericAlias.
+GenericAliasUnion = Union[GenericAlias, _BaseGenericAlias]
+GenericAliasUnionArgs = get_args(GenericAliasUnion)
+
+
+def get_fancy_repr(value: Any) -> Any:
+    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):
+        return transform_dict(value)
+    if isinstance(value, GenericAliasUnionArgs):
+        return transform_generic_alias(value)
+    if value is None or value is NoneType:
+        return transform_none(value)
+    if isinstance(value, type):
+        return transform_type(value)
+    if isinstance(value, Enum):
+        return transform_enum(value)
+    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)  # pragma: no cover
+    if isinstance(value, LambdaType) and _LambdaFunctionName == value.__name__:
+        return transform_lambda(value)
+    if inspect.isfunction(value):
+        return transform_function(value)
+    else:
+        return transform_other(value)
+
+
+def transform_grouped_metadata(value: "annotated_types.GroupedMetadata"):
+    empty_obj = type(value)
+
+    modified_fields = [
+        (key, getattr(value, key))
+        for key in value.__dataclass_fields__  # pyright: ignore[reportAttributeAccessIssue]
+        if getattr(value, key) != getattr(empty_obj, key)
+    ]
+
+    return PlainRepr(
+        value.__class__.__name__
+        + "("
+        + ", ".join(f"{PlainRepr(key)}={get_fancy_repr(v)}" for key, v in modified_fields)
+        + ")",
+    )
+
+
+def transform_collection(value: Union[list, tuple, set, frozenset]) -> Any:
+    return PlainRepr(value.__class__(map(get_fancy_repr, value)))
+
+
+def transform_dict(value: dict) -> Any:
+    return PlainRepr(
+        value.__class__((get_fancy_repr(k), get_fancy_repr(v)) for k, v in value.items()),
+    )
+
+
+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(_: type[None]) -> Any:
+    return "None"
+
+
+def transform_type(value: type) -> Any:
+    return value.__name__
+
+
+def transform_enum(value: Enum) -> Any:
+    return PlainRepr(f"{value.__class__.__name__}.{value.name}")
+
+
+def transform_auto(_: auto) -> Any:  # pragma: no cover # it works but we no longer use auto
+    return PlainRepr("auto()")
+
+
+def transform_union(value: UnionType) -> Any:  # pragma: no cover
+    return "typing.Union[" + (", ".join(get_fancy_repr(a) for a in get_args(value))) + "]"
+
+
+def transform_lambda(value: LambdaType) -> Any:
+    # We clean source because getsource() can return only a part of the expression which
+    # on its own is not a valid expression such as: "\n  .had(default_factory=lambda: 91)"
+    return _get_lambda_source_from_default_factory(inspect.getsource(value).strip(" \n\t."))
+
+
+def transform_function(value: Callable) -> Any:
+    return PlainRepr(value.__name__)
+
+
+def transform_other(value: Any) -> Any:
+    return PlainRepr(repr(value))
+
+
+def _get_lambda_source_from_default_factory(source: str) -> str:
+    found_lambdas: list[ast.Lambda] = [
+        node.value
+        for node in ast.walk(ast.parse(source))
+        if isinstance(node, ast.keyword) and node.arg == "default_factory" and isinstance(node.value, ast.Lambda)
+    ]
+
+    if len(found_lambdas) == 1:
+        return ast.unparse(found_lambdas[0])
+    # These two errors are really hard to cover. Not sure if even possible, honestly :)
+    elif len(found_lambdas) == 0:  # pragma: no cover
+        raise InvalidGenerationInstructionError(
+            f"No lambda found in default_factory even though one was passed: {source}",
+        )
+    else:  # pragma: no cover
+        raise InvalidGenerationInstructionError(
+            "More than one lambda found in default_factory. This is not supported.",
+        )
+
+
+def pop_docstring_from_cls_body(cls_body: list[ast.stmt]) -> list[ast.stmt]:
+    if (
+        len(cls_body) > 0
+        and isinstance(cls_body[0], ast.Expr)
+        and isinstance(cls_body[0].value, ast.Constant)
+        and isinstance(cls_body[0].value.value, str)
+    ):
+        return [cls_body.pop(0)]
+    else:
+        return []

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 = f'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/_internal/context_vars.py

@@ -0,0 +1,9 @@
+from contextvars import ContextVar
+
+from typing_extensions import Literal
+
+DEFAULT_API_VERSION_VAR: "ContextVar[str | None]" = ContextVar("cadwyn_default_api_version")
+CURRENT_DEPENDENCY_SOLVER_OPTIONS = Literal["cadwyn", "fastapi"]
+CURRENT_DEPENDENCY_SOLVER_VAR: ContextVar[CURRENT_DEPENDENCY_SOLVER_OPTIONS] = ContextVar(
+    "cadwyn_dependencies_current_dependency_solver"
+)

cadwyn/_render.py

@@ -0,0 +1,155 @@
+import ast
+import inspect
+import textwrap
+from enum import Enum
+from typing import TYPE_CHECKING, Union
+
+import typer
+from pydantic import BaseModel
+
+from cadwyn._asts import get_fancy_repr, pop_docstring_from_cls_body
+from cadwyn._utils import lenient_issubclass
+from cadwyn.exceptions import CadwynRenderError
+from cadwyn.schema_generation import (
+    PydanticFieldWrapper,
+    _EnumWrapper,
+    _PydanticModelWrapper,
+    generate_versioned_models,
+)
+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[Union[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[Union[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[Union[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: _PydanticModelWrapper, 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()
+        ],
+    )

cadwyn/_utils.py

@@ -0,0 +1,79 @@
+import sys
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, Union
+
+from pydantic._internal._decorators import unwrap_wrapped_function
+
+Sentinel: Any = object()
+
+_T = TypeVar("_T", bound=Callable)
+
+
+_P_T = TypeVar("_P_T")
+_P_R = TypeVar("_P_R")
+
+
+if sys.version_info >= (3, 10):
+    UnionType = type(int | str) | type(Union[int, str])
+    DATACLASS_SLOTS: dict[str, Any] = {"slots": True}
+    ZIP_STRICT_TRUE: dict[str, Any] = {"strict": True}
+    ZIP_STRICT_FALSE: dict[str, Any] = {"strict": False}
+    DATACLASS_KW_ONLY: dict[str, Any] = {"kw_only": True}
+else:
+    UnionType = type(Union[int, str])
+    DATACLASS_SLOTS: dict[str, Any] = {}
+    DATACLASS_KW_ONLY: dict[str, Any] = {}
+    ZIP_STRICT_TRUE: dict[str, Any] = {}
+    ZIP_STRICT_FALSE: dict[str, Any] = {}
+
+
+def get_name_of_function_wrapped_in_pydantic_validator(func: Any) -> str:
+    if hasattr(func, "wrapped"):
+        return get_name_of_function_wrapped_in_pydantic_validator(func.wrapped)
+    if hasattr(func, "__func__"):
+        return get_name_of_function_wrapped_in_pydantic_validator(func.__func__)
+    return func.__name__
+
+
+class classproperty(Generic[_P_T, _P_R]):  # noqa: N801
+    def __init__(self, func: Callable[[_P_T], _P_R]) -> None:
+        super().__init__()
+        self.func = func
+
+    def __get__(self, obj: Any, cls: _P_T) -> _P_R:
+        return self.func(cls)
+
+
+class PlainRepr(str):
+    """String class where repr doesn't include quotes"""
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+def same_definition_as_in(t: _T) -> Callable[[Callable], _T]:
+    def decorator(f: Callable) -> _T:
+        return f  # pyright: ignore[reportReturnType]
+
+    return decorator
+
+
+def fully_unwrap_decorator(func: Callable, is_pydantic_v1_style_validator: Any):
+    func = unwrap_wrapped_function(func)
+    if is_pydantic_v1_style_validator and func.__closure__:
+        func = func.__closure__[0].cell_contents
+    return unwrap_wrapped_function(func)
+
+
+T = TypeVar("T", bound=type[object])
+
+if TYPE_CHECKING:
+    lenient_issubclass = issubclass
+
+else:
+
+    def lenient_issubclass(cls: type, other: Union[T, tuple[T, ...]]) -> bool:
+        try:
+            return issubclass(cls, other)
+        except TypeError:  # pragma: no cover
+            return False