instant-python 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

instant_python/cli.py

@@ -1,15 +1,15 @@
 from rich.console import Console
 from rich.panel import Panel
 
-from instant_python import folder_cli, project_cli
-from instant_python.errors.application_error import ApplicationError
-from instant_python.intant_python_typer import InstantPythonTyper
+from instant_python.commands import init, config
+from instant_python.shared.application_error import ApplicationError
+from instant_python.instant_python_typer import InstantPythonTyper
 
 app = InstantPythonTyper()
 console = Console()
 
-app.add_typer(folder_cli.app, name="folder", help="Generate only the folder structure for a new project")
-app.add_typer(project_cli.app, name="project", help="Generate a full project ready to be used")
+app.add_typer(init.app)
+app.add_typer(config.app)
 
 
 @app.error_handler(ApplicationError)

instant_python/commands/config.py

@@ -0,0 +1,28 @@
+import typer
+
+from instant_python.configuration.parser.parser import Parser
+from instant_python.configuration.question.questionary import Questionary
+from instant_python.configuration.question_wizard import QuestionWizard
+from instant_python.configuration.step.dependencies_step import DependenciesStep
+from instant_python.configuration.step.general_step import GeneralStep
+from instant_python.configuration.step.git_step import GitStep
+from instant_python.configuration.step.steps import Steps
+from instant_python.configuration.step.template_step import TemplateStep
+
+app = typer.Typer()
+
+
+@app.command("config", help="Generate the configuration file for a new project")
+def create_new_project() -> None:
+    questionary = Questionary()
+    steps = Steps(
+        GeneralStep(questionary=questionary),
+        TemplateStep(questionary=questionary),
+        GitStep(questionary=questionary),
+        DependenciesStep(questionary=questionary),
+    )
+
+    question_wizard = QuestionWizard(steps=steps)
+    configuration = question_wizard.run()
+    validated_configuration = Parser.parse_from_answers(configuration)
+    validated_configuration.save_on_current_directory()

instant_python/commands/init.py

@@ -0,0 +1,53 @@
+import typer
+
+from instant_python.configuration.parser.parser import Parser
+from instant_python.dependency_manager.dependency_manager_factory import DependencyManagerFactory
+from instant_python.git.git_configurer import GitConfigurer
+from instant_python.project_creator.file_system import FileSystem
+from instant_python.render.custom_project_renderer import CustomProjectRenderer
+from instant_python.render.jinja_environment import JinjaEnvironment
+from instant_python.render.jinja_project_renderer import JinjaProjectRenderer
+
+app = typer.Typer()
+
+
+@app.command("init", help="Create a new project")
+def create_new_project(
+    config_file: str = typer.Option("ipy.yml", "--config", "-c", help="Path to yml configuration file"),
+    template: str | None = typer.Option(None, "--template", "-t", help="Path to custom template file"),
+) -> None:
+    configuration = Parser.parse_from_file(config_file_path=config_file)
+    environment = JinjaEnvironment(package_name="instant_python", template_directory="templates")
+
+    if template:
+        project_renderer = CustomProjectRenderer(template_path=template)
+        project_structure = project_renderer.render_project_structure()
+    else:
+        project_renderer = JinjaProjectRenderer(jinja_environment=environment)
+        project_structure = project_renderer.render_project_structure(
+            context_config=configuration,
+            template_base_dir="project_structure",
+        )
+
+    file_system = FileSystem(project_structure=project_structure)
+    file_system.write_on_disk(
+        file_renderer=environment,
+        context=configuration,
+    )
+
+    dependency_manager = DependencyManagerFactory.create(
+        dependency_manager=configuration.dependency_manager,
+        project_directory=configuration.project_folder_name,
+    )
+    dependency_manager.setup_environment(
+        python_version=configuration.python_version,
+        dependencies=configuration.dependencies,
+    )
+
+    git_configurer = GitConfigurer(project_directory=configuration.project_folder_name)
+    git_configurer.setup_repository(configuration.git)
+    configuration.save_on_project_folder()
+
+
+if __name__ == "__main__":
+    app()

instant_python/configuration/configuration_schema.py

@@ -0,0 +1,85 @@
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TypedDict, Self, Union
+
+import yaml
+
+from instant_python.configuration.dependency.dependency_configuration import (
+    DependencyConfiguration,
+)
+from instant_python.configuration.general.general_configuration import (
+    GeneralConfiguration,
+)
+from instant_python.configuration.git.git_configuration import GitConfiguration
+from instant_python.configuration.template.template_configuration import (
+    TemplateConfiguration,
+)
+
+
+@dataclass
+class ConfigurationSchema:
+    general: GeneralConfiguration
+    dependencies: list[DependencyConfiguration]
+    template: TemplateConfiguration
+    git: GitConfiguration
+    _config_file_path: Path = field(default_factory=lambda: Path("ipy.yml"))
+
+    @classmethod
+    def from_file(
+        cls,
+        config_file_path: str,
+        general: GeneralConfiguration,
+        dependencies: list[DependencyConfiguration],
+        template: TemplateConfiguration,
+        git: GitConfiguration,
+    ) -> Self:
+        return cls(
+            general=general,
+            dependencies=dependencies,
+            template=template,
+            git=git,
+            _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
+
+        shutil.move(self._config_file_path, destination_path)
+
+    def save_on_current_directory(self) -> None:
+        destination_folder = Path.cwd() / self._config_file_path
+        with open(destination_folder, "w") as file:
+            yaml.dump(self.to_primitives(), file)
+
+    def to_primitives(self) -> "ConfigurationSchemaPrimitives":
+        return ConfigurationSchemaPrimitives(
+            general=self.general.to_primitives(),
+            dependencies=[dependency.to_primitives() for dependency in self.dependencies],
+            template=self.template.to_primitives(),
+            git=self.git.to_primitives(),
+        )
+
+    @property
+    def template_type(self) -> str:
+        return self.template.name
+
+    @property
+    def project_folder_name(self) -> str:
+        return self.general.slug
+
+    @property
+    def dependency_manager(self) -> str:
+        return self.general.dependency_manager
+
+    @property
+    def python_version(self) -> str:
+        return self.general.python_version
+
+
+class ConfigurationSchemaPrimitives(TypedDict):
+    general: dict[str, str]
+    dependencies: list[dict[str, Union[str, bool]]]
+    template: dict[str, Union[str, list[str]]]
+    git: dict[str, Union[str, bool]]

instant_python/configuration/dependency/dependency_configuration.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass, field, asdict
+
+from instant_python.configuration.dependency.not_dev_dependency_included_in_group import (
+    NotDevDependencyIncludedInGroup,
+)
+
+
+@dataclass
+class DependencyConfiguration:
+    name: str
+    version: str
+    is_dev: bool = field(default=False)
+    group: str = field(default_factory=str)
+
+    def __post_init__(self) -> None:
+        self.version = str(self.version)
+        self._ensure_dependency_is_dev_if_group_is_set()
+
+    def to_primitives(self) -> dict[str, str | bool]:
+        return asdict(self)
+
+    def get_installation_flag(self) -> tuple[str, ...]:
+        if self.group:
+            return (f"--group {self.group}",)
+        elif self.is_dev:
+            return ("--dev",)
+        return tuple()
+
+    def get_specification(self) -> str:
+        if self.version == "latest":
+            return self.name
+        return f"{self.name}=={self.version}"
+
+    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)

instant_python/configuration/dependency/not_dev_dependency_included_in_group.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+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/configuration/general/general_configuration.py

@@ -0,0 +1,60 @@
+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.supported_licenses import SupportedLicenses
+from instant_python.shared.supported_managers import SupportedManagers
+from instant_python.shared.supported_python_versions import SupportedPythonVersions
+
+
+@dataclass
+class GeneralConfiguration:
+    slug: str
+    source_name: str
+    description: str
+    version: str
+    author: str
+    license: str
+    python_version: str
+    dependency_manager: str
+    year: int = field(default=datetime.now().year)
+
+    _SUPPORTED_DEPENDENCY_MANAGERS: ClassVar[list[str]] = SupportedManagers.get_supported_managers()
+    _SUPPORTED_PYTHON_VERSIONS: ClassVar[list[str]] = SupportedPythonVersions.get_supported_versions()
+    _SUPPORTED_LICENSES: ClassVar[list[str]] = SupportedLicenses.get_supported_licenses()
+
+    def __post_init__(self) -> None:
+        self.version = str(self.version)
+        self.python_version = str(self.python_version)
+        self._remove_white_spaces_from_slug_if_present()
+        self._ensure_license_is_supported()
+        self._ensure_python_version_is_supported()
+        self._ensure_dependency_manager_is_supported()
+
+    def _remove_white_spaces_from_slug_if_present(self) -> None:
+        if " " in self.slug:
+            self.slug = self.slug.replace(" ", "")
+
+    def _ensure_license_is_supported(self) -> None:
+        if self.license not in self._SUPPORTED_LICENSES:
+            raise InvalidLicenseValue(self.license, self._SUPPORTED_LICENSES)
+
+    def _ensure_python_version_is_supported(self) -> None:
+        if self.python_version not in self._SUPPORTED_PYTHON_VERSIONS:
+            raise InvalidPythonVersionValue(self.python_version, self._SUPPORTED_PYTHON_VERSIONS)
+
+    def _ensure_dependency_manager_is_supported(self) -> None:
+        if self.dependency_manager not in self._SUPPORTED_DEPENDENCY_MANAGERS:
+            raise InvalidDependencyManagerValue(self.dependency_manager, self._SUPPORTED_DEPENDENCY_MANAGERS)
+
+    def to_primitives(self) -> dict[str, str]:
+        return asdict(self)

instant_python/configuration/general/invalid_dependency_manager_value.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+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)

instant_python/configuration/general/invalid_license_value.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+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)

instant_python/configuration/general/invalid_python_version_value.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+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/configuration/git/git_configuration.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+from instant_python.configuration.git.git_user_or_email_not_present import (
+    GitUserOrEmailNotPresent,
+)
+
+
+@dataclass
+class GitConfiguration:
+    initialize: bool
+    username: Optional[str] = field(default=None)
+    email: Optional[str] = field(default=None)
+
+    def __post_init__(self) -> None:
+        self._ensure_username_and_email_are_set_if_initializing()
+
+    def _ensure_username_and_email_are_set_if_initializing(self) -> None:
+        if self.initialize and (self.username is None or self.email is None):
+            raise GitUserOrEmailNotPresent()
+
+    def to_primitives(self) -> dict[str, str | bool]:
+        return asdict(self)

instant_python/configuration/git/git_user_or_email_not_present.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+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/configuration/parser/config_key_not_present.py

@@ -0,0 +1,8 @@
+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:
+        message = f"The following required keys are missing from the configuration file: {', '.join(missing_keys)}. Required keys are: {', '.join(required_keys)}."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python/configuration/parser/configuration_file_not_found.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+class ConfigurationFileNotFound(ApplicationError):
+    def __init__(self, path: str) -> None:
+        message = f"Configuration file not found at '{path}'."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python/configuration/parser/empty_configuration_not_allowed.py

@@ -0,0 +1,8 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+class EmptyConfigurationNotAllowed(ApplicationError):
+    def __init__(self) -> None:
+        message = "Configuration file cannot be empty."
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python/configuration/parser/missing_mandatory_fields.py

@@ -0,0 +1,10 @@
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.error_types import ErrorTypes
+
+
+class MissingMandatoryFields(ApplicationError):
+    def __init__(self, missing_field: str, config_section: str) -> None:
+        message = (
+            f"Mandatory field '{missing_field}' is missing in the '{config_section}' section of the configuration file."
+        )
+        super().__init__(message=message, error_type=ErrorTypes.CONFIGURATION.value)

instant_python/configuration/parser/parser.py

@@ -0,0 +1,148 @@
+from typing import Union
+
+import yaml
+
+from instant_python.configuration.parser.config_key_not_present import ConfigKeyNotPresent
+from instant_python.configuration.configuration_schema import ConfigurationSchema
+from instant_python.configuration.dependency.dependency_configuration import (
+    DependencyConfiguration,
+)
+from instant_python.configuration.general.general_configuration import (
+    GeneralConfiguration,
+)
+from instant_python.configuration.git.git_configuration import GitConfiguration
+from instant_python.configuration.parser.configuration_file_not_found import (
+    ConfigurationFileNotFound,
+)
+from instant_python.configuration.parser.empty_configuration_not_allowed import (
+    EmptyConfigurationNotAllowed,
+)
+from instant_python.configuration.parser.missing_mandatory_fields import (
+    MissingMandatoryFields,
+)
+from instant_python.configuration.template.template_configuration import TemplateConfiguration
+
+
+class Parser:
+    REQUIRED_CONFIG_KEYS = ["general", "dependencies", "template", "git"]
+
+    @classmethod
+    def parse_from_file(cls, config_file_path: str) -> ConfigurationSchema:
+        """Parses the configuration file and validates its content.
+
+        Args:
+            config_file_path: The path to the configuration file to be parsed.
+        Returns:
+            ConfigurationSchema: An instance of ConfigurationSchema containing the parsed configuration.
+        Raises:
+            ConfigurationFileNotFound: If the configuration file does not exist in that path.
+            EmptyConfigurationNotAllowed: If the configuration file is empty.
+            ConfigKeyNotPresent: If any of the required keys are missing from the configuration.
+            MissingMandatoryFields: If any mandatory fields are missing in the configuration sections.
+        """
+        content = cls._get_config_file_content(config_file_path)
+        general_configuration, dependencies_configuration, template_configuration, git_configuration = (
+            cls._parse_configuration(content=content)
+        )
+        return ConfigurationSchema.from_file(
+            config_file_path=config_file_path,
+            general=general_configuration,
+            dependencies=dependencies_configuration,
+            template=template_configuration,
+            git=git_configuration,
+        )
+
+    @classmethod
+    def parse_from_answers(cls, content: dict[str, dict]) -> ConfigurationSchema:
+        general_configuration, dependencies_configuration, template_configuration, git_configuration = (
+            cls._parse_configuration(content=content)
+        )
+        return ConfigurationSchema(
+            general=general_configuration,
+            dependencies=dependencies_configuration,
+            template=template_configuration,
+            git=git_configuration,
+        )
+
+    @classmethod
+    def _parse_configuration(cls, content: dict[str, dict]) -> tuple:
+        general_configuration = cls._parse_general_configuration(content["general"])
+        dependencies_configuration = cls._parse_dependencies_configuration(content["dependencies"])
+        template_configuration = cls._parse_template_configuration(content["template"])
+        git_configuration = cls._parse_git_configuration(content["git"])
+        return general_configuration, dependencies_configuration, template_configuration, git_configuration
+
+    @classmethod
+    def _get_config_file_content(cls, config_file_path: str) -> dict[str, dict]:
+        content = cls._read_config_file(config_file_path)
+        cls._ensure_config_file_is_not_empty(content)
+        cls._ensure_all_required_keys_are_present(content)
+        return content
+
+    @staticmethod
+    def _ensure_config_file_is_not_empty(content: dict[str, dict]) -> None:
+        if not content:
+            raise EmptyConfigurationNotAllowed()
+
+    @staticmethod
+    def _read_config_file(config_file_path: str) -> dict[str, dict]:
+        try:
+            with open(config_file_path, "r") as file:
+                return yaml.safe_load(file)
+        except FileNotFoundError:
+            raise ConfigurationFileNotFound(config_file_path)
+
+    @staticmethod
+    def _ensure_all_required_keys_are_present(content: dict[str, dict]) -> None:
+        missing_keys = [key for key in Parser.REQUIRED_CONFIG_KEYS if key not in content]
+        if missing_keys:
+            raise ConfigKeyNotPresent(missing_keys, Parser.REQUIRED_CONFIG_KEYS)
+
+    @staticmethod
+    def _parse_general_configuration(fields: dict[str, str]) -> GeneralConfiguration:
+        try:
+            return GeneralConfiguration(**fields)
+        except TypeError as error:
+            _ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], "general") from error
+
+    @staticmethod
+    def _parse_dependencies_configuration(
+        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:
+                _ensure_error_is_for_missing_fields(error)
+                raise MissingMandatoryFields(error.args[0], "dependencies") from error
+
+            dependencies.append(dependency)
+
+        return dependencies
+
+    @staticmethod
+    def _parse_template_configuration(fields: dict[str, Union[str, bool, list[str]]]) -> TemplateConfiguration:
+        try:
+            return TemplateConfiguration(**fields)
+        except TypeError as error:
+            _ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], "template") from error
+
+    @staticmethod
+    def _parse_git_configuration(fields: dict[str, Union[str, bool]]) -> GitConfiguration:
+        try:
+            return GitConfiguration(**fields)
+        except TypeError as error:
+            _ensure_error_is_for_missing_fields(error)
+            raise MissingMandatoryFields(error.args[0], "git") from error
+
+
+def _ensure_error_is_for_missing_fields(error: TypeError) -> None:
+    if ".__init__() missing" not in str(error):
+        raise error

instant_python/configuration/question/boolean_question.py

@@ -0,0 +1,12 @@
+from instant_python.configuration.question.question import Question
+from instant_python.configuration.question.questionary import Questionary
+
+
+class BooleanQuestion(Question[bool]):
+    def __init__(self, key: str, message: str, default: bool, questionary: Questionary) -> None:
+        super().__init__(key, message, questionary)
+        self._default = default
+
+    def ask(self) -> dict[str, bool]:
+        answer = self._questionary.boolean_question(self._message, default=self._default)
+        return {self._key: answer}

instant_python/configuration/question/choice_question.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+from instant_python.configuration.question.question import Question
+from instant_python.configuration.question.questionary import Questionary
+
+
+class ChoiceQuestion(Question[str]):
+    def __init__(self, key: str, message: str, questionary: Questionary, options: Optional[list[str]] = None) -> None:
+        super().__init__(key, message, questionary)
+        self._default = options[0] if options else ""
+        self._options = options if options else []
+
+    def ask(self) -> dict[str, str]:
+        answer = self._questionary.single_choice_question(
+            self._message,
+            options=self._options,
+            default=self._default,
+        )
+        return {self._key: answer}

instant_python/{question_prompter → configuration}/question/conditional_question.py

@@ -1,11 +1,14 @@
 from typing import Union
 
-from instant_python.question_prompter.question.question import Question
+from instant_python.configuration.question.question import Question
 
 
 class ConditionalQuestion:
     def __init__(
-        self, base_question: Question, subquestions: Union[list[Question], "ConditionalQuestion"], condition: str | bool
+        self,
+        base_question: Question,
+        subquestions: Union[list[Question], "ConditionalQuestion"],
+        condition: Union[str, bool],
     ) -> None:
         self._base_question = base_question
         self._subquestions = subquestions
@@ -18,7 +21,7 @@ class ConditionalQuestion:
             return base_answer
 
         answers = base_answer
-        
+
         if isinstance(self._subquestions, ConditionalQuestion):
             answers.update(self._subquestions.ask())
         else:

instant_python/configuration/question/free_text_question.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from instant_python.configuration.question.question import Question
+from instant_python.configuration.question.questionary import Questionary
+
+
+class FreeTextQuestion(Question[str]):
+    def __init__(self, key: str, message: str, questionary: Questionary, default: Optional[str] = None) -> None:
+        super().__init__(key, message, questionary)
+        self._default = default if default else ""
+
+    def ask(self) -> dict[str, str]:
+        answer = self._questionary.free_text_question(self._message, default=self._default)
+        return {self._key: answer}

instant_python/configuration/question/multiple_choice_question.py

@@ -0,0 +1,12 @@
+from instant_python.configuration.question.question import Question
+from instant_python.configuration.question.questionary import Questionary
+
+
+class MultipleChoiceQuestion(Question[list[str]]):
+    def __init__(self, key: str, message: str, options: list[str], questionary: Questionary) -> None:
+        super().__init__(key, message, questionary)
+        self._options = options
+
+    def ask(self) -> dict[str, list[str]]:
+        answer = self._questionary.multiselect_question(self._message, options=self._options)
+        return {self._key: answer}

instant_python/{question_prompter → configuration}/question/question.py

@@ -2,17 +2,21 @@ from abc import ABC, abstractmethod
 
 from typing import TypeVar, Generic
 
+from instant_python.configuration.question.questionary import Questionary
+
 T = TypeVar("T")
 
+
 class Question(Generic[T], ABC):
-    def __init__(self, key: str, message: str) -> None:
+    def __init__(self, key: str, message: str, questionary: Questionary) -> None:
         self._key = key
         self._message = message
+        self._questionary = questionary
 
     @abstractmethod
     def ask(self) -> dict[str, T]:
         raise NotImplementedError
-    
+
     @property
     def key(self) -> str:
         return self._key