instant-python 0.20.0__py3-none-any.whl

instant_python/initialize/domain/node.py

@@ -0,0 +1,73 @@
+from collections.abc import Iterator
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from instant_python.initialize.domain.project_writer import NodeWriter
+
+
+from abc import ABC, abstractmethod
+
+
+class Node(ABC):
+    @abstractmethod
+    def create(self, writer: "NodeWriter", destination: Path) -> None:
+        raise NotImplementedError
+
+
+class File(Node):
+    def __init__(self, name: str, extension: str, content: str | None = None) -> None:
+        self._name = name
+        self._extension = extension
+        self._content = content
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self._name}, extension={self._extension})"
+
+    def create(self, writer: "NodeWriter", destination: Path) -> None:
+        file_path = self._build_path_for(destination)
+        writer.create_file(file_path, self._content)
+
+    def is_empty(self) -> bool:
+        return self._content is None or self._content == ""
+
+    def is_pyproject_toml(self) -> bool:
+        return self._name == "pyproject" and self._extension == ".toml"
+
+    def _build_path_for(self, path: Path) -> Path:
+        return path / f"{self._name}{self._extension}"
+
+
+class Directory(Node):
+    _INIT_FILE_NAME = "__init__.py"
+
+    def __init__(self, name: str, is_python_module: bool, children: list[Node]) -> None:
+        self._name = name
+        self._is_python_module = is_python_module
+        self._children = children
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self._name}, is_python_module={self._is_python_module})"
+
+    def __iter__(self) -> Iterator["Node"]:
+        return iter(self._children)
+
+    def create(self, writer: "NodeWriter", destination: Path) -> None:
+        directory_path = self._build_path_for(destination)
+        writer.create_directory(directory_path)
+
+        if self._is_python_module:
+            init_file_path = directory_path / self._INIT_FILE_NAME
+            writer.create_file(init_file_path)
+
+        for child in self._children:
+            child.create(writer, directory_path)
+
+    def _build_path_for(self, path: Path) -> Path:
+        return path / self._name
+
+
+class NodeType(str, Enum):
+    DIRECTORY = "directory"
+    FILE = "file"

instant_python/initialize/domain/project_formatter.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class ProjectFormatter(ABC):
+    @abstractmethod
+    def format(self) -> None:
+        raise NotImplementedError

instant_python/initialize/domain/project_renderer.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod, ABC
+
+from instant_python.shared.domain.config_schema import ConfigSchema
+from instant_python.initialize.domain.project_structure import ProjectStructure
+
+
+class ProjectRenderer(ABC):
+    @abstractmethod
+    def render(self, context_config: ConfigSchema) -> ProjectStructure:
+        raise NotImplementedError

instant_python/initialize/domain/project_structure.py

@@ -0,0 +1,77 @@
+from collections.abc import Iterator
+
+from instant_python.initialize.domain.node import Node, NodeType, Directory, File
+from instant_python.shared.application_error import ApplicationError
+
+
+class ProjectStructure:
+    def __init__(self, nodes: list[Node]) -> None:
+        self._nodes = nodes
+
+    @classmethod
+    def from_raw_structure(cls, structure: list[dict]) -> "ProjectStructure":
+        nodes = cls._build_project_structure(structure)
+        cls._ensure_pyproject_file_is_present(nodes)
+        return cls(nodes=nodes)
+
+    def flatten(self) -> Iterator[Node]:
+        for node in self._nodes:
+            yield node
+            if isinstance(node, Directory):
+                yield from self._flatten_directory(node)
+
+    @classmethod
+    def _build_project_structure(cls, nodes: list[dict]) -> list[Node]:
+        return [cls._build_node(node) for node in nodes]
+
+    @classmethod
+    def _build_node(cls, node: dict) -> Node:
+        node_type = node["type"]
+        name = node["name"]
+
+        if node_type == NodeType.DIRECTORY:
+            children = node.get("children", [])
+            is_python_module = node.get("python", False)
+            directory_children = [cls._build_node(child) for child in children]
+            return Directory(name=name, is_python_module=is_python_module, children=directory_children)
+        elif node_type == NodeType.FILE:
+            extension = node.get("extension", "")
+            content = node.get("content", None)
+            return File(name=name, extension=extension, content=content)
+        else:
+            raise UnknownNodeTypeError(node_type)
+
+    @classmethod
+    def _ensure_pyproject_file_is_present(cls, nodes: list[Node]) -> None:
+        for node in nodes:
+            if isinstance(node, File) and node.is_pyproject_toml():
+                return
+        raise MissingPyprojectTomlError()
+
+    def __iter__(self) -> Iterator[Node]:
+        return iter(self._nodes)
+
+    def __len__(self) -> int:
+        return len(self._nodes)
+
+    def _flatten_directory(self, directory: Directory) -> Iterator[Node]:
+        for child in directory:
+            yield child
+            if isinstance(child, Directory):
+                yield from self._flatten_directory(child)
+
+
+class UnknownNodeTypeError(ApplicationError):
+    def __init__(self, node_type: str) -> None:
+        super().__init__(message=f"Unknown node type: {node_type}")
+
+
+class MissingPyprojectTomlError(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__(
+            message="Missing pyproject.toml file in project structure. Add the following "
+            "to your project structure definition:\n"
+            "- name: pyproject\n"
+            "  type: file\n"
+            "  extension: .toml"
+        )

instant_python/initialize/domain/project_writer.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from instant_python.initialize.domain.project_structure import ProjectStructure
+
+
+class ProjectWriter(ABC):
+    @abstractmethod
+    def write(self, project_structure: ProjectStructure, destination: Path) -> None:
+        raise NotImplementedError
+
+
+class NodeWriter(ABC):
+    @abstractmethod
+    def create_directory(self, path: Path) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_file(self, path: Path, content: str | None = None) -> None:
+        raise NotImplementedError

instant_python/initialize/domain/version_control_configurer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from instant_python.shared.domain.git_config import GitConfig
+
+
+class VersionControlConfigurer(ABC):
+    @abstractmethod
+    def setup(self, config: GitConfig) -> None:
+        raise NotImplementedError

instant_python/initialize/infra/env_manager/env_manager_factory.py

@@ -0,0 +1,27 @@
+from instant_python.initialize.domain.env_manager import EnvManager
+from instant_python.initialize.infra.env_manager.pdm_env_manager import PdmEnvManager
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+from instant_python.initialize.infra.env_manager.uv_env_manager import UvEnvManager
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.supported_managers import SupportedManagers
+
+
+class EnvManagerFactory:
+    @staticmethod
+    def create(dependency_manager: str, console: SystemConsole) -> EnvManager:
+        managers = {
+            SupportedManagers.UV: UvEnvManager,
+            SupportedManagers.PDM: PdmEnvManager,
+        }
+        try:
+            return managers[SupportedManagers(dependency_manager)](console=console)
+        except KeyError:
+            raise UnknownDependencyManagerError(dependency_manager)
+
+
+class UnknownDependencyManagerError(ApplicationError):
+    def __init__(self, manager: str) -> None:
+        supported_managers = ".".join(SupportedManagers.get_supported_managers())
+        super().__init__(
+            message=f"Unknown env manager: {manager}. Please use some of the supported managers: '{supported_managers}'."
+        )

instant_python/initialize/infra/env_manager/pdm_env_manager.py

@@ -0,0 +1,66 @@
+import sys
+from pathlib import Path
+
+from instant_python.shared.domain.dependency_config import DependencyConfig
+from instant_python.initialize.domain.env_manager import EnvManager
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+
+
+class PdmEnvManager(EnvManager):
+    def __init__(self, console: SystemConsole | None = None) -> None:
+        self._console = console
+        self._system_os = sys.platform
+        self._pdm = self._set_pdm_executable_based_on_os()
+
+    def setup(self, python_version: str, dependencies: list[DependencyConfig]) -> None:
+        if self._pdm_is_not_installed():
+            self._install()
+        self._install_python(python_version)
+        self._install_dependencies(dependencies)
+
+    def _pdm_is_not_installed(self) -> bool:
+        result = self._console.execute(f"{self._pdm} --version")
+        return not result.success()
+
+    def _install(self) -> None:
+        print(">>> Installing pdm...")
+        self._console.execute_or_raise(self._get_installation_command_based_on_os())
+        print(">>> pdm installed successfully")
+
+    def _set_pdm_executable_based_on_os(self):
+        return (
+            f"{str(Path.home() / 'AppData' / 'Roaming' / 'Python' / 'Scripts' / 'pdm.exe')}"
+            if self._system_os.startswith("win")
+            else "~/.local/bin/pdm"
+        )
+
+    def _get_installation_command_based_on_os(self) -> str:
+        if self._system_os.startswith("win"):
+            return 'powershell -ExecutionPolicy ByPass -c "irm https://pdm-project.org/install-pdm.py | py -"'
+        return "curl -sSL https://pdm-project.org/install-pdm.py | python3 -"
+
+    def _install_python(self, version: str) -> None:
+        print(f">>> Installing Python {version}...")
+        self._console.execute_or_raise(f"{self._pdm} python install {version}")
+        print(f">>> Python {version} installed successfully")
+
+    def _install_dependencies(self, dependencies: list[DependencyConfig]) -> None:
+        self._create_virtual_environment()
+        print(">>> Installing dependencies...")
+        for dependency in dependencies:
+            self._install_dependency(dependency)
+        print(">>> Dependencies installed successfully")
+
+    def _install_dependency(self, dependency: DependencyConfig) -> None:
+        command = self._build_dependency_install_command(dependency)
+        self._console.execute_or_raise(command)
+
+    def _build_dependency_install_command(self, dependency: DependencyConfig) -> str:
+        command = [f"{self._pdm} add"]
+        command.extend(dependency.get_installation_flag())
+        command.append(dependency.get_specification())
+
+        return " ".join(command)
+
+    def _create_virtual_environment(self) -> None:
+        self._console.execute_or_raise(f"{self._pdm} install")

instant_python/initialize/infra/env_manager/system_console.py

@@ -0,0 +1,65 @@
+import subprocess
+from dataclasses import dataclass
+
+from instant_python.shared.application_error import ApplicationError
+
+
+@dataclass(frozen=True)
+class CommandExecutionResult:
+    exit_code: int
+    stdout: str
+    stderr: str
+
+    def success(self) -> bool:
+        return self.exit_code == 0
+
+
+class SystemConsole:
+    def __init__(self, working_directory: str) -> None:
+        self._working_directory = working_directory
+
+    def execute(self, command: str) -> CommandExecutionResult:
+        try:
+            return self._run_command(command)
+        except Exception as error:
+            return self._unexpected_error_result(error)
+
+    def execute_or_raise(self, command: str) -> CommandExecutionResult:
+        result = self.execute(command)
+        if not result.success():
+            raise CommandExecutionError(
+                exit_code=result.exit_code,
+                stderr_output=result.stderr,
+            )
+        return result
+
+    def _run_command(self, command: str) -> CommandExecutionResult:
+        result = subprocess.run(
+            command,
+            shell=True,
+            check=False,
+            cwd=self._working_directory,
+            capture_output=True,
+            text=True,
+        )
+        return CommandExecutionResult(
+            exit_code=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr,
+        )
+
+    @staticmethod
+    def _unexpected_error_result(error: Exception) -> CommandExecutionResult:
+        return CommandExecutionResult(
+            exit_code=-1,
+            stdout="",
+            stderr=str(error),
+        )
+
+
+class CommandExecutionError(ApplicationError):
+    def __init__(self, exit_code: int, stderr_output: str = None) -> None:
+        message = f"Unexpected error when executing a command, exit code {exit_code}"
+        if stderr_output:
+            message += f": {stderr_output}"
+        super().__init__(message=message)

instant_python/initialize/infra/env_manager/uv_env_manager.py

@@ -0,0 +1,74 @@
+import sys
+from pathlib import Path
+
+from instant_python.shared.domain.dependency_config import DependencyConfig
+from instant_python.initialize.domain.env_manager import EnvManager
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+
+
+class UvEnvManager(EnvManager):
+    def __init__(self, console: SystemConsole | None = None) -> None:
+        self._console = console
+        self._system_os = sys.platform
+        self._uv = self._set_uv_executable_based_on_os()
+
+    def setup(self, python_version: str, dependencies: list[DependencyConfig]) -> None:
+        if self._uv_is_not_installed():
+            self._install()
+        self._install_python(python_version)
+        self._install_dependencies(dependencies)
+
+    def _install(self) -> None:
+        print(">>> Installing uv...")
+        self._console.execute_or_raise(self._get_installation_command_based_on_os())
+        print(">>> uv installed successfully")
+        if self._system_os.startswith("win"):
+            print(
+                ">>> Remember to add uv to your PATH environment variable. You can do this:\n"
+                "    1. Running the following command if you use cmd:\n"
+                "       set Path=%Path%;%USERPROFILE%\\.local\\bin\n"
+                "    2. Running the following command if you use PowerShell:\n"
+                "       $env:Path = '$env:USERPROFILE\\.local\\bin;$env:Path'\n"
+                "    3. Restarting your shell."
+            )
+
+    def _get_installation_command_based_on_os(self) -> str:
+        if self._system_os.startswith("win"):
+            return 'powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"'
+        return "curl -LsSf https://astral.sh/uv/install.sh | sh"
+
+    def _set_uv_executable_based_on_os(self):
+        return (
+            f"{str(Path.home() / '.local' / 'bin' / 'uv.exe')}"
+            if self._system_os.startswith("win")
+            else "~/.local/bin/uv"
+        )
+
+    def _install_python(self, version: str) -> None:
+        print(f">>> Installing Python {version}...")
+        self._console.execute_or_raise(f"{self._uv} python install {version}")
+        print(f">>> Python {version} installed successfully")
+
+    def _install_dependencies(self, dependencies: list[DependencyConfig]) -> None:
+        self._create_virtual_environment()
+        print(">>> Installing dependencies...")
+        for dependency in dependencies:
+            self._install_dependency(dependency)
+        print(">>> Dependencies installed successfully")
+
+    def _install_dependency(self, dependency: DependencyConfig) -> None:
+        command = self._build_dependency_install_command(dependency)
+        self._console.execute_or_raise(command)
+
+    def _build_dependency_install_command(self, dependency: DependencyConfig) -> str:
+        command = [f"{self._uv} add"]
+        command.extend(dependency.get_installation_flag())
+        command.append(dependency.get_specification())
+        return " ".join(command)
+
+    def _create_virtual_environment(self) -> None:
+        self._console.execute_or_raise(f"{self._uv} sync --all-groups")
+
+    def _uv_is_not_installed(self) -> bool:
+        result = self._console.execute(f"{self._uv} --version")
+        return not result.success()

instant_python/initialize/infra/formatter/ruff_project_formatter.py

@@ -0,0 +1,10 @@
+from instant_python.initialize.domain.project_formatter import ProjectFormatter
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+
+
+class RuffProjectFormatter(ProjectFormatter):
+    def __init__(self, console: SystemConsole) -> None:
+        self._console = console
+
+    def format(self) -> None:
+        self._console.execute_or_raise(command="uvx ruff format")

instant_python/initialize/infra/renderer/jinja_environment.py

@@ -0,0 +1,71 @@
+from collections.abc import Callable
+from typing import Any
+
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.supported_templates import SupportedTemplates
+from jinja2 import Environment, FileSystemLoader, ChoiceLoader, PackageLoader
+
+
+class JinjaEnvironment:
+    _EMPTY_CONTEXT = {}
+    _BASE_PACKAGE_NAME = "instant_python"
+    _PROJECT_STRUCTURE_TEMPLATE_PATH = "templates/project_structure"
+    _BOILERPLATE_TEMPLATE_PATH = "templates/boilerplate"
+
+    def __init__(self, user_template_path: str | None = None) -> None:
+        self._env = Environment(
+            loader=ChoiceLoader(
+                [
+                    FileSystemLoader(user_template_path if user_template_path else []),
+                    PackageLoader(
+                        package_name=self._BASE_PACKAGE_NAME, package_path=self._PROJECT_STRUCTURE_TEMPLATE_PATH
+                    ),
+                    PackageLoader(package_name=self._BASE_PACKAGE_NAME, package_path=self._BOILERPLATE_TEMPLATE_PATH),
+                ]
+            ),
+            trim_blocks=True,
+            lstrip_blocks=True,
+            autoescape=True,
+        )
+        self.add_filter("is_in", _is_in)
+        self.add_filter("compute_base_path", _compute_base_path)
+        self.add_filter("has_dependency", _has_dependency)
+        self.add_filter("resolve_import_path", _resolve_import_path)
+
+    def render_template(self, name: str, context: dict[str, Any] | None = None) -> str:
+        template = self._env.get_template(name)
+        return template.render(**(context or self._EMPTY_CONTEXT))
+
+    def add_filter(self, name: str, filter_: Callable) -> None:
+        self._env.filters[name] = filter_
+
+
+class UnknownTemplateError(ApplicationError):
+    def __init__(self, template_name: str) -> None:
+        super().__init__(message=f"Unknown template type: {template_name}")
+
+
+def _is_in(values: list[str], container: list) -> bool:
+    return any(value in container for value in values)
+
+
+def _has_dependency(dependencies: list[dict], dependency_name: str) -> bool:
+    return any(dep.get("name") == dependency_name for dep in dependencies)
+
+
+def _compute_base_path(initial_path: str, template_type: str) -> str:
+    if template_type == SupportedTemplates.DDD:
+        return initial_path
+
+    path_components = initial_path.split(".")
+    if template_type == SupportedTemplates.CLEAN:
+        return ".".join(path_components[1:])
+    elif template_type == SupportedTemplates.STANDARD:
+        return ".".join(path_components[2:])
+    else:
+        raise UnknownTemplateError(template_type)
+
+
+def _resolve_import_path(initial_path: str, template_type: str) -> str:
+    base_path = _compute_base_path(initial_path, template_type)
+    return f".{base_path}" if base_path else ""

instant_python/initialize/infra/renderer/jinja_project_renderer.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import yaml
+from jinja2 import TemplateNotFound
+
+from instant_python.shared.domain.config_schema import ConfigSchema
+from instant_python.initialize.domain.node import NodeType
+from instant_python.initialize.domain.project_renderer import ProjectRenderer
+from instant_python.initialize.domain.project_structure import ProjectStructure
+from instant_python.initialize.infra.renderer.jinja_environment import JinjaEnvironment
+from instant_python.shared.supported_templates import SupportedTemplates
+
+
+class JinjaProjectRenderer(ProjectRenderer):
+    _MAIN_STRUCTURE_TEMPLATE_FILE = "main_structure.yml"
+
+    def __init__(self, env: JinjaEnvironment) -> None:
+        self._env = env
+
+    def render(self, context_config: ConfigSchema) -> ProjectStructure:
+        template_name = self._get_project_main_structure_template(context_config)
+        basic_project_structure = self._render_project_structure_with_jinja(context_config, template_name)
+        project_structure_with_files_content = self._add_template_content_to_files(
+            context_config, basic_project_structure
+        )
+        return ProjectStructure.from_raw_structure(structure=project_structure_with_files_content)
+
+    def _render_project_structure_with_jinja(self, context_config: ConfigSchema, template_name: str) -> list[dict]:
+        raw_project_structure = self._env.render_template(name=template_name, context=context_config.to_primitives())
+        return yaml.safe_load(raw_project_structure)
+
+    def _get_project_main_structure_template(self, config: ConfigSchema) -> str:
+        return str(Path(config.calculate_project_structure_template_name()) / self._MAIN_STRUCTURE_TEMPLATE_FILE)
+
+    def _add_template_content_to_files(self, context_config: ConfigSchema, project_structure: list[dict]) -> list[dict]:
+        for node in project_structure:
+            self._populate_file_content(context_config, node)
+        return project_structure
+
+    def _populate_file_content(self, context_config: ConfigSchema, node: dict) -> None:
+        if node.get("type") == NodeType.FILE:
+            try:
+                template_name = node.get("template") or f"{node['name']}{node['extension']}"
+                file_content = self._env.render_template(
+                    name=template_name,
+                    context={
+                        **context_config.to_primitives(),
+                        "template_types": SupportedTemplates,
+                    },
+                )
+            except (TemplateNotFound, KeyError):
+                print(f"Warning: Template not found for file {node.get('name')}, leaving content empty.")
+                file_content = None
+            node["content"] = file_content
+
+        for child in node.get("children", []):
+            self._populate_file_content(context_config, child)

instant_python/initialize/infra/version_control/git_configurer.py

@@ -0,0 +1,29 @@
+from instant_python.shared.domain.git_config import GitConfig
+from instant_python.initialize.domain.version_control_configurer import VersionControlConfigurer
+from instant_python.initialize.infra.env_manager.system_console import SystemConsole
+
+
+class GitConfigurer(VersionControlConfigurer):
+    def __init__(self, console: SystemConsole) -> None:
+        self._console = console
+
+    def setup(self, config: GitConfig) -> None:
+        print(">>> Setting up git repository...")
+        self._initialize_repository()
+        self._set_user_information(
+            username=config.username,
+            email=config.email,
+        )
+        self._make_initial_commit()
+        print(">>> Git repository created successfully")
+
+    def _initialize_repository(self) -> None:
+        self._console.execute_or_raise(command="git init")
+
+    def _set_user_information(self, username: str, email: str) -> None:
+        self._console.execute(command=f"git config user.name {username}")
+        self._console.execute(command=f"git config user.email {email}")
+
+    def _make_initial_commit(self) -> None:
+        self._console.execute(command="git add .")
+        self._console.execute(command='git commit -m "🎉 chore: initial commit"')

instant_python/initialize/infra/writer/file_system_project_writer.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from instant_python.initialize.domain.project_structure import ProjectStructure
+from instant_python.initialize.domain.project_writer import ProjectWriter, NodeWriter
+
+
+class FileSystemNodeWriter(NodeWriter):
+    def create_directory(self, path: Path) -> None:
+        path.mkdir(parents=True, exist_ok=True)
+
+    def create_file(self, path: Path, content: str | None = None) -> None:
+        path.touch(exist_ok=True)
+        if content is not None:
+            path.write_text(content)
+
+
+class FileSystemProjectWriter(ProjectWriter):
+    def __init__(self) -> None:
+        self._node_writer = FileSystemNodeWriter()
+
+    def write(self, project_structure: ProjectStructure, destination: Path) -> None:
+        for node in project_structure:
+            node.create(writer=self._node_writer, destination=destination)

instant_python/shared/application_error.py

@@ -0,0 +1,8 @@
+class ApplicationError(Exception):
+    def __init__(self, message: str) -> None:
+        self._message = message
+        super().__init__(self._message)
+
+    @property
+    def message(self) -> str:
+        return self._message