instant-python 0.11.0__tar.gz → 0.12.1__tar.gz

{instant_python-0.11.0 → instant_python-0.12.1}/CHANGELOG.md

@@ -2,6 +2,146 @@
 
 <!-- version list -->
 
+## v0.12.1 (2025-10-23)
+
+### 🪲 Bug Fixes
+
+- **templates**: Create github issues templates folder with correct name
+  ([`751e58f`](https://github.com/dimanu-py/instant-python/commit/751e58fa2ffd637e7984e4c2040616deb300f2f8))
+
+
+## v0.12.0 (2025-10-23)
+
+### ✨ Features
+
+- **initialize**: Move init command cli to its own folder for hexagonal architecture
+  ([`3101896`](https://github.com/dimanu-py/instant-python/commit/310189634553c297095d8f3bd40fcd32cc87228f))
+
+- **config**: Implement YAML config writer to save configuration to file
+  ([`99b2e5e`](https://github.com/dimanu-py/instant-python/commit/99b2e5ed5ac0aea6859dc852a5bf5ed15e34f659))
+
+- **config**: Return parsed configuration
+  ([`330dc00`](https://github.com/dimanu-py/instant-python/commit/330dc0056fdef9ae9fc983ab9cbe080c8fc27fca))
+
+- **config**: Add parsing logic for template section in configuration
+  ([`9f9e83a`](https://github.com/dimanu-py/instant-python/commit/9f9e83a5c684c634cb00826fe57db98dcdaee45b))
+
+- **config**: Add parsing logic for git section in configuration
+  ([`818febc`](https://github.com/dimanu-py/instant-python/commit/818febc61febbc509caf1a9ec2946f3d71ff6eb3))
+
+- **config**: Add parsing logic for dependencies section in configuration
+  ([`b6fec2a`](https://github.com/dimanu-py/instant-python/commit/b6fec2a4c2d7b9773b7bca1707acf6193e0dd986))
+
+- **config**: Implement logic to parse general section of config
+  ([`e6ef56c`](https://github.com/dimanu-py/instant-python/commit/e6ef56c2988e8af8d0a9ffadcc882c643a2e580e))
+
+- **config**: Validate required configuration keys and raise appropriate exceptions
+  ([`697b115`](https://github.com/dimanu-py/instant-python/commit/697b1153472189ae7dd8b58825830644282ef9bc))
+
+- **config**: Raise EmptyConfigurationNotAllowed for empty content in parse method
+  ([`b3f51e4`](https://github.com/dimanu-py/instant-python/commit/b3f51e4a5dd483d4a2f3fa58c2e4b3b035dec1ca))
+
+- **config**: Inject ConfigParser port into ConfigGenerator use case
+  ([`4f0a8f6`](https://github.com/dimanu-py/instant-python/commit/4f0a8f6be698c54b1ae75755a4807c6c8184c9d4))
+
+- **config**: Define ConfigParser interface as driver port
+  ([`59ec2b9`](https://github.com/dimanu-py/instant-python/commit/59ec2b9c5c3ffb145547b98c06721c8121cab907))
+
+- **config**: Extend QuestionaryQuestionWizard to inherit from QuestionWizard
+  ([`ed3674c`](https://github.com/dimanu-py/instant-python/commit/ed3674c41547504a95817498c759324a7607700d))
+
+- **config**: Add abstract QuestionWizard class for question handling
+  ([`abb9a22`](https://github.com/dimanu-py/instant-python/commit/abb9a226be6f257ed5924fe935ccbfae338e9c10))
+
+- **config**: Implement execute method for configuration generation
+  ([`936b2c6`](https://github.com/dimanu-py/instant-python/commit/936b2c61fc69c013e618093bfa62e8599876f2d7))
+
+- **config**: Create ConfigGenerator class for configuration generation
+  ([`377564e`](https://github.com/dimanu-py/instant-python/commit/377564e5e9057c79f2f07b0889bae55f749e8981))
+
+- **config**: Create yaml writer interface
+  ([`4e6f3b5`](https://github.com/dimanu-py/instant-python/commit/4e6f3b5a29a7970f67836bb18c07349cc0a93897))
+
+### 🪲 Bug Fixes
+
+- **templates**: Point to correct base error template file when including fastapi built in feature
+  ([`c2ce3f3`](https://github.com/dimanu-py/instant-python/commit/c2ce3f35a1eb9cb268906e78990abd7c25604955))
+
+- **cli**: Correct import for new place of config command
+  ([`f23b0fc`](https://github.com/dimanu-py/instant-python/commit/f23b0fc3204483bbac44c87fd70611e742c50c61))
+
+### ⚙️ Build System
+
+- Update audit make command to ignore pip vulnerability
+  ([`963d5f6`](https://github.com/dimanu-py/instant-python/commit/963d5f6c0fdbc9528cd90489429db692a36fb8c5))
+
+- Exclude resources folders from mypy analysis
+  ([`7f2b3b8`](https://github.com/dimanu-py/instant-python/commit/7f2b3b818d4b608aa466e50d9dfdedd42e6af4f7))
+
+### ♻️ Refactoring
+
+- **config**: Instantiate question wizard steps inside directly coupling them
+  ([`8785304`](https://github.com/dimanu-py/instant-python/commit/8785304b744f9dba777e2518014e4a40146753c0))
+
+- **config**: Remove complex class hierarchy for different types of questions and streamline
+  questions using questionary wrapper
+  ([`35e266b`](https://github.com/dimanu-py/instant-python/commit/35e266bfb3afc97b88f6432e08463a80553ff32b))
+
+- **config**: Streamline dependency installation questions in CLI
+  ([`33f0bd6`](https://github.com/dimanu-py/instant-python/commit/33f0bd6d95d7aa0d9c87a74c2a5e0a638b1541a1))
+
+- **config**: Modify cli application to use new config generator use case
+  ([`530fe7e`](https://github.com/dimanu-py/instant-python/commit/530fe7e47ed7f9fb81077c4efdbe31c0967e339c))
+
+- **config**: Move question wizard concrete implementation to new infra folder in config command
+  ([`0f8b481`](https://github.com/dimanu-py/instant-python/commit/0f8b48128eb97fb1c8ed54852307cb995c183739))
+
+- **config**: Turn config file path attribute to public
+  ([`8fa7f3e`](https://github.com/dimanu-py/instant-python/commit/8fa7f3e6aa31e287b050601732db1ecd7260e325))
+
+- **config**: Clean up parser tests adding setup_method
+  ([`eb3c095`](https://github.com/dimanu-py/instant-python/commit/eb3c0958b36bb161ff7874458761b1c1871e1db4))
+
+- **config**: Move config parsing errors to new architecture and to errors file
+  ([`c18a969`](https://github.com/dimanu-py/instant-python/commit/c18a96965d35faa1a8e735974e3e1e9c8ae64810))
+
+- **config**: Extract string values to constants
+  ([`49ac047`](https://github.com/dimanu-py/instant-python/commit/49ac04775ca140464eb8f79a246bed63fe6cd9b4))
+
+- **config**: Extract semantic methods for better readability in parser
+  ([`42cc355`](https://github.com/dimanu-py/instant-python/commit/42cc35588acb3ef256d22bbf9062b9d367e28f0a))
+
+- **config**: Decouple configuration generation from specific schema classes validating answers with
+  parser
+  ([`2a3bea5`](https://github.com/dimanu-py/instant-python/commit/2a3bea55ae87317580012ab6eb940675c6089c4a))
+
+- **config**: Rename QuestionaryQuestionWizard to QuestionaryConsoleWizard
+  ([`66a6671`](https://github.com/dimanu-py/instant-python/commit/66a6671f9765ca91836229d3c32c4c21ba6ecc4d))
+
+- **config**: Apply dependency inversion to ConfigGenerator constructor
+  ([`8ae285f`](https://github.com/dimanu-py/instant-python/commit/8ae285f2d0c26e03513ac874435dbc100360cea0))
+
+- **config**: Rename YamlWriter interface to ConfigWriter
+  ([`4921828`](https://github.com/dimanu-py/instant-python/commit/4921828e171c8e999c643da1df583b1c4bfa3d43))
+
+- **config**: Update test to use QuestionWizard instead of QuestionaryQuestionWizard for mock
+  ([`00fb764`](https://github.com/dimanu-py/instant-python/commit/00fb764239ed6fffa94ec211bc32b544d407cf4a))
+
+- **config**: Rename QuestionWizard to QuestionaryQuestionWizard to express its implementation uses
+  questionary
+  ([`74d124d`](https://github.com/dimanu-py/instant-python/commit/74d124d68318fa333cb48f98aa43c6f59667a6c1))
+
+- **config**: Structure tests for config domain following same structure as source
+  ([`eafda5e`](https://github.com/dimanu-py/instant-python/commit/eafda5e240b84483962daeed5d5c85b3354b2a15))
+
+- **config**: Move domain classes for config command to domain module
+  ([`c6aa3ad`](https://github.com/dimanu-py/instant-python/commit/c6aa3ad5f5649fc4f3dd61d9d02fc9d0de70a7ca))
+
+- **commands**: Move cli application for 'config' command to specific module config that will follow
+  hexagonal architecture to reduce coupling
+  ([`a1fa9ab`](https://github.com/dimanu-py/instant-python/commit/a1fa9ab605a0fe622e529f086352d5eefc3b8ece))
+
+
 ## v0.11.0 (2025-09-30)
 
 ### ✨ Features

{instant_python-0.11.0 → instant_python-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instant-python
-Version: 0.11.0
+Version: 0.12.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/

{instant_python-0.11.0 → instant_python-0.12.1}/instant_python/cli/cli.py

@@ -1,7 +1,8 @@
 from rich.console import Console
 from rich.panel import Panel
 
-from instant_python.commands import init, config
+from instant_python.config.delivery import cli as config
+from instant_python.initialize.delivery import cli as init
 from instant_python.shared.application_error import ApplicationError
 from instant_python.cli.instant_python_typer import InstantPythonTyper
 

instant_python-0.12.1/instant_python/config/application/config_generator.py

@@ -0,0 +1,15 @@
+from instant_python.config.domain.config_parser import ConfigParser
+from instant_python.config.domain.config_writer import ConfigWriter
+from instant_python.config.domain.question_wizard import QuestionWizard
+
+
+class ConfigGenerator:
+    def __init__(self, question_wizard: QuestionWizard, writer: ConfigWriter, parser: ConfigParser) -> None:
+        self._question_wizard = question_wizard
+        self._writer = writer
+        self._parser = parser
+
+    def execute(self) -> None:
+        answers = self._question_wizard.run()
+        configuration = self._parser.parse(answers)
+        self._writer.write(configuration)

instant_python-0.12.1/instant_python/config/delivery/cli.py

@@ -0,0 +1,19 @@
+import typer
+
+from instant_python.config.application.config_generator import ConfigGenerator
+from instant_python.config.infra.parser.parser import Parser
+from instant_python.config.infra.question_wizard.step.questionary import Questionary
+from instant_python.config.infra.question_wizard.questionary_console_wizard import QuestionaryConsoleWizard
+from instant_python.config.infra.writer.yaml_config_writer import YamlConfigWriter
+
+app = typer.Typer()
+
+
+@app.command("config", help="Generate the configuration file for a new project")
+def generate_ipy_configuration_file() -> None:
+    config_generator = ConfigGenerator(
+        question_wizard=QuestionaryConsoleWizard(questionary=(Questionary())),
+        writer=YamlConfigWriter(),
+        parser=Parser(),
+    )
+    config_generator.execute()

instant_python-0.12.1/instant_python/config/domain/config_parser.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from instant_python.config.domain.configuration_schema import ConfigurationSchema
+
+
+class ConfigParser(ABC):
+    @abstractmethod
+    def parse(self, content: dict[str, dict]) -> ConfigurationSchema:
+        raise NotImplementedError

instant_python-0.12.1/instant_python/config/domain/config_writer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from instant_python.config.domain.configuration_schema import ConfigurationSchema
+
+
+class ConfigWriter(ABC):
+    @abstractmethod
+    def write(self, configuration: ConfigurationSchema) -> None:
+        raise NotImplementedError

{instant_python-0.11.0/instant_python/configuration → instant_python-0.12.1/instant_python/config/domain}/configuration_schema.py

@@ -5,14 +5,14 @@ from typing import TypedDict, Union
 
 import yaml
 
-from instant_python.configuration.dependency.dependency_configuration import (
+from instant_python.config.domain.dependency_configuration import (
     DependencyConfiguration,
 )
-from instant_python.configuration.general.general_configuration import (
+from instant_python.config.domain.general_configuration import (
     GeneralConfiguration,
 )
-from instant_python.configuration.git.git_configuration import GitConfiguration
-from instant_python.configuration.template.template_configuration import (
+from instant_python.config.domain.git_configuration import GitConfiguration
+from instant_python.config.domain.template_configuration import (
     TemplateConfiguration,
 )
 
@@ -23,7 +23,7 @@ class ConfigurationSchema:
     dependencies: list[DependencyConfiguration]
     template: TemplateConfiguration
     git: GitConfiguration
-    _config_file_path: Path = field(default_factory=lambda: Path("ipy.yml"))
+    config_file_path: Path = field(default_factory=lambda: Path("ipy.yml"))
 
     @classmethod
     def from_file(
@@ -39,17 +39,17 @@ class ConfigurationSchema:
             dependencies=dependencies,
             template=template,
             git=git,
-            _config_file_path=Path(config_file_path),
+            config_file_path=Path(config_file_path),
         )
 
     def save_on_project_folder(self) -> None:
         destination_folder = Path.cwd() / self.project_folder_name
-        destination_path = destination_folder / self._config_file_path.name
+        destination_path = destination_folder / self.config_file_path.name
 
-        shutil.move(self._config_file_path, destination_path)
+        shutil.move(self.config_file_path, destination_path)
 
     def save_on_current_directory(self) -> None:
-        destination_folder = Path.cwd() / self._config_file_path
+        destination_folder = Path.cwd() / self.config_file_path
         with open(destination_folder, "w") as file:
             yaml.dump(self.to_primitives(), file)
 

{instant_python-0.11.0/instant_python/configuration/dependency → instant_python-0.12.1/instant_python/config/domain}/dependency_configuration.py

@@ -1,8 +1,7 @@
 from dataclasses import dataclass, field, asdict
 
-from instant_python.configuration.dependency.not_dev_dependency_included_in_group import (
-    NotDevDependencyIncludedInGroup,
-)
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
 
 
 @dataclass
@@ -34,3 +33,9 @@ class DependencyConfiguration:
     def _ensure_dependency_is_dev_if_group_is_set(self) -> None:
         if self.group and not self.is_dev:
             raise NotDevDependencyIncludedInGroup(self.name, self.group)
+
+
+class NotDevDependencyIncludedInGroup(ApplicationError):
+    def __init__(self, dependency_name: str, dependency_group: str) -> None:
+        message = f"Dependency '{dependency_name}' has been included in group '{dependency_group}' but it is not a development dependency. Please ensure that only development dependencies are included in groups."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

{instant_python-0.11.0/instant_python/configuration/general → instant_python-0.12.1/instant_python/config/domain}/general_configuration.py

@@ -2,15 +2,8 @@ from datetime import datetime
 from dataclasses import dataclass, asdict, field
 from typing import ClassVar
 
-from instant_python.configuration.general.invalid_dependency_manager_value import (
-    InvalidDependencyManagerValue,
-)
-from instant_python.configuration.general.invalid_license_value import (
-    InvalidLicenseValue,
-)
-from instant_python.configuration.general.invalid_python_version_value import (
-    InvalidPythonVersionValue,
-)
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
 from instant_python.shared.supported_licenses import SupportedLicenses
 from instant_python.shared.supported_managers import SupportedManagers
 from instant_python.shared.supported_python_versions import SupportedPythonVersions
@@ -58,3 +51,21 @@ class GeneralConfiguration:
 
     def to_primitives(self) -> dict[str, str]:
         return asdict(self)
+
+
+class InvalidDependencyManagerValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        message = f"Invalid dependency manager: {value}. Allowed values are {', '.join(supported_values)}."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class InvalidLicenseValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        message = f"Invalid license: {value}. Allowed values are {', '.join(supported_values)}."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class InvalidPythonVersionValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        message = f"Invalid Python version: {value}. Allowed versions are {', '.join(supported_values)}."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

{instant_python-0.11.0/instant_python/configuration/git → instant_python-0.12.1/instant_python/config/domain}/git_configuration.py

@@ -1,9 +1,8 @@
 from dataclasses import dataclass, field, asdict
 from typing import Optional
 
-from instant_python.configuration.git.git_user_or_email_not_present import (
-    GitUserOrEmailNotPresent,
-)
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
 
 
 @dataclass
@@ -21,3 +20,9 @@ class GitConfiguration:
 
     def to_primitives(self) -> dict[str, str | bool]:
         return asdict(self)
+
+
+class GitUserOrEmailNotPresent(ApplicationError):
+    def __init__(self) -> None:
+        message = "When initializing a git repository, both username and email must be provided."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python-0.12.1/instant_python/config/domain/question_wizard.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class QuestionWizard(ABC):
+    @abstractmethod
+    def run(self) -> dict:
+        raise NotImplementedError

{instant_python-0.11.0/instant_python/configuration/template → instant_python-0.12.1/instant_python/config/domain}/template_configuration.py

@@ -1,18 +1,8 @@
 from dataclasses import dataclass, field, asdict
 from typing import ClassVar, Optional, Union
 
-from instant_python.configuration.template.bounded_context_not_applicable import (
-    BoundedContextNotApplicable,
-)
-from instant_python.configuration.template.bounded_context_not_especified import (
-    BoundedContextNotSpecified,
-)
-from instant_python.configuration.template.invalid_built_in_features_values import (
-    InvalidBuiltInFeaturesValues,
-)
-from instant_python.configuration.template.invalid_template_value import (
-    InvalidTemplateValue,
-)
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
 from instant_python.shared.supported_built_in_features import SupportedBuiltInFeatures
 from instant_python.shared.supported_templates import SupportedTemplates
 
@@ -57,3 +47,29 @@ class TemplateConfiguration:
 
     def to_primitives(self) -> dict[str, Union[str, list[str]]]:
         return asdict(self)
+
+
+class BoundedContextNotApplicable(ApplicationError):
+    def __init__(self, value: str) -> None:
+        message = f"Bounded context feature is not applicable for template '{value}'. Is only applicable for 'domain_driven_design' template."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class BoundedContextNotSpecified(ApplicationError):
+    def __init__(self) -> None:
+        message = "Option to specify bounded context is set as True, but either bounded context or aggregate name is not specified."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class InvalidBuiltInFeaturesValues(ApplicationError):
+    def __init__(self, values: list[str], supported_values: list[str]) -> None:
+        message = (
+            f"Features {', '.join(values)} are not supported. Supported features are: {', '.join(supported_values)}."
+        )
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class InvalidTemplateValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        message = f"Invalid template: '{value}'. Supported templates are: {', '.join(supported_values)}."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python-0.12.1/instant_python/config/infra/parser/errors.py

@@ -0,0 +1,25 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+class ConfigKeyNotPresent(ApplicationError):
+    def __init__(self, missing_keys: list[str], required_keys: list[str]) -> None:
+        super().__init__(
+            message=f"The following required keys are missing from the configuration file: {', '.join(missing_keys)}. Required keys are: {', '.join(required_keys)}.",
+            error_type=ErrorTypes.CONFIGURATION.value,
+        )
+
+
+class EmptyConfigurationNotAllowed(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__(message="Configuration file cannot be empty.", error_type=ErrorTypes.CONFIGURATION.value)
+
+
+class MissingMandatoryFields(ApplicationError):
+    def __init__(self, missing_field: str, config_section: str) -> None:
+        super().__init__(
+            message=(
+                f"Mandatory field '{missing_field}' is missing in the '{config_section}' section of the configuration file."
+            ),
+            error_type=ErrorTypes.CONFIGURATION.value,
+        )

instant_python-0.12.1/instant_python/config/infra/parser/parser.py

@@ -0,0 +1,91 @@
+from typing import Union
+
+from instant_python.config.domain.config_parser import ConfigParser
+from instant_python.config.domain.configuration_schema import ConfigurationSchema
+from instant_python.config.domain.dependency_configuration import DependencyConfiguration
+from instant_python.config.domain.general_configuration import GeneralConfiguration
+from instant_python.config.domain.git_configuration import GitConfiguration
+from instant_python.config.domain.template_configuration import TemplateConfiguration
+from instant_python.config.infra.parser.errors import (
+    ConfigKeyNotPresent,
+    EmptyConfigurationNotAllowed,
+    MissingMandatoryFields,
+)
+
+
+class Parser(ConfigParser):
+    _GENERAL = "general"
+    _DEPENDENCIES = "dependencies"
+    _TEMPLATE = "template"
+    _GIT = "git"
+    _REQUIRED_CONFIG_KEYS = [_GENERAL, _DEPENDENCIES, _TEMPLATE, _GIT]
+
+    def parse(self, content: dict[str, dict]) -> ConfigurationSchema:
+        self._ensure_configuration_is_not_empty(content)
+        self._ensure_all_required_sections_are_present(content)
+        general_section = self._parse_general_section(content[self._GENERAL])
+        dependencies_section = self._parse_dependencies_section(content[self._DEPENDENCIES])
+        template_section = self._parse_template_section(content[self._TEMPLATE])
+        git_section = self._parse_git_section(content[self._GIT])
+        return ConfigurationSchema(
+            general=general_section,
+            dependencies=dependencies_section,
+            template=template_section,
+            git=git_section,
+        )
+
+    def _parse_general_section(self, fields: dict[str, str]) -> GeneralConfiguration:
+        try:
+            return GeneralConfiguration(**fields)
+        except TypeError as error:
+            self._ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], self._GENERAL) from error
+
+    def _parse_dependencies_section(
+        self,
+        fields: list[dict[str, Union[str, bool]]],
+    ) -> list[DependencyConfiguration]:
+        dependencies = []
+
+        if not fields:
+            return dependencies
+
+        for dependency_fields in fields:
+            try:
+                dependency = DependencyConfiguration(**dependency_fields)
+            except TypeError as error:
+                self._ensure_error_is_for_missing_fields(error)
+                raise MissingMandatoryFields(error.args[0], self._DEPENDENCIES) from error
+
+            dependencies.append(dependency)
+
+        return dependencies
+
+    def _parse_template_section(self, fields: dict[str, Union[str, bool, list[str]]]) -> TemplateConfiguration:
+        try:
+            return TemplateConfiguration(**fields)
+        except TypeError as error:
+            self._ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], self._TEMPLATE) from error
+
+    def _parse_git_section(self, fields: dict[str, Union[str, bool]]) -> GitConfiguration:
+        try:
+            return GitConfiguration(**fields)
+        except TypeError as error:
+            self._ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], self._GIT) from error
+
+    def _ensure_all_required_sections_are_present(self, content: dict[str, dict]):
+        missing_keys = [key for key in self._REQUIRED_CONFIG_KEYS if key not in content]
+        if missing_keys:
+            raise ConfigKeyNotPresent(missing_keys, self._REQUIRED_CONFIG_KEYS)
+
+    @staticmethod
+    def _ensure_configuration_is_not_empty(content: dict[str, dict]):
+        if not content:
+            raise EmptyConfigurationNotAllowed
+
+    @staticmethod
+    def _ensure_error_is_for_missing_fields(error: TypeError) -> None:
+        if ".__init__() missing" not in str(error):
+            raise error

instant_python-0.12.1/instant_python/config/infra/question_wizard/questionary_console_wizard.py

@@ -0,0 +1,25 @@
+from instant_python.config.domain.question_wizard import QuestionWizard
+from instant_python.config.infra.question_wizard.step.dependencies_step import DependenciesStep
+from instant_python.config.infra.question_wizard.step.general_step import GeneralStep
+from instant_python.config.infra.question_wizard.step.git_step import GitStep
+from instant_python.config.infra.question_wizard.step.questionary import Questionary
+from instant_python.config.infra.question_wizard.step.steps import Steps
+from instant_python.config.infra.question_wizard.step.template_step import TemplateStep
+
+
+class QuestionaryConsoleWizard(QuestionWizard):
+    def __init__(self, questionary: Questionary) -> None:
+        self._steps = Steps(
+            GeneralStep(questionary=questionary),
+            TemplateStep(questionary=questionary),
+            GitStep(questionary=questionary),
+            DependenciesStep(questionary=questionary),
+        )
+        self._answers = {}
+
+    def run(self) -> dict:
+        for step in self._steps:
+            answer = step.run()
+            self._answers.update(answer)
+
+        return self._answers

instant_python-0.12.1/instant_python/config/infra/question_wizard/step/dependencies_step.py

@@ -0,0 +1,64 @@
+from typing import Union
+
+from instant_python.config.infra.question_wizard.step.questionary import Questionary
+from instant_python.config.infra.question_wizard.step.steps import Step
+
+
+class DependenciesStep(Step):
+    _KEY = "dependencies"
+
+    def __init__(self, questionary: Questionary) -> None:
+        super().__init__(questionary)
+        self._dependencies = []
+
+    def run(self) -> dict[str, list[dict[str, Union[str, bool]]]]:
+        while True:
+            if not self._user_wants_to_install_dependencies():
+                break
+
+            name = self._ask_dependency_name()
+            if not name:
+                print("Dependency name cannot be empty. Let's try again.")
+                continue
+            version = self._ask_dependency_version()
+            is_for_development = self._ask_if_dependency_is_for_development_purpose(name)
+            group_name = self._ask_dev_dependency_group_name() if is_for_development else ""
+
+            self._dependencies.append(
+                {
+                    "name": name,
+                    "version": version,
+                    "is_dev": is_for_development,
+                    "group": group_name,
+                }
+            )
+
+        return {self._KEY: self._dependencies}
+
+    def _ask_dev_dependency_group_name(self) -> str:
+        return self._questionary.free_text_question(
+            message="Specify the name of the group where to install the dependency (leave empty if not applicable)",
+            default="",
+        )
+
+    def _ask_if_dependency_is_for_development_purpose(self, name: str) -> bool:
+        return self._questionary.boolean_question(
+            message=f"Do you want to install {name} as a dev dependency?",
+            default=False,
+        )
+
+    def _ask_dependency_version(self) -> str:
+        return self._questionary.free_text_question(
+            message="Enter the version of the dependency you want to install",
+            default="latest",
+        )
+
+    def _ask_dependency_name(self) -> str:
+        return self._questionary.free_text_question(
+            message="Enter the name of the dependency you want to install",
+        )
+
+    def _user_wants_to_install_dependencies(self) -> bool:
+        return self._questionary.boolean_question(
+            message="Do you want to install dependencies?",
+        )