instant-python 0.17.0__tar.gz → 0.18.1__tar.gz

{instant_python-0.17.0 → instant_python-0.18.1}/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 <!-- version list -->
 
+## v0.18.1 (2025-11-19)
+
+### ♻️ Refactoring
+
+- **initialize**: Improve error message when configuration file is not found
+  ([`851f725`](https://github.com/dimanu-py/instant-python/commit/851f725e91482bc3a5d40aa96a7cd522955909ca))
+
+
+## v0.18.0 (2025-11-17)
+
+### ✨ Features
+
+- **templates**: Add sindri value objects error handler for fastapi application if value objects
+  feature is selected
+  ([`8ac4773`](https://github.com/dimanu-py/instant-python/commit/8ac47733f7e33932a23be3bb5665275209d2ab50))
+
+- **templates**: Remove value object folders from project structure templates
+  ([`6029ca6`](https://github.com/dimanu-py/instant-python/commit/6029ca6fcb5fc565040bbdcf9bdb151787b15361))
+
+- **templates**: Remove value object implementation templates now that this feature is provided by
+  sindripy
+  ([`1164d85`](https://github.com/dimanu-py/instant-python/commit/1164d85d5a0e5410f492b6e6f327946cde20345b))
+
+- **templates**: Add sindripy to value_objects dependencies
+  ([`b563be5`](https://github.com/dimanu-py/instant-python/commit/b563be513465603f45966b33e57bdb5b535c30b6))
+
+### ♻️ Refactoring
+
+- **templates**: Remove faker and random generator as it's not need it
+  ([`0ba348b`](https://github.com/dimanu-py/instant-python/commit/0ba348bc5cd36ebb64c653f4ff32e1b8b17f76a5))
+
+- **templates**: Stop including pytest if value objects feature is selected as it doesn't include
+  tests anymore
+  ([`c747731`](https://github.com/dimanu-py/instant-python/commit/c74773198cc939996e5e166e755a90e22865393a))
+
+- **templates**: Include random generator template only if value objects feature is not selected
+  ([`2ad49c3`](https://github.com/dimanu-py/instant-python/commit/2ad49c323f9596b854e85b46094d343f202f9de3))
+
+- **templates**: Remove test value object templates from project structures now that it has been
+  substituted by sindripy library
+  ([`9e27b5b`](https://github.com/dimanu-py/instant-python/commit/9e27b5b792a9f2b28d1f582451d044f7c0195152))
+
+
 ## v0.17.0 (2025-11-12)
 
 ### ✨ Features

{instant_python-0.17.0 → instant_python-0.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instant-python
-Version: 0.17.0
+Version: 0.18.1
 Summary: Instant boilerplate generation for Python projects
 Project-URL: documentation, https://dimanu-py.github.io/instant-python/
 Project-URL: repository, https://github.com/dimanu-py/instant-python/
@@ -258,6 +258,19 @@ commands like `ng new` or `create-react-app`, but for Python projects.
 
 </td></tr></table></div>
 
+## ✨ NEW ✨ Create Fully Customized Projects
+
+Take full control of your project generation! With **custom templates**, you can:
+
+- 🎨 Design your own project structure that matches your architectural patterns (like Hexagonal Architecture)
+- 📝 Create reusable file templates with your standardized code and best practices
+- 🔄 Enforce consistency across all your Python projects
+- ⚡ Eliminate repetitive boilerplate and setup tasks
+
+Whether you have a standardized project structure you always use or specific architectural patterns you want to enforce, 
+custom templates let you generate projects exactly the way you want them. 
+[Learn how to create your first custom template](https://dimanu-py.github.io/instant-python/guide/custom_projects/) and level up your project generation workflow!
+
 ## Navigation Guide
 
 This section provides a high-level overview of the `instant-python` documentation
@@ -302,8 +315,3 @@ so can quickly find what you need.
 [//]: # (You can disable this feature by setting the environment variable `INSTANT_PYTHON_NO_TRACK` to `1` or )
 
 [//]: # (passing the `--no-track` option to any command.)
-
-## Contributing
-
-We welcome contributions to `instant-python`! If you have ideas, suggestions, or improvements, please check out our
-[contributing guide](https://dimanu-py.github.io/instant-python/home/contributing/) for details on how to get involved.

{instant_python-0.17.0 → instant_python-0.18.1}/README.md

@@ -29,6 +29,19 @@ commands like `ng new` or `create-react-app`, but for Python projects.
 
 </td></tr></table></div>
 
+## ✨ NEW ✨ Create Fully Customized Projects
+
+Take full control of your project generation! With **custom templates**, you can:
+
+- 🎨 Design your own project structure that matches your architectural patterns (like Hexagonal Architecture)
+- 📝 Create reusable file templates with your standardized code and best practices
+- 🔄 Enforce consistency across all your Python projects
+- ⚡ Eliminate repetitive boilerplate and setup tasks
+
+Whether you have a standardized project structure you always use or specific architectural patterns you want to enforce, 
+custom templates let you generate projects exactly the way you want them. 
+[Learn how to create your first custom template](https://dimanu-py.github.io/instant-python/guide/custom_projects/) and level up your project generation workflow!
+
 ## Navigation Guide
 
 This section provides a high-level overview of the `instant-python` documentation
@@ -73,8 +86,3 @@ so can quickly find what you need.
 [//]: # (You can disable this feature by setting the environment variable `INSTANT_PYTHON_NO_TRACK` to `1` or )
 
 [//]: # (passing the `--no-track` option to any command.)
-
-## Contributing
-
-We welcome contributions to `instant-python`! If you have ideas, suggestions, or improvements, please check out our
-[contributing guide](https://dimanu-py.github.io/instant-python/home/contributing/) for details on how to get involved.

{instant_python-0.17.0 → instant_python-0.18.1}/docs/guide/default_features.md

@@ -255,297 +255,48 @@ needed to configure the migrations and run them asynchronously.
 
 ### Value objects and exceptions
 
-Value objects are a common pattern to encapsulate primitives and encapsulate domain logic. If
-you choose this option, it will include the following value objects:
+Value object pattern is a design pattern that emphasizes the use of immutable objects to represent values in a system. It encourages the creation of small, focused classes that encapsulate domain logic.
 
-A base class for all aggregates of your project with some common methods and utilities.
+They act as behavior magnets and try to avoid the code smells of anemic domain models and primitive obsession among others.
 
-???+ example "Aggregate"
+Value objects are characterized by:
 
-    ```python
-    class Aggregate(ABC):
-        @abstractmethod
-        def __init__(self) -> None:
-            raise NotImplementedError
-    
-        @override
-        def __repr__(self) -> str:
-            attributes = []
-            for key, value in sorted(self._to_dict().items()):
-                attributes.append(f"{key}={value!r}")
-    
-            return f"{self.__class__.__name__}({', '.join(attributes)})"
-    
-        @override
-        def __eq__(self, other: Self) -> bool:
-            if not isinstance(other, self.__class__):
-                return NotImplemented
-    
-            return self._to_dict() == other._to_dict()
-    
-        def _to_dict(self, *, ignore_private: bool = True) -> dict[str, Any]:
-            dictionary: dict[str, Any] = {}
-            for key, value in self.__dict__.items():
-                if ignore_private and key.startswith(f"_{self.__class__.__name__}__"):
-                    continue  # ignore private attributes
-    
-                key = key.replace(f"_{self.__class__.__name__}__", "")
-    
-                if key.startswith("_"):
-                    key = key[1:]
-    
-                dictionary[key] = value
-    
-            return dictionary
-    
-        @classmethod
-        def from_primitives(cls, primitives: dict[str, Any]) -> Self:
-            if not isinstance(primitives, dict) or not all(
-                    isinstance(key, str) for key in primitives
-            ):
-                raise TypeError(f'{cls.__name__} primitives <<<{primitives}>>> must be a dictionary of strings. Got <<<{type(primitives).__name__}>>> type.')  # noqa: E501  # fmt: skip
-    
-            constructor_signature = signature(obj=cls.__init__)
-            parameters: dict[str, Parameter] = {parameter.name: parameter for parameter in constructor_signature.parameters.values() if parameter.name != 'self'}  # noqa: E501  # fmt: skip
-            missing = {name for name, parameter in parameters.items() if parameter.default is _empty and name not in primitives}  # noqa: E501  # fmt: skip
-            extra = set(primitives) - parameters.keys()
-    
-            if missing or extra:
-                cls._raise_value_constructor_parameters_mismatch(
-                    primitives=set(primitives), missing=missing, extra=extra
-                )
-    
-            return cls(**primitives)
-    
-        @classmethod
-        def _raise_value_constructor_parameters_mismatch(
-                cls,
-                primitives: set[str],
-                missing: set[str],
-                extra: set[str],
-        ) -> None:
-            primitives_names = ", ".join(sorted(primitives))
-            missing_names = ", ".join(sorted(missing))
-            extra_names = ", ".join(sorted(extra))
-    
-            raise ValueError(f'{cls.__name__} primitives <<<{primitives_names}>>> must contain all constructor parameters. Missing parameters: <<<{missing_names}>> and extra parameters: <<<{extra_names}>>>.')  # noqa: E501  # fmt: skip
-    
-        def to_primitives(self) -> dict[str, Any]:
-            primitives = self._to_dict()
-            for key, value in primitives.items():
-                if isinstance(value, Aggregate) or hasattr(value, "to_primitives"):
-                    value = value.to_primitives()
-    
-                elif isinstance(value, Enum):
-                    value = value.value
-    
-                elif isinstance(value, ValueObject) or hasattr(value, "value"):
-                    value = value.value
-    
-                    if isinstance(value, Enum):
-                        value = value.value
-    
-                primitives[key] = value
-    
-            return primitives
-    ```
+- Immutability: Once created, a value object's state cannot be changed
+- Value equality: Two value objects are equal if their values are equal, regardless of identity
+- Self-validation: Value objects validate their state upon construction
+- Domain semantics: They represent meaningful concepts in the domain rather than primitive types
 
-A base value object class that will automatically be able to gather all methods decorated with `@validate` to be able
-to validate any pre-condition of the value object. This class is also configured to be immutable, meaning that once
-initialized, the value cannot be changed.
+!!! info "New versions use `sindripy`"
+    `instant-python` versions previous to 0.18.0 implemented value objects directly in the generated project.
+    All these implementations have been moved to the [`sindripy`](https://pypi.org/project/sindripy/) library 
+    to promote reusability and better maintenance.
+    When selecting this feature, the generated project will include `sindripy` as a dependency.
 
-???+ example "Base ValueObject"
+Along with `sindripy` to model value objects, this feature will include:
 
-    ```python
-    class ValueObject[T](ABC):
-        __slots__ = ("_value",)
-        __match_args__ = ("_value",)
-    
-        _value: T
-    
-        def __init__(self, value: T) -> None:
-            self._validate(value)
-            object.__setattr__(self, "_value", value)
-    
-        def _validate(self, value: T) -> None:
-            """Gets all methods decorated with @validate and calls them to validate all domain conditions."""
-            validators: list[Callable[[T], None]] = []
-            for cls in reversed(self.__class__.__mro__):
-                if cls is object:
-                    continue
-                for name, member in cls.__dict__.items():
-                    if getattr(member, "_is_validator", False):
-                        validators.append(getattr(self, name))
-    
-            for validator in validators:
-                validator(value)
-    
-        @property
-        def value(self) -> T:
-            return self._value
-    
-        @override
-        def __eq__(self, other: Self) -> bool:
-            return self.value == other.value
-    
-        @override
-        def __repr__(self) -> str:
-            return f"{self.__class__.__name__}({self._value!r})"
-    
-        @override
-        def __str__(self) -> str:
-            return str(self._value)
-    
-        @override
-        def __setattr__(self, name: str, value: T) -> None:
-            """Prevents modification of the value after initialization."""
-            if name in self.__slots__:
-                raise AttributeError("Cannot modify the value of a ValueObject")
-    
-            public_name = name.replace("_", "")
-            public_slots = [slot.replace("_", "") for slot in self.__slots__]
-            if public_name in public_slots:
-                raise AttributeError("Cannot modify the value of a ValueObject")
-    
-            raise AttributeError(
-                f"Class {self.__class__.__name__} object has no attribute '{name}'"
-            )
-    ```
-
-Some common value objects that will be placed at _usables_ folder.
-
-???+ example "UUID"
+1. A base exception class that you can use to create your own exceptions:
 
-    ```python
-    class Uuid(ValueObject[str]):
-        @validate
-        def _ensure_has_value(self, value: str) -> None:
-            if value is None:
-                raise RequiredValueError
-    
-        @validate
-        def _ensure_value_is_string(self, value: str) -> None:
-            if not isinstance(value, str):
-                raise IncorrectValueTypeError(value)
-    
-        @validate
-        def _ensure_value_has_valid_uuid_format(self, value: str) -> None:
-            try:
-                UUID(value)
-            except ValueError:
-                raise InvalidIdFormatError
-    ```
-
-???+ example "StringValueObject"
-
-    ```python
-    class StringValueObject(ValueObject[str]):
-        @validate
-        def _ensure_has_value(self, value: str) -> None:
-            if value is None:
-                raise RequiredValueError
-    
-        @validate
-        def _ensure_is_string(self, value: str) -> None:
-            if not isinstance(value, str):
-                raise IncorrectValueTypeError(value)
-    ```
-???+ example "IntValueObject"
-
-    ```python
-    class IntValueObject(ValueObject[int]):
-        @validate
-        def _ensure_has_value(self, value: int) -> None:
-            if value is None:
-                raise RequiredValueError
+    ???+ example "Implementation"
     
-        @validate
-        def _ensure_value_is_integer(self, value: int) -> None:
-            if not isinstance(value, int):
-                raise IncorrectValueTypeError(value)
-    
-        @validate
-        def _ensure_value_is_positive(self, value: int) -> None:
-            if value < 0:
-                raise InvalidNegativeValueError(value)
-    ```
-
-Along with these value objects, it will include a base exception class that you can use to create your own exceptions and
-some common exceptions that you can use in your project:
-
-???+ example "Base Error"
-
-    ```python
-    class Error(Exception, ABC):
-        def __init__(self, message: str, error_type: str) -> None:
-            self._message = message
-            self._type = error_type
-            super().__init__(self._message)
-    
-        @property
-        def type(self) -> str:
-            return self._type
-    
-        @property
-        def message(self) -> str:
-            return self._message
-    
-        def to_primitives(self) -> dict[str, str]:
-            return {
-                "type": self.type,
-                "message": self.message,
-            }
-    ```
-
-???+ example "Domain Error"
-
-    ```python
-    class DomainError(Error):
-        ...
-    ```
+        ```python
+        class BaseError(Exception, ABC):
+            def __init__(self, message: str) -> None:
+                self._message = message
+                super().__init__(self._message)
+        
+            @property
+            def message(self) -> str:
+                return self._message
+        ```
 
-???+ example "IncorrectValueTypeError"
+2. A `DomainError` class that extends the base exception class. You can use this class to raise domain errors in your application.
 
-    ```python
-    T = TypeVar("T")
+    ???+ example "Implementation"
     
-    
-    class IncorrectValueTypeError(DomainError):
-        def __init__(self, value: T) -> None:
-            self._message = f"Value '{value}' is not of type {type(value).__name__}"
-            self._type = "incorrect_value_type"
-            super().__init__(message=self._message, error_type=self._type)
-    ```
-
-???+ example "InvalidIdFormatError"
-
-    ```python
-    class InvalidIdFormatError(DomainError):
-        def __init__(self) -> None:
-            self._message = "User id must be a valid UUID"
-            self._type = "invalid_id_format"
-            super().__init__(message=self._message, error_type=self._type)
-    ```
-
-???+ example "InvalidNegativeValueError"
-
-    ```python
-    class InvalidNegativeValueError(DomainError):
-        def __init__(self, value: int) -> None:
-            self._message = f"Invalid negative value: {value}"
-            self._type = "invalid_negative_value"
-            super().__init__(message=self._message, error_type=self._type)
-    ```
-
-???+ example "RequiredValueError"
-
-    ```python
-    class RequiredValueError(DomainError):
-        def __init__(self) -> None:
-            self._message = "Value is required, can't be None"
-            self._type = "required_value"
-            super().__init__(message=self._message, error_type=self._type)
-    ```
+        ```python
+        class DomainError(BaseError):
+            ...
+        ```
 
 ### Event bus
 

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/initialize/infra/persistence/yaml_config_repository.py

@@ -27,4 +27,8 @@ class YamlConfigRepository(ConfigRepository):
 
 class ConfigurationFileNotFound(ApplicationError):
     def __init__(self, path: str) -> None:
-        super().__init__(message=f"Configuration file not found at '{path}'.")
+        super().__init__(
+            message=f"Configuration file not found at '{path}'. To create a project, you first"
+            f" need a configuration file. Please, run 'ipy config' command to create one.\n"
+            f"If you have the configuration file in another location, use the '-c' flag.",
+        )

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/boilerplate/fastapi/application.py

@@ -2,18 +2,22 @@ from fastapi import FastAPI
 {% if "logger" in template.built_in_features %}
 from fastapi.errors import RequestValidationError
 {% endif %}
-
+{% if "value_objects" in template.built_in_features %}
+from sindripy.value_objects import SindriValidationError
+{% endif %}
 {% if template.name == template_types.STANDARD %}
 {% if "logger" in template.built_in_features %}
 from {{ general.source_name }}.api.handlers.error_handlers import (
 	unexpected_exception_handler,
 	domain_error_handler,
 	validation_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
 )
 {% else %}
 from {{ general.source_name }}.api.handlers.error_handlers import (
 	unexpected_exception_handler,
 	domain_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
 )
 {% endif %}
 {% else %}
@@ -22,11 +26,13 @@ from {{ general.source_name }}.delivery.api.handlers.error_handlers import (
 	unexpected_exception_handler,
 	domain_error_handler,
 	validation_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
 )
 {% else %}
 from {{ general.source_name }}.delivery.api.handlers.error_handlers import (
 	unexpected_exception_handler,
 	domain_error_handler,
+    {% if "value_objects" in template.built_in_features %}sindri_validation_error_handler,{% endif %}
 )
 {% endif %}
 {% endif %}
@@ -61,5 +67,8 @@ logger = create_file_logger(name="{{ general.slug }}")
 app.add_middleware(FastapiLogMiddleware, logger=logger)
 app.add_exception_handler(RequestValidationError, validation_error_handler)
 {% endif %}
+{% if "value_objects" in template.built_in_features %}
+app.add_exception_handler(SindriValidationError, sindri_validation_error_handler)
+{% endif %}
 app.add_exception_handler(Exception, unexpected_exception_handler)
 app.add_exception_handler(DomainError, domain_error_handler)

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/boilerplate/fastapi/error_handlers.py

@@ -7,7 +7,9 @@ from {{ general.source_name }}{{ "shared.infra.logger.file_logger" | resolve_imp
 {% endif %}
 from {{ general.source_name }}{{ "shared.infra.http.error_response" | resolve_import_path(template.name) }} import InternalServerError, UnprocessableEntityError
 from {{ general.source_name }}{{ "shared.domain.errors.domain_error" | resolve_import_path(template.name) }} import DomainError
-
+{% if "value_objects" in template.built_in_features %}
+from sindripy.value_objects import SindriValidationError
+{% endif %}
 
 {% if "logger" in template.built_in_features %}
 logger = create_file_logger(name="{{ general.slug }}")
@@ -51,6 +53,22 @@ async def validation_error_handler(
 		},
 	)
 	return await request_validation_exception_handler(request, exc)
+
+{% if "value_objects" in template.built_in_features %}
+async def sindri_validation_error_handler(
+        request: Request,
+        exc: SindriValidationError,
+) -> JSONResponse:
+    logger.error(
+        message=f"error - {request.url.path}",
+        details={
+            "error": {"message": str(exc)},
+            "method": request.method,
+            "source": request.url.path,
+        },
+    )
+    return UnprocessableEntityError().as_json()
+{% endif %}
 {% else %}
 async def unexpected_exception_handler(_: Request, __: Exception) -> JSONResponse:
 	return InternalServerError().as_json()
@@ -58,4 +76,13 @@ async def unexpected_exception_handler(_: Request, __: Exception) -> JSONRespons
 
 async def domain_error_handler(_: Request, __: DomainError) -> JSONResponse:
 	return UnprocessableEntityError().as_json()
+
+
+{% if "value_objects" in template.built_in_features %}
+async def sindri_validation_error_handler(
+        _: Request,
+        __: SindriValidationError,
+) -> JSONResponse:
+    return UnprocessableEntityError().as_json()
+{% endif %}
 {% endif %}

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/boilerplate/pyproject.toml

@@ -2,7 +2,8 @@
     "async_sqlalchemy": ["sqlalchemy", "asyncpg", "psycopg2-binary", "pydantic", "pydantic-settings"],
     "async_alembic": ["alembic", "pydantic", "pydantic-settings"],
     "event_bus": ["pika"],
-    "fastapi_application": ["fastapi[standard]"]
+    "fastapi_application": ["fastapi[standard]"],
+    "value_objects": ["sindripy"]
 } %}
 {% macro get_main_dependencies() -%}
     {%- set deps = [] -%}
@@ -27,8 +28,7 @@
     "pre-commit": ["precommit_hook"]
     },
     "test": {
-    "faker": [],
-    "pytest": ["github_actions", "makefile", "precommit_hook", "value_objects"],
+    "pytest": ["github_actions", "makefile", "precommit_hook"],
     "pytest-asyncio": ["async_alembic", "async_sqlalchemy"]
     }
 } %}

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/project_structure/clean_architecture/test.yml.j2

@@ -6,18 +6,13 @@
     - name: domain
       type: directory
       python: True
-      {% if ["value_objects", "event_bus"] | is_in(template.built_in_features) %}
-      children:
-      {% if "value_objects" in template.built_in_features %}
-        {{ macros.include_and_indent("test_value_objects.yml.j2", 8) }}
-      {% endif %}
       {% if "event_bus" in template.built_in_features %}
+      children:
         - name: mock_event_bus
           type: file
           extension: .py
           template: event_bus/mock_event_bus.py
       {% endif %}
-      {% endif %}
     - name: infra
       type: directory
       python: True
@@ -38,8 +33,4 @@
       {% endif %}
     - name: delivery
       type: directory
-      python: True
-    - name: random_generator
-      type: file
-      extension: .py
-      template: random_generator.py
+      python: True

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/project_structure/domain_driven_design/test.yml.j2

@@ -7,21 +7,16 @@
       type: directory
       python: True
       children:
+        - name: delivery
+          type: directory
+          python: True
         - name: domain
           type: directory
           python: True
-          children:
-            - name: random_generator
-              type: file
-              extension: .py
-              template: random_generator.py
-            {% if "value_objects" in template.built_in_features %}
-            {{ macros.include_and_indent("test_value_objects.yml.j2", 12) }}
-            {% endif %}
-        {% if ["event_bus", "async_sqlalchemy"] | is_in(template.built_in_features) %}
         - name: infra
           type: directory
           python: True
+          {% if ["event_bus", "async_sqlalchemy"] | is_in(template.built_in_features) %}
           children:
             {% if "event_bus" in template.built_in_features %}
             - name: mock_event_bus
@@ -35,7 +30,7 @@
               extension: .py
               template: persistence/async/async_engine_fixture.py
             {% endif %}
-        {% endif %}
+          {% endif %}
     {% if template.specify_bounded_context %}
     {{ macros.include_and_indent("domain_driven_design/bounded_context.yml.j2", 4) }}
     {% endif %}

{instant_python-0.17.0 → instant_python-0.18.1}/instant_python/templates/project_structure/standard_project/test.yml.j2

@@ -2,14 +2,8 @@
 - name: test
   type: directory
   python: True
+  {% if ["async_sqlalchemy", "event_bus"] | is_in(template.built_in_features) %}
   children:
-    - name: random_generator
-      type: file
-      extension: .py
-      template: random_generator.py
-    {% if "value_objects" in template.built_in_features %}
-    {{ macros.include_and_indent("test_value_objects.yml.j2", 4) }}
-    {% endif %}
     {% if "async_sqlalchemy" in template.built_in_features %}
     - name: conftest
       type: file
@@ -25,4 +19,5 @@
           type: file
           extension: .py
           template: event_bus/mock_event_bus.py
-    {% endif %}
+    {% endif %}
+  {% endif %}

instant_python-0.18.1/instant_python/templates/project_structure/value_objects.yml.j2

@@ -0,0 +1,12 @@
+- name: errors
+  type: directory
+  python: True
+  children:
+    - name: base_error
+      type: file
+      extension: .py
+      template: exceptions/base_error.py
+    - name: domain_error
+      type: file
+      extension: .py
+      template: exceptions/domain_error.py