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

cadwyn/_compat.py

@@ -1,151 +0,0 @@
-import ast
-import dataclasses
-import inspect
-from typing import Any, TypeAlias
-
-import pydantic
-from fastapi._compat import ModelField as FastAPIModelField
-from pydantic import BaseModel, Field
-
-ModelField: TypeAlias = Any  # pyright: ignore[reportRedeclaration]
-PydanticUndefined: TypeAlias = Any
-VALIDATOR_CONFIG_KEY = "__validators__"
-
-try:
-    PYDANTIC_V2 = False
-
-    from pydantic.fields import FieldInfo, ModelField  # pyright: ignore # noqa: PGH003
-    from pydantic.fields import Undefined as PydanticUndefined  # pyright: ignore # noqa: PGH003
-
-    _all_field_arg_names = []
-    EXTRA_FIELD_NAME = "extra"
-except ImportError:
-    PYDANTIC_V2 = True
-
-    from pydantic.fields import FieldInfo
-    from pydantic_core import PydanticUndefined  # pyright: ignore # noqa: PGH003
-
-    ModelField: TypeAlias = FieldInfo  # pyright: ignore # noqa: PGH003
-    _all_field_arg_names = sorted(
-        [
-            name
-            for name, param in inspect.signature(Field).parameters.items()
-            if param.kind in {inspect._ParameterKind.KEYWORD_ONLY, inspect._ParameterKind.POSITIONAL_OR_KEYWORD}
-        ],
-    )
-    EXTRA_FIELD_NAME = "json_schema_extra"
-
-
-_empty_field_info = Field()
-dict_of_empty_field_info = {k: getattr(_empty_field_info, k) for k in FieldInfo.__slots__}
-
-
-def is_pydantic_1_constrained_type(value: object):
-    """This method only works for pydanticV1. It is always False in PydanticV2"""
-    return isinstance(value, type) and value.__name__.startswith("Constrained") and value.__name__.endswith("Value")
-
-
-def is_constrained_type(value: object):
-    if PYDANTIC_V2:
-        import annotated_types
-
-        return isinstance(value, annotated_types.Len | annotated_types.Interval | pydantic.StringConstraints)
-
-    else:
-        return is_pydantic_1_constrained_type(value)
-
-
-@dataclasses.dataclass(slots=True)
-class PydanticFieldWrapper:
-    """We DO NOT maintain field.metadata at all"""
-
-    annotation: Any
-
-    init_model_field: dataclasses.InitVar[ModelField]
-    field_info: FieldInfo = dataclasses.field(init=False)
-
-    annotation_ast: ast.expr | None = None
-    # In the expressions "foo: str | None = None" and "foo: str | None = Field(default=None)"
-    # the value_ast is "None" and "Field(default=None)" respectively
-    value_ast: ast.expr | None = None
-
-    def __post_init__(self, init_model_field: ModelField):
-        if isinstance(init_model_field, FieldInfo):
-            self.field_info = init_model_field
-        else:
-            self.field_info = init_model_field.field_info
-
-    def update_attribute(self, *, name: str, value: Any):
-        if PYDANTIC_V2:
-            self.field_info._attributes_set[name] = value
-        else:
-            setattr(self.field_info, name, value)
-
-    def delete_attribute(self, *, name: str) -> None:
-        if PYDANTIC_V2:
-            self.field_info._attributes_set.pop(name)
-        else:
-            setattr(self.field_info, name, PydanticUndefined)
-
-    @property
-    def passed_field_attributes(self):
-        if PYDANTIC_V2:
-            attributes = {
-                attr_name: self.field_info._attributes_set[attr_name]
-                for attr_name in _all_field_arg_names
-                if attr_name in self.field_info._attributes_set
-            }
-            # PydanticV2 always adds frozen to _attributes_set but we don't want it if it wasn't explicitly set
-            if attributes.get("frozen", ...) is None:
-                attributes.pop("frozen")
-            return attributes
-
-        else:
-            attributes = {
-                attr_name: attr_val
-                for attr_name, default_attr_val in dict_of_empty_field_info.items()
-                if attr_name != EXTRA_FIELD_NAME
-                and (attr_val := getattr(self.field_info, attr_name)) != default_attr_val
-            }
-            extras = getattr(self.field_info, EXTRA_FIELD_NAME) or {}
-            return attributes | extras
-
-
-def get_annotation_from_model_field(model: ModelField) -> Any:
-    if PYDANTIC_V2:
-        return model.field_info.annotation
-    else:
-        return model.annotation
-
-
-def model_fields(model: type[BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V2:
-        return model.model_fields
-    else:
-        return model.__fields__  # pyright: ignore[reportDeprecated]
-
-
-def model_dump(model: BaseModel, by_alias: bool = False, exclude_unset: bool = False) -> dict[str, Any]:
-    if PYDANTIC_V2:
-        return model.model_dump(by_alias=by_alias, exclude_unset=exclude_unset)
-    else:
-        return model.dict(by_alias=by_alias, exclude_unset=exclude_unset)  # pyright: ignore[reportDeprecated]
-
-
-def rebuild_fastapi_body_param(old_body_param: FastAPIModelField, new_body_param_type: type[BaseModel]):
-    kwargs: dict[str, Any] = {"name": old_body_param.name, "field_info": old_body_param.field_info}
-    if PYDANTIC_V2:
-        old_body_param.field_info.annotation = new_body_param_type
-        kwargs.update({"mode": old_body_param.mode})
-    else:
-        kwargs.update(
-            {
-                "type_": new_body_param_type,
-                "class_validators": old_body_param.class_validators,  # pyright: ignore[reportAttributeAccessIssue]
-                "default": old_body_param.default,
-                "required": old_body_param.required,
-                "model_config": old_body_param.model_config,  # pyright: ignore[reportAttributeAccessIssue]
-                "alias": old_body_param.alias,
-            },
-        )
-    return FastAPIModelField(**kwargs)

cadwyn/_package_utils.py

@@ -1,45 +0,0 @@
-import ast
-import inspect
-from datetime import date
-from pathlib import Path
-from types import ModuleType
-
-from cadwyn.exceptions import CodeGenerationError
-
-IdentifierPythonPath = str
-
-
-def get_absolute_python_path_of_import(node: ast.ImportFrom, module_python_path: str):
-    python_path = ".".join(module_python_path.split(".")[0 : -node.level])
-    result = []
-    if node.module:
-        result.append(node.module)
-    if python_path:
-        result.append(python_path)
-    return ".".join(result)
-
-
-def get_cls_pythonpath(cls: type) -> IdentifierPythonPath:
-    return f"{cls.__module__}.{cls.__name__}"
-
-
-def get_version_dir_path(template_package: ModuleType, version: date) -> Path:
-    template_dir = get_package_path_from_module(template_package)
-    return template_dir.with_name(get_version_dir_name(version))
-
-
-def get_package_path_from_module(template_package: ModuleType) -> Path:
-    # Can be cached in the future to gain some speedups
-    file = inspect.getsourcefile(template_package)
-
-    # I am too lazy to reproduce this error correctly
-    if file is None:  # pragma: no cover
-        raise CodeGenerationError(f'Package "{template_package}" has no source file')
-    file = Path(file)
-    if not file.name == "__init__.py":
-        raise CodeGenerationError(f'"{template_package}" is not a package')
-    return file.parent
-
-
-def get_version_dir_name(version: date):
-    return "v" + version.isoformat().replace("-", "_")

cadwyn/codegen/README.md

@@ -1,10 +0,0 @@
-# Codegen
-
-main.py -- contains the real core of codegen
-asts.py -- contains the majority of ast-related utilities in cadwyn
-common.py -- contains all the data structures used by cadwyn code generation and its plugins
-plugins/class_rebuilding.py -- plugin for building enums + schemas from their versions in context
-plugins/class_renaming.py -- plugin for globally renaming classes such as schemas or enums
-plugins/import_auto_adding.py -- plugin for adding missing imports from other files or libraries
-
-You are free to overwrite any and all default plugins using the optional arguments of `generate_code_for_versioned_packages`. Please note our use of `ast_comments` module for preserving comments that we add. Please also note that codegen migrations apply strictly to the toplevel of the module. So if you want to visit some inner structure -- you'd have to find it yourself.

cadwyn/codegen/__init__.py

@@ -1,10 +0,0 @@
-from ._common import CodegenContext, GlobalCodegenContext
-from ._main import DEFAULT_CODEGEN_MIGRATION_PLUGINS, DEFAULT_CODEGEN_PLUGINS, generate_code_for_versioned_packages
-
-__all__ = [
-    "generate_code_for_versioned_packages",
-    "CodegenContext",
-    "GlobalCodegenContext",
-    "DEFAULT_CODEGEN_PLUGINS",
-    "DEFAULT_CODEGEN_MIGRATION_PLUGINS",
-]

cadwyn/codegen/_common.py

@@ -1,168 +0,0 @@
-import ast
-import dataclasses
-import inspect
-import textwrap
-from dataclasses import dataclass
-from enum import Enum
-from functools import cache
-from pathlib import Path
-from types import ModuleType
-from typing import TYPE_CHECKING, Any, Generic, Protocol, TypeAlias, TypeVar, cast
-
-from pydantic import BaseModel
-from typing_extensions import Self
-
-from cadwyn._compat import PydanticFieldWrapper, model_fields
-from cadwyn._package_utils import IdentifierPythonPath
-from cadwyn.exceptions import CodeGenerationError
-
-if TYPE_CHECKING:
-    from cadwyn.structure.versions import HeadVersion, Version, VersionBundle
-
-from .._asts import _ValidatorWrapper, get_validator_info_or_none
-
-_FieldName: TypeAlias = str
-_CodegenPluginASTType = TypeVar("_CodegenPluginASTType", bound=ast.AST)
-
-
-@dataclasses.dataclass(slots=True)
-class PydanticModelWrapper:
-    cls: type[BaseModel]
-    name: str
-    fields: dict[_FieldName, PydanticFieldWrapper]
-    validators: dict[_FieldName, _ValidatorWrapper]
-    annotations: dict[str, Any] = dataclasses.field(init=False, repr=False)
-    _parents: list[Self] | None = dataclasses.field(init=False, default=None)
-
-    def __post_init__(self):
-        self.annotations = self.cls.__annotations__.copy()
-
-    def _get_parents(self, schemas: "dict[IdentifierPythonPath, Self]"):
-        if self._parents is not None:
-            return self._parents
-        parents = []
-        for base in self.cls.mro()[1:]:
-            schema_path = f"{base.__module__}.{base.__name__}"
-
-            if schema_path in schemas:
-                parents.append(schemas[schema_path])
-            elif issubclass(base, BaseModel):
-                fields, validators = get_fields_and_validators_from_model(base)
-                parents.append(type(self)(base, base.__name__, fields, validators))
-        self._parents = parents
-        return parents
-
-    def _get_defined_fields_through_mro(
-        self, schemas: "dict[IdentifierPythonPath, Self]"
-    ) -> dict[str, PydanticFieldWrapper]:
-        fields = {}
-
-        for parent in reversed(self._get_parents(schemas)):
-            fields |= parent.fields
-
-        return fields | self.fields
-
-    def _get_defined_annotations_through_mro(self, schemas: "dict[IdentifierPythonPath, Self]") -> dict[str, Any]:
-        annotations = {}
-
-        for parent in reversed(self._get_parents(schemas)):
-            annotations |= parent.annotations
-
-        return annotations | self.annotations
-
-
-@cache
-def get_fields_and_validators_from_model(
-    cls: type,
-) -> tuple[dict[_FieldName, PydanticFieldWrapper], dict[_FieldName, _ValidatorWrapper]]:
-    if not isinstance(cls, type) or not issubclass(cls, BaseModel):
-        raise CodeGenerationError(f"Model {cls} is not a subclass of BaseModel")
-
-    fields = model_fields(cls)
-    try:
-        source = inspect.getsource(cls)
-    except OSError:  # pragma: no cover # It is covered by tests but not on every platform
-        return (
-            {
-                field_name: PydanticFieldWrapper(annotation=field.annotation, init_model_field=field)
-                for field_name, field in fields.items()
-            },
-            {},
-        )
-    else:
-        cls_ast = cast(ast.ClassDef, ast.parse(textwrap.dedent(source)).body[0])
-        validators: dict[str, _ValidatorWrapper] = {}
-
-        validators_and_nones = (
-            get_validator_info_or_none(node)
-            for node in cls_ast.body
-            if isinstance(node, ast.FunctionDef) and node.decorator_list
-        )
-        validators = {validator.func_ast.name: validator for validator in validators_and_nones if validator is not None}
-
-        return (
-            {
-                node.target.id: PydanticFieldWrapper(
-                    annotation=fields[node.target.id].annotation,
-                    init_model_field=fields[node.target.id],
-                    annotation_ast=node.annotation,
-                    value_ast=node.value,
-                )
-                for node in cls_ast.body
-                if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id in fields
-            },
-            validators,
-        )
-
-
-@dataclass(slots=True)
-class _EnumWrapper:
-    cls: type[Enum]
-    members: dict[_FieldName, Any]
-
-
-@dataclass(slots=True)
-class _ModuleWrapper:
-    value: ModuleType
-    extra_imports: list[ast.Import | ast.ImportFrom] = dataclasses.field(default_factory=list)
-
-
-@dataclasses.dataclass(slots=True, kw_only=True)
-class GlobalCodegenContext:
-    current_version: "Version | HeadVersion"
-    latest_version: "Version" = dataclasses.field(init=False)
-    versions: "list[Version]"
-    schemas: dict[IdentifierPythonPath, PydanticModelWrapper] = dataclasses.field(repr=False)
-    enums: dict[IdentifierPythonPath, _EnumWrapper] = dataclasses.field(repr=False)
-    modules: dict[IdentifierPythonPath, _ModuleWrapper] = dataclasses.field(repr=False)
-    version_bundle: "VersionBundle"
-    extra: dict[str, Any]
-
-    def __post_init__(self):
-        self.latest_version = max(self.versions, key=lambda v: v.value)
-
-
-@dataclasses.dataclass(slots=True, kw_only=True)
-class CodegenContext(GlobalCodegenContext):
-    # This attribute is extremely useful for calculating relative imports
-    index_of_head_package_dir_in_module_python_path: int
-    module_python_path: str
-    module_path: Path
-    template_module: ModuleType
-    all_names_defined_on_toplevel_of_file: dict[IdentifierPythonPath, str]
-
-
-class CodegenPlugin(Protocol, Generic[_CodegenPluginASTType]):
-    @property
-    def node_type(self) -> type[_CodegenPluginASTType]:
-        raise NotImplementedError
-
-    @staticmethod
-    def __call__(node: _CodegenPluginASTType, context: CodegenContext) -> _CodegenPluginASTType:
-        raise NotImplementedError
-
-
-class MigrationPlugin(Protocol):
-    @staticmethod
-    def __call__(context: GlobalCodegenContext) -> None:
-        raise NotImplementedError

cadwyn/codegen/_main.py

@@ -1,279 +0,0 @@
-import ast
-import importlib
-import os
-import shutil
-from collections.abc import Collection, Generator, Sequence
-from copy import deepcopy
-from pathlib import Path
-from types import ModuleType
-from typing import Any, overload
-
-import ast_comments
-from typing_extensions import deprecated
-
-from cadwyn._asts import get_all_names_defined_at_toplevel_of_module, read_python_module
-from cadwyn._package_utils import IdentifierPythonPath, get_package_path_from_module, get_version_dir_path
-from cadwyn._utils import get_index_of_head_schema_dir_in_module_python_path
-from cadwyn.codegen._common import (
-    CodegenContext,
-    CodegenPlugin,
-    GlobalCodegenContext,
-    MigrationPlugin,
-    PydanticModelWrapper,
-    _EnumWrapper,
-    _ModuleWrapper,
-    get_fields_and_validators_from_model,
-)
-from cadwyn.codegen._plugins.class_migrations import class_migration_plugin
-from cadwyn.codegen._plugins.class_rebuilding import ClassRebuildingPlugin
-from cadwyn.codegen._plugins.class_renaming import ClassRenamingPlugin
-from cadwyn.codegen._plugins.import_auto_adding import ImportAutoAddingPlugin
-from cadwyn.codegen._plugins.module_migrations import module_migration_plugin
-from cadwyn.structure.versions import Version, VersionBundle
-
-_AUTO_GENERATION_WARNING = "# THIS FILE WAS AUTO-GENERATED BY CADWYN. DO NOT EVER TRY TO EDIT IT BY HAND\n\n"
-
-
-DEFAULT_CODEGEN_PLUGINS: tuple[CodegenPlugin, ...] = (
-    ClassRebuildingPlugin(),
-    ClassRenamingPlugin(),
-    ImportAutoAddingPlugin(),
-)
-DEFAULT_CODEGEN_MIGRATION_PLUGINS: tuple[MigrationPlugin, ...] = (
-    module_migration_plugin,
-    class_migration_plugin,
-)
-
-
-@overload
-def generate_code_for_versioned_packages(
-    head_package: ModuleType,
-    versions: VersionBundle,
-    *,
-    codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
-    migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
-    extra_context: dict[str, Any] | None = None,
-): ...
-
-
-@overload
-@deprecated(
-    "ignore_coverage_for_latest_aliases is deprecated. "
-    "You do not need to pass it any longer and it is going to be deleted in the future."
-)
-def generate_code_for_versioned_packages(
-    head_package: ModuleType,
-    versions: VersionBundle,
-    *,
-    ignore_coverage_for_latest_aliases: bool | None = None,
-    codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
-    migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
-    extra_context: dict[str, Any] | None = None,
-): ...
-
-
-def generate_code_for_versioned_packages(
-    head_package: ModuleType,
-    versions: VersionBundle,
-    *,
-    ignore_coverage_for_latest_aliases: bool | None = None,
-    codegen_plugins: Sequence[CodegenPlugin] = DEFAULT_CODEGEN_PLUGINS,
-    migration_plugins: Sequence[MigrationPlugin] = DEFAULT_CODEGEN_MIGRATION_PLUGINS,
-    extra_context: dict[str, Any] | None = None,
-):
-    """
-    Args:
-        head_package: The head package from which we will generate the versioned packages
-        versions: Version bundle to generate versions from the head package.
-    """
-    extra_context = extra_context or {}
-    schemas = {}
-    for k, v in deepcopy(versions.versioned_schemas).items():
-        fields, validators = get_fields_and_validators_from_model(v)
-        schemas[k] = PydanticModelWrapper(v, v.__name__, fields, validators)
-
-    _generate_versioned_directories(
-        head_package,
-        versions=list(versions),
-        schemas=schemas,
-        enums={
-            k: _EnumWrapper(v, {member.name: member.value for member in v})
-            for k, v in deepcopy(versions.versioned_enums).items()
-        },
-        modules={k: _ModuleWrapper(module) for k, module in versions.versioned_modules.items()},
-        version_bundle=versions,
-        extra_context=extra_context | {"ignore_coverage_for_latest_aliases": ignore_coverage_for_latest_aliases},
-        codegen_plugins=codegen_plugins,
-        migration_plugins=migration_plugins,
-    )
-    # This should not affect real use cases at all but is rather useful for testing
-    importlib.invalidate_caches()
-
-
-def _generate_versioned_directories(
-    template_package: ModuleType,
-    versions: list[Version],
-    schemas: dict[IdentifierPythonPath, PydanticModelWrapper],
-    enums: dict[IdentifierPythonPath, _EnumWrapper],
-    modules: dict[IdentifierPythonPath, _ModuleWrapper],
-    version_bundle: VersionBundle,
-    extra_context: dict[str, Any],
-    codegen_plugins: Collection[CodegenPlugin],
-    migration_plugins: Collection[MigrationPlugin],
-):
-    global_context = GlobalCodegenContext(
-        current_version=version_bundle.head_version,
-        versions=versions,
-        schemas=schemas,
-        enums=enums,
-        modules=modules,
-        extra=extra_context,
-        version_bundle=version_bundle,
-    )
-    for plugin in migration_plugins:
-        plugin(global_context)
-    for version in versions:
-        print(f"Generating code for version={version.value!s}")  # noqa: T201
-        global_context = GlobalCodegenContext(
-            current_version=version,
-            versions=versions,
-            schemas=schemas,
-            enums=enums,
-            modules=modules,
-            extra=extra_context,
-            version_bundle=version_bundle,
-        )
-        _generate_directory_for_version(template_package, codegen_plugins, version, global_context)
-        for plugin in migration_plugins:
-            plugin(global_context)
-
-
-def _generate_directory_for_version(
-    template_package: ModuleType,
-    plugins: Collection[CodegenPlugin],
-    version: Version,
-    global_context: GlobalCodegenContext,
-):
-    template_dir = get_package_path_from_module(template_package)
-    version_dir = get_version_dir_path(template_package, version.value)
-
-    for (
-        _relative_path_to_file,
-        template_module,
-        parallel_file,
-    ) in _generate_parallel_directory(
-        template_package,
-        version_dir,
-    ):
-        file_source = read_python_module(template_module)
-        parsed_file = ast_comments.parse(file_source)
-        context = _build_context(global_context, template_dir, version_dir, template_module, parallel_file, parsed_file)
-
-        parsed_file = _apply_module_level_plugins(plugins, parsed_file, context)
-        new_module = _apply_per_node_plugins(plugins, parsed_file, context)
-        parallel_file.write_text(_AUTO_GENERATION_WARNING + ast_comments.unparse(new_module))
-
-
-def _apply_module_level_plugins(
-    plugins: Collection[CodegenPlugin],
-    parsed_file: ast_comments.Module,
-    context: CodegenContext,
-) -> ast_comments.Module:
-    node_type = type(parsed_file)
-    for plugin in plugins:
-        if issubclass(node_type, plugin.node_type):
-            parsed_file = plugin(parsed_file, context)
-    return parsed_file
-
-
-def _apply_per_node_plugins(
-    plugins: Collection[CodegenPlugin],
-    parsed_file: ast_comments.Module,
-    context: CodegenContext,
-) -> ast_comments.Module:
-    new_body = []
-
-    for node in parsed_file.body:
-        node_type = type(node)
-        for plugin in plugins:
-            if issubclass(node_type, plugin.node_type):
-                node = plugin(node, context)  # noqa: PLW2901
-        new_body.append(node)
-
-    return ast_comments.Module(body=new_body, type_ignores=[])
-
-
-def _build_context(
-    global_context: GlobalCodegenContext,
-    template_dir: Path,
-    version_dir: Path,
-    template_module: ModuleType,
-    parallel_file: Path,
-    parsed_file: ast_comments.Module,
-):
-    if template_module.__name__.endswith(".__init__"):
-        module_python_path = template_module.__name__.removesuffix(".__init__")
-    else:
-        module_python_path = template_module.__name__
-    all_names_defined_at_toplevel_of_file = get_all_names_defined_at_toplevel_of_module(
-        parsed_file,
-        module_python_path,
-    )
-    index_of_head_package_dir_in_module_python_path = get_index_of_head_schema_dir_in_module_python_path(
-        template_module,
-        template_dir.with_name(version_dir.name),
-    )
-    return CodegenContext(
-        current_version=global_context.current_version,
-        versions=global_context.versions,
-        schemas=global_context.schemas,
-        enums=global_context.enums,
-        modules=global_context.modules,
-        extra=global_context.extra,
-        index_of_head_package_dir_in_module_python_path=index_of_head_package_dir_in_module_python_path,
-        module_python_path=module_python_path,
-        all_names_defined_on_toplevel_of_file=all_names_defined_at_toplevel_of_file,
-        template_module=template_module,
-        module_path=parallel_file,
-        version_bundle=global_context.version_bundle,
-    )
-
-
-def _generate_parallel_directory(
-    template_module: ModuleType,
-    parallel_dir: Path,
-) -> Generator[tuple[Path, ModuleType, Path], Any, None]:
-    if template_module.__file__ is None:  # pragma: no cover
-        raise ValueError(
-            f"You passed a {template_module=} but it doesn't have a file "
-            "so it is impossible to generate its counterpart.",
-        )
-    dir = get_package_path_from_module(template_module)
-    parallel_dir.mkdir(exist_ok=True)
-    # >>> [cadwyn, structure, schemas]
-    template_module_python_path_parts = template_module.__name__.split(".")
-    # >>> [home, foo, bar, cadwyn, structure, schemas]
-    template_module_path_parts = Path(template_module.__file__).parent.parts
-    # >>> [home, foo, bar] = [home, foo, bar, cadwyn, structure, schemas][:-3]
-    root_module_path = Path(
-        *template_module_path_parts[: -len(template_module_python_path_parts)],
-    )
-    for subroot, dirnames, filenames in os.walk(dir):
-        original_subroot = Path(subroot)
-        parallel_subroot = parallel_dir / original_subroot.relative_to(dir)
-        if "__pycache__" in dirnames:
-            dirnames.remove("__pycache__")
-        for dirname in dirnames:
-            (parallel_subroot / dirname).mkdir(exist_ok=True)
-        for filename in filenames:
-            original_file = (original_subroot / filename).absolute()
-            parallel_file = (parallel_subroot / filename).absolute()
-
-            if filename.endswith(".py"):
-                original_module_path = ".".join(
-                    original_file.relative_to(root_module_path).with_suffix("").parts,
-                )
-                original_module = importlib.import_module(original_module_path)
-                yield original_subroot.relative_to(dir), original_module, parallel_file
-            else:
-                shutil.copyfile(original_file, parallel_file)