instant-python 0.20.0__py3-none-any.whl

instant_python/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.20.0"

instant_python/cli/cli.py

@@ -0,0 +1,58 @@
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from instant_python import __version__
+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
+
+app = InstantPythonTyper()
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        console.print(f"instant-python {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            help="Show the application version",
+            callback=version_callback,
+            is_eager=True,
+        ),
+    ] = None,
+) -> None:
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+
+
+app.add_typer(init.app)
+app.add_typer(config.app)
+
+
+@app.error_handler(ApplicationError)
+def handle_application_error(exc: ApplicationError) -> None:
+    error_panel = Panel(exc.message, title="Error", border_style="red")
+    console.print(error_panel)
+
+
+@app.error_handler(Exception)
+def handle_unexpected_error(exc: Exception) -> None:
+    error_panel = Panel(f"An unexpected error occurred: {exc}", title="Error", border_style="red")
+    console.print(error_panel)
+
+
+if __name__ == "__main__":
+    app()

instant_python/cli/instant_python_typer.py

@@ -0,0 +1,35 @@
+import sys
+from collections.abc import Callable
+from typing import Any
+
+import typer
+
+ExceptionType = type[Exception]
+ErrorHandlingCallback = Callable[[Exception], None]
+
+
+class InstantPythonTyper(typer.Typer):
+    error_handlers: dict[ExceptionType, ErrorHandlingCallback] = {}
+
+    def error_handler(self, exc: ExceptionType) -> Callable[[Callable[[Exception], None]], Callable[[Exception], None]]:
+        """Registers a callback function to be called when 'exc' (the given exception) is raised."""
+
+        def decorator(func: ErrorHandlingCallback) -> Callable[[Exception], None]:
+            self.error_handlers[exc] = func
+            return func
+
+        return decorator
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """Overrides Typer.__call__ so that when we run the CLI,
+        we can catch any exception that's raised and see if there's
+        a matching error handler for it.
+        """
+        try:
+            super().__call__(*args, **kwargs)
+        except Exception as error:
+            for registered_exc_type, handler in self.error_handlers.items():
+                if isinstance(error, registered_exc_type):
+                    handler(error)
+                    sys.exit(1)
+            raise

instant_python/config/application/config_generator.py

@@ -0,0 +1,23 @@
+from instant_python.shared.domain.config_repository import ConfigRepository
+from instant_python.shared.domain.config_schema import ConfigSchema
+from instant_python.config.domain.question_wizard import QuestionWizard
+
+
+class ConfigGenerator:
+    def __init__(self, question_wizard: QuestionWizard, repository: ConfigRepository) -> None:
+        self._question_wizard = question_wizard
+        self._repository = repository
+
+    def execute(self) -> None:
+        answers = self._ask_project_configuration_to_user()
+        config = self._create_configuration_based_on_answers(answers)
+        self._save_configuration(config)
+
+    def _create_configuration_based_on_answers(self, answers: dict) -> ConfigSchema:
+        return ConfigSchema.from_primitives(answers)
+
+    def _save_configuration(self, config: ConfigSchema) -> None:
+        self._repository.write(config)
+
+    def _ask_project_configuration_to_user(self) -> dict:
+        return self._question_wizard.run()

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.question_wizard.step.questionary import Questionary
+from instant_python.config.infra.question_wizard.questionary_console_wizard import QuestionaryConsoleWizard
+from instant_python.shared.infra.persistence.yaml_config_repository import YamlConfigRepository
+
+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(),
+        ),
+        repository=YamlConfigRepository(),
+    )
+    config_generator.execute()

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/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/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?",
+        )

instant_python/config/infra/question_wizard/step/general_step.py

@@ -0,0 +1,81 @@
+from instant_python.config.infra.question_wizard.step.questionary import Questionary
+from instant_python.config.infra.question_wizard.step.steps import Step
+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
+
+
+class GeneralStep(Step):
+    _KEY = "general"
+
+    def __init__(self, questionary: Questionary) -> None:
+        super().__init__(questionary)
+        self._answers = {}
+
+    def run(self) -> dict[str, dict[str, str]]:
+        self._ask_project_slug()
+        self._ask_source_folder_name()
+        self._ask_project_description()
+        self._ask_project_version()
+        self._ask_author_name()
+        self._ask_license()
+        self._ask_python_version()
+        self._ask_dependency_manager()
+
+        return {self._KEY: self._answers}
+
+    def _ask_project_slug(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter the name of the project (CANNOT CONTAIN SPACES)",
+            default="python-project",
+        )
+        self._answers["slug"] = answer
+
+    def _ask_source_folder_name(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter the name of the source folder",
+            default="src",
+        )
+        self._answers["source_name"] = answer
+
+    def _ask_project_description(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter the project description",
+            default="Python Project Description",
+        )
+        self._answers["description"] = answer
+
+    def _ask_project_version(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter the project initial version",
+            default="0.1.0",
+        )
+        self._answers["version"] = answer
+
+    def _ask_author_name(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter your name",
+        )
+        self._answers["author"] = answer
+
+    def _ask_license(self) -> None:
+        answer = self._questionary.single_choice_question(
+            message="Select a license",
+            options=SupportedLicenses.get_supported_licenses(),
+        )
+        self._answers["license"] = answer
+
+    def _ask_python_version(self) -> None:
+        answer = self._questionary.single_choice_question(
+            message="Enter the python version",
+            options=SupportedPythonVersions.get_supported_versions(),
+        )
+        self._answers["python_version"] = answer
+
+    def _ask_dependency_manager(self) -> None:
+        answer = self._questionary.single_choice_question(
+            message="Select a dependency manager",
+            options=SupportedManagers.get_supported_managers(),
+            default=SupportedManagers.UV,
+        )
+        self._answers["dependency_manager"] = answer

instant_python/config/infra/question_wizard/step/git_step.py

@@ -0,0 +1,41 @@
+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 GitStep(Step):
+    _KEY = "git"
+
+    def __init__(self, questionary: Questionary) -> None:
+        super().__init__(questionary)
+        self._answers = {}
+
+    def run(self) -> dict[str, dict[str, Union[str, bool]]]:
+        if not self._user_wants_initialize_git_repository():
+            return {self._KEY: self._answers}
+
+        self._ask_git_username()
+        self._ask_git_email()
+
+        return {self._KEY: self._answers}
+
+    def _ask_git_email(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Type your git email",
+        )
+        self._answers["email"] = answer
+
+    def _ask_git_username(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Type your git user name",
+        )
+        self._answers["username"] = answer
+
+    def _user_wants_initialize_git_repository(self) -> bool:
+        answer = self._questionary.boolean_question(
+            message="Do you want to initialize a git repository?",
+            default=True,
+        )
+        self._answers["initialize"] = answer
+        return answer

instant_python/config/infra/question_wizard/step/questionary.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+import questionary
+
+
+class Questionary:
+    def boolean_question(self, message: str, default: bool = False) -> bool:
+        return questionary.confirm(message, default=default).ask()
+
+    def free_text_question(self, message: str, default: Optional[str] = None) -> str:
+        return questionary.text(message, default=default if default else "").ask()
+
+    def single_choice_question(self, message: str, options: list[str], default: Optional[str] = None) -> str:
+        return questionary.select(message, choices=options, default=default).ask()
+
+    def multiselect_question(self, message: str, options: list[str]) -> list[str]:
+        return questionary.checkbox(message, choices=options).ask()

instant_python/config/infra/question_wizard/step/steps.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+
+from instant_python.config.infra.question_wizard.step.questionary import Questionary
+
+
+class Step(ABC):
+    def __init__(self, questionary: Questionary) -> None:
+        self._questionary = questionary
+
+    @abstractmethod
+    def run(self) -> dict[str, dict]:
+        raise NotImplementedError
+
+
+class Steps:
+    def __init__(self, *step: Step) -> None:
+        self._steps = list(step)
+
+    def __iter__(self) -> Iterator[Step]:
+        return iter(self._steps)

instant_python/config/infra/question_wizard/step/template_step.py

@@ -0,0 +1,63 @@
+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
+from instant_python.shared.supported_built_in_features import SupportedBuiltInFeatures
+from instant_python.shared.supported_templates import SupportedTemplates
+
+
+class TemplateStep(Step):
+    _KEY = "template"
+
+    def __init__(self, questionary: Questionary) -> None:
+        super().__init__(questionary)
+        self._answers = {}
+
+    def run(self) -> dict[str, dict[str, Union[str, list[str]]]]:
+        name = self._choose_template_name_from_options()
+
+        if name == SupportedTemplates.DDD and self._user_wants_to_specify_bounded_context():
+            self._ask_bounded_context_name()
+            self._ask_aggregate_name()
+
+        if name != SupportedTemplates.CUSTOM:
+            self._select_built_in_features()
+
+        return {self._KEY: self._answers}
+
+    def _choose_template_name_from_options(self) -> str:
+        answer = self._questionary.single_choice_question(
+            message="Select a template",
+            options=SupportedTemplates.get_supported_templates(),
+        )
+        self._answers["name"] = answer
+        return answer
+
+    def _user_wants_to_specify_bounded_context(self) -> None:
+        answer = self._questionary.boolean_question(
+            message="Do you want to specify your first bounded context?",
+            default=True,
+        )
+        self._answers["specify_bounded_context"] = answer
+
+    def _ask_bounded_context_name(self) -> str:
+        answer = self._questionary.free_text_question(
+            message="Enter the bounded context name",
+            default="backoffice",
+        )
+        self._answers["bounded_context"] = answer
+        return answer
+
+    def _ask_aggregate_name(self) -> None:
+        answer = self._questionary.free_text_question(
+            message="Enter the aggregate name",
+            default="user",
+        )
+        self._answers["aggregate_name"] = answer
+
+    def _select_built_in_features(self) -> None:
+        answer = self._questionary.multiselect_question(
+            message="Select the built-in features you want to include",
+            options=SupportedBuiltInFeatures.get_supported_built_in_features(),
+        )
+        self._answers["built_in_features"] = answer

instant_python/initialize/application/project_initializer.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+
+from instant_python.shared.domain.config_schema import ConfigSchema
+from instant_python.initialize.domain.env_manager import EnvManager
+from instant_python.initialize.domain.project_formatter import ProjectFormatter
+from instant_python.initialize.domain.project_renderer import ProjectRenderer
+from instant_python.initialize.domain.project_writer import ProjectWriter
+from instant_python.initialize.domain.version_control_configurer import VersionControlConfigurer
+
+
+class ProjectInitializer:
+    def __init__(
+        self,
+        renderer: ProjectRenderer,
+        writer: ProjectWriter,
+        env_manager: EnvManager,
+        version_control_configurer: VersionControlConfigurer,
+        formatter: ProjectFormatter,
+    ) -> None:
+        self._project_renderer = renderer
+        self._writer = writer
+        self._env_manager = env_manager
+        self._version_control_configurer = version_control_configurer
+        self._formatter = formatter
+
+    def execute(self, config: ConfigSchema, destination_project_folder: Path) -> None:
+        self._create_project_at_destination_folder(config, destination_project_folder)
+        self._setup_development_environment(config)
+        if config.version_control_has_to_be_initialized:
+            self._setup_version_control_system(config)
+        self._format_final_project()
+
+    def _format_final_project(self) -> None:
+        self._formatter.format()
+
+    def _setup_version_control_system(self, config: ConfigSchema) -> None:
+        self._version_control_configurer.setup(config.git)
+
+    def _setup_development_environment(self, config: ConfigSchema) -> None:
+        self._env_manager.setup(
+            python_version=config.python_version,
+            dependencies=config.dependencies,
+        )
+
+    def _create_project_at_destination_folder(self, config: ConfigSchema, destination_project_folder: Path) -> None:
+        project_structure = self._project_renderer.render(context_config=config)
+        self._writer.write(project_structure=project_structure, destination=destination_project_folder)

instant_python/initialize/delivery/cli.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+import typer
+
+from instant_python.initialize.application.project_initializer import ProjectInitializer
+from instant_python.initialize.infra.env_manager.env_manager_factory import EnvManagerFactory
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+from instant_python.initialize.infra.formatter.ruff_project_formatter import RuffProjectFormatter
+from instant_python.shared.infra.persistence.yaml_config_repository import YamlConfigRepository
+from instant_python.initialize.infra.renderer.jinja_environment import JinjaEnvironment
+from instant_python.initialize.infra.renderer.jinja_project_renderer import JinjaProjectRenderer
+from instant_python.initialize.infra.version_control.git_configurer import GitConfigurer
+from instant_python.initialize.infra.writer.file_system_project_writer import FileSystemProjectWriter
+
+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. Default: ipy.yml"
+    ),
+    custom_templates_path: str | None = typer.Option(
+        None, "--templates", "-t", help="Path to custom templates folder."
+    ),
+) -> None:
+    repository = YamlConfigRepository()
+    config = repository.read(path=Path(config_file))
+
+    current_working_directory = Path.cwd()
+    console = SystemConsole(working_directory=str(current_working_directory / config.project_folder_name))
+    project_initializer = ProjectInitializer(
+        renderer=JinjaProjectRenderer(env=JinjaEnvironment(user_template_path=custom_templates_path)),
+        writer=FileSystemProjectWriter(),
+        env_manager=EnvManagerFactory.create(dependency_manager=config.dependency_manager, console=console),
+        version_control_configurer=GitConfigurer(console=console),
+        formatter=RuffProjectFormatter(console=console),
+    )
+
+    project_initializer.execute(
+        config=config,
+        destination_project_folder=current_working_directory / config.project_folder_name,
+    )
+    repository.move(config=config, base_directory=current_working_directory)
+
+
+if __name__ == "__main__":
+    app()

instant_python/initialize/domain/env_manager.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from instant_python.shared.domain.dependency_config import DependencyConfig
+
+
+class EnvManager(ABC):
+    @abstractmethod
+    def setup(self, python_version: str, dependencies: list[DependencyConfig]) -> None:
+        raise NotImplementedError