instant-python 0.0.1__py3-none-any.whl

instant_python/cli.py

@@ -0,0 +1,11 @@
+import typer
+
+from instant_python import folder_cli, project_cli
+
+app = typer.Typer()
+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")
+
+
+if __name__ == "__main__":
+    app()

instant_python/folder_cli.py

@@ -0,0 +1,50 @@
+import typer
+
+from instant_python.project_generator.custom_template_manager import CustomTemplateManager
+from instant_python.project_generator.default_template_manager import DefaultTemplateManager
+from instant_python.project_generator.folder_tree import FolderTree
+from instant_python.project_generator.project_generator import ProjectGenerator
+from instant_python.question_prompter.question.free_text_question import FreeTextQuestion
+from instant_python.question_prompter.question_wizard import QuestionWizard
+from instant_python.question_prompter.step.general_project_step import GeneralProjectStep
+from instant_python.question_prompter.step.steps import Steps
+from instant_python.question_prompter.step.template_step import TemplateStep
+
+app = typer.Typer()
+
+
+@app.command("template", help="Pass a custom template folder structure", hidden=True)
+def create_folder_structure_from_template(template_name: str) -> None:
+	project_name = FreeTextQuestion(
+		key="project_slug",
+		message="Enter the name of the project (CANNOT CONTAIN SPACES)",
+		default="python-project",
+	).ask()
+	project_generator = ProjectGenerator(
+		folder_tree=FolderTree(project_name["project_slug"]),
+		template_manager=CustomTemplateManager(template_name),
+	)
+
+	project_generator.generate()
+
+
+@app.command("new", help="Use default built-in project structure templates")
+def create_default_project_structure() -> None:
+	wizard = QuestionWizard(
+		steps=Steps(GeneralProjectStep(), TemplateStep())
+	)
+	user_requirements = wizard.run()
+	user_requirements.save_in_memory()
+
+	project_generator = ProjectGenerator(
+		folder_tree=FolderTree(user_requirements.project_slug),
+		template_manager=DefaultTemplateManager(),
+	)
+
+	project_generator.generate()
+
+	user_requirements.remove()
+
+
+if __name__ == "__main__":
+	app()

instant_python/installer/dependency_manager.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+
+class DependencyManager(ABC):
+    @abstractmethod
+    def install(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def install_python(self, version: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def install_dependencies(self, dependencies: list[str]) -> None:
+        raise NotImplementedError

instant_python/installer/dependency_manager_factory.py

@@ -0,0 +1,14 @@
+from instant_python.installer.dependency_manager import DependencyManager
+from instant_python.installer.managers import Managers
+from instant_python.installer.pdm_manager import PdmManager
+from instant_python.installer.uv_manager import UvManager
+
+
+class DependencyManagerFactory:
+    @staticmethod
+    def create(user_manager: str, project_path: str) -> DependencyManager:
+        managers = {
+            Managers.UV: UvManager,
+            Managers.PDM: PdmManager,
+        }
+        return managers[Managers(user_manager)](project_path)

instant_python/installer/git_configurer.py

@@ -0,0 +1,47 @@
+import subprocess
+
+
+class GitConfigurer:
+    def __init__(self, project_directory: str) -> None:
+        self._project_directory = project_directory
+
+    def configure(self, email: str, username: str) -> None:
+        self._initialize_repository()
+
+        if email and username:
+            self._set_user_information(email, username)
+
+        self._initial_commit()
+
+    def _initialize_repository(self) -> None:
+        print(">>> Initializing git repository...")
+        subprocess.run(
+            "git init",
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+        print(">>> Git repository initialized successfully")
+
+    def _set_user_information(self, email: str | None, username: str | None) -> None:
+        print(">>> Configuring git user and email...")
+        subprocess.run(
+            f"git config user.name {username} && git config user.email {email}",
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+        print(">>> Git user and email configured successfully")
+
+    def _initial_commit(self) -> None:
+        print(">>> Making initial commit...")
+        subprocess.run(
+	        "git add . && git commit -m '🎉 chore: initial commit'",
+	        shell=True,
+	        check=True,
+	        cwd=self._project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+        print(">>> Initial commit made successfully")

instant_python/installer/installer.py

@@ -0,0 +1,18 @@
+from instant_python.installer.dependency_manager import DependencyManager
+
+
+class Installer:
+    _dependency_manager: DependencyManager
+
+    def __init__(
+        self,
+        dependency_manager: DependencyManager,
+    ) -> None:
+        self._dependency_manager = dependency_manager
+
+    def perform_installation(
+        self, python_version: str, dependencies: list[str]
+    ) -> None:
+        self._dependency_manager.install()
+        self._dependency_manager.install_python(python_version)
+        self._dependency_manager.install_dependencies(dependencies)

instant_python/installer/managers.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class Managers(StrEnum):
+    PYENV = "pyenv"
+    UV = "uv"
+    PDM = "pdm"

instant_python/installer/operating_systems.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class OperatingSystems(StrEnum):
+    WINDOWS = "windows"
+    MACOS = "macos"
+    LINUX = "linux"

instant_python/installer/pdm_manager.py

@@ -0,0 +1,72 @@
+import subprocess
+
+from instant_python.installer.dependency_manager import DependencyManager
+from instant_python.question_prompter.question.boolean_question import BooleanQuestion
+from instant_python.question_prompter.question.free_text_question import FreeTextQuestion
+
+
+class PdmManager(DependencyManager):
+    def __init__(self, project_directory: str) -> None:
+        self._project_directory = project_directory
+        self._pdm = "~/.local/bin/pdm"
+
+    def install(self) -> None:
+        print(">>> Installing pdm...")
+        subprocess.run(
+            "curl -sSL https://pdm-project.org/install-pdm.py | python3 -",
+            shell=True,
+            check=True,
+        )
+        print(">>> pdm installed successfully")
+
+    def install_python(self, version: str) -> None:
+        command = f"{self._pdm} python install {version}"
+        print(f">>> Installing Python {version}...")
+        subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+        )
+        print(f">>> Python {version} installed successfully")
+
+    def install_dependencies(self, dependencies: list[str]) -> None:
+        for dependency_name in dependencies:
+            self._install_dependency(dependency_name)
+
+    def _install_dependency(self, dependency_name: str) -> None:
+        is_dev = BooleanQuestion(
+            key="is_dev",
+            message=f"Do you want to install {dependency_name} as a dev dependency?",
+            default=False,
+        ).ask()["is_dev"]
+        add_to_group = BooleanQuestion(
+            key="add_to_group",
+            message=f"Do you want to install the {dependency_name} inside a group?",
+            default=False,
+        ).ask()["add_to_group"]
+
+        flag = self._generate_flag(add_to_group, is_dev)
+
+        command = f"{self._pdm} add {flag} {dependency_name}"
+        subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+        )
+
+    @staticmethod
+    def _generate_flag(add_to_group: bool, is_dev: bool) -> str:
+        dev_flag = "--dev" if is_dev else ""
+        group_flag = ""
+        if add_to_group:
+            group_name = FreeTextQuestion(
+                key="group_name", message="Enter the name of the group"
+            ).ask()["group_name"]
+            group_flag += f"--group {group_name}"
+        return f"{dev_flag} {group_flag}"
+
+
+
+

instant_python/installer/uv_manager.py

@@ -0,0 +1,73 @@
+import subprocess
+
+from instant_python.installer.dependency_manager import DependencyManager
+from instant_python.question_prompter.question.boolean_question import BooleanQuestion
+from instant_python.question_prompter.question.free_text_question import FreeTextQuestion
+
+
+class UvManager(DependencyManager):
+    def __init__(self, project_directory: str) -> None:
+        self._project_directory = project_directory
+        self._uv = "~/.local/bin/uv"
+
+    def install(self) -> None:
+        print(">>> Installing uv...")
+        subprocess.run(
+            "curl -LsSf https://astral.sh/uv/install.sh | sh",
+            shell=True,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+        print(">>> uv installed successfully")
+
+    def install_python(self, version: str) -> None:
+        command = f"{self._uv} python install {version}"
+        print(f">>> Installing Python {version}...")
+        subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+        print(f">>> Python {version} installed successfully")
+
+    def install_dependencies(self, dependencies: list[str]) -> None:
+        for dependency_name in dependencies:
+            self._install_dependency(dependency_name)
+
+    def _install_dependency(self, dependency_name: str) -> None:
+        is_dev = BooleanQuestion(
+            key="is_dev",
+            message=f"Do you want to install {dependency_name} as a dev dependency?",
+            default=False,
+        ).ask()["is_dev"]
+        add_to_group = BooleanQuestion(
+            key="add_to_group",
+            message=f"Do you want to install the {dependency_name} inside a group?",
+            default=False,
+        ).ask()["add_to_group"]
+
+        flag = self._generate_flag(add_to_group, is_dev)
+
+        command = f"{self._uv} add {flag} {dependency_name}"
+        subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            cwd=self._project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+        print(f">>> {dependency_name} installed successfully")
+
+    @staticmethod
+    def _generate_flag(add_to_group: bool, is_dev: bool) -> str:
+        flag = ""
+        if is_dev:
+            flag = "--dev"
+        if add_to_group:
+            group_name = FreeTextQuestion(
+                key="group_name", message="Enter the name of the group"
+            ).ask()["group_name"]
+            flag = f"--group {group_name}"
+        return flag

instant_python/project_cli.py

@@ -0,0 +1,100 @@
+import typer
+
+from instant_python.installer.dependency_manager_factory import DependencyManagerFactory
+from instant_python.installer.git_configurer import GitConfigurer
+from instant_python.installer.installer import Installer
+from instant_python.project_generator.custom_template_manager import CustomTemplateManager
+from instant_python.project_generator.default_template_manager import (
+    DefaultTemplateManager,
+)
+from instant_python.project_generator.folder_tree import FolderTree
+from instant_python.project_generator.project_generator import ProjectGenerator
+from instant_python.question_prompter.question_wizard import QuestionWizard
+from instant_python.question_prompter.step.dependencies_step import DependenciesStep
+from instant_python.question_prompter.step.general_custom_template_project_step import GeneralCustomTemplateProjectStep
+from instant_python.question_prompter.step.general_project_step import (
+    GeneralProjectStep,
+)
+from instant_python.question_prompter.step.git_step import GitStep
+from instant_python.question_prompter.step.steps import Steps
+from instant_python.question_prompter.step.template_step import TemplateStep
+
+app = typer.Typer()
+
+
+@app.command("template", help="Pass a custom template folder structure", hidden=True)
+def create_folder_structure_from_template(template_name: str) -> None:
+    wizard = QuestionWizard(steps=Steps(
+        GeneralCustomTemplateProjectStep(),
+        GitStep(),
+        DependenciesStep(),
+    ))
+    user_requirements = wizard.run()
+    user_requirements.save_in_memory()
+
+    project_generator = ProjectGenerator(
+        folder_tree=FolderTree(user_requirements.project_slug),
+        template_manager=CustomTemplateManager(template_name),
+    )
+    project_generator.generate()
+
+    installer = Installer(
+        dependency_manager=DependencyManagerFactory.create(
+            user_requirements.dependency_manager, project_generator.path
+        )
+    )
+    installer.perform_installation(
+        user_requirements.python_version, user_requirements.dependencies
+    )
+
+    if user_requirements.git:
+        git_configurer = GitConfigurer(project_generator.path)
+        git_configurer.configure(
+            user_requirements.git_email, user_requirements.git_user_name
+        )
+
+    user_requirements.remove()
+
+
+@app.command(
+    "new",
+    help="Use default built-in template to create a new project",
+)
+def create_full_project() -> None:
+    wizard = QuestionWizard(
+        steps=Steps(
+            GeneralProjectStep(),
+            GitStep(),
+            TemplateStep(),
+            DependenciesStep(),
+        )
+    )
+    user_requirements = wizard.run()
+    user_requirements.save_in_memory()
+
+    project_generator = ProjectGenerator(
+        folder_tree=FolderTree(user_requirements.project_slug),
+        template_manager=DefaultTemplateManager(),
+    )
+    project_generator.generate()
+
+    installer = Installer(
+        dependency_manager=DependencyManagerFactory.create(
+            user_requirements.dependency_manager, project_generator.path
+        )
+    )
+    installer.perform_installation(
+        user_requirements.python_version, user_requirements.dependencies
+    )
+
+    if user_requirements.git:
+        git_configurer = GitConfigurer(project_generator.path)
+        git_configurer.configure(
+            user_requirements.git_email, user_requirements.git_user_name
+        )
+
+    user_requirements.remove()
+
+
+if __name__ == "__main__":
+    app()

instant_python/project_generator/custom_template_manager.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import override
+
+import yaml
+
+from instant_python.project_generator.template_manager import TemplateManager
+
+
+class CustomTemplateManager(TemplateManager):
+    def __init__(self, template_path: str) -> None:
+        self._template_path = Path(template_path).expanduser().resolve()
+
+    @override
+    def get_project(self, template_name: str) -> dict[str, str]:
+        if not self._template_path.is_file():
+            raise FileNotFoundError(
+                f"Could not find YAML file at: {self._template_path}"
+            )
+        with open(self._template_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f)

instant_python/project_generator/default_template_manager.py

@@ -0,0 +1,45 @@
+from typing import override
+
+import yaml
+from jinja2 import Environment, Template, PackageLoader
+
+from instant_python.project_generator.jinja_custom_filters import is_in, compute_base_path
+from instant_python.project_generator.template_manager import TemplateManager
+from instant_python.question_prompter.template_types import TemplateTypes
+from instant_python.question_prompter.user_requirements import UserRequirements
+
+
+class DefaultTemplateManager(TemplateManager):
+
+    def __init__(self) -> None:
+        self._requirements = self._load_memory_requirements()
+        self._env = Environment(loader=PackageLoader("instant_python",
+                                                     "templates"),
+                                trim_blocks=True,
+                                lstrip_blocks=True)
+        self._env.filters["is_in"] = is_in
+        self._env.filters["compute_base_path"] = compute_base_path
+
+    @override
+    def get_project(self, template_name: str) -> dict:
+        template = self._get_template(
+            f"{template_name}/{self._requirements.template}/main_structure.yml.j2"
+        )
+        raw_project_structure = self._render(template)
+        return yaml.safe_load(raw_project_structure)
+
+    def get_boilerplate(self, template_name: str) -> str:
+        template = self._get_template(f"{template_name}")
+        return self._render(template)
+
+    def _get_template(self, name: str) -> Template:
+        return self._env.get_template(name)
+
+    def _render(self, template: Template) -> str:
+        return template.render(**self._requirements.to_dict(), template_types=TemplateTypes)
+
+    @staticmethod
+    def _load_memory_requirements() -> UserRequirements:
+        with open("user_requirements.yml") as file:
+            requirements = yaml.safe_load(file)
+        return UserRequirements(**requirements)

instant_python/project_generator/directory.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+from instant_python.project_generator.node import Node
+
+
+class Directory(Node):
+	_INIT_FILE = "__init__.py"
+
+	def __init__(self, name: str, children: list[Node], python_module: bool) -> None:
+		self._name = name
+		self._python_module = python_module
+		self._children = children
+
+	def __repr__(self) -> str:
+		return (
+			f"{self.__class__.__name__}(name={self._name}, children={self._children})"
+		)
+
+	def create(self, base_path: Path) -> None:
+		directory_path = base_path / self._name
+		directory_path.mkdir(parents=True, exist_ok=True)
+
+		if self._python_module:
+			init_path = directory_path / self._INIT_FILE
+			init_path.touch(exist_ok=True)
+
+		for child in self._children:
+			child.create(base_path=directory_path)

instant_python/project_generator/file.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+from instant_python.project_generator.default_template_manager import DefaultTemplateManager
+from instant_python.project_generator.node import Node
+
+
+class File(Node):
+
+    def __init__(self, name: str, extension: str) -> None:
+        self._file_name = f"{name.split("/")[-1]}{extension}"
+        self._template_path = f"boilerplate/{name}{extension}"
+        self._template_manager = DefaultTemplateManager()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self._file_name})"
+
+    def create(self, base_path: Path) -> None:
+        file_path = base_path / self._file_name
+        content = self._template_manager.get_boilerplate(self._template_path)
+        file_path.write_text(content)

instant_python/project_generator/folder_tree.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+from instant_python.project_generator.directory import Directory
+from instant_python.project_generator.file import File
+from instant_python.project_generator.node import Node, NodeType
+
+
+class UnknownNodeType(ValueError):
+    def __init__(self, node_type: str) -> None:
+        self._message = f"Unknown node type: {node_type}"
+        super().__init__(self._message)
+
+
+class FolderTree:
+    def __init__(self, project_directory: str) -> None:
+        self._project_directory = Path(project_directory)
+
+    def create(self, project_structure: dict) -> None:
+        tree = [self._build_tree(node) for node in project_structure.get("root", [])]
+        for node in tree:
+            node.create(base_path=self._project_directory)
+
+    @property
+    def project_directory(self) -> str:
+        return str(self._project_directory)
+
+    def _build_tree(self, node: dict) -> Node:
+        node_type = node.get("type")
+        name = node.get("name")
+
+        if node_type == NodeType.DIRECTORY:
+            children = node.get("children", [])
+            is_python_module = node.get("python", False)
+            directory_children = [self._build_tree(child) for child in children]
+            return Directory(name=name, children=directory_children, python_module=is_python_module)
+        elif node_type == NodeType.FILE:
+            extension = node.get("extension", "")
+            return File(name=name, extension=extension)
+        else:
+            raise UnknownNodeType(node_type)

instant_python/project_generator/jinja_custom_filters.py

@@ -0,0 +1,18 @@
+from instant_python.question_prompter.template_types import TemplateTypes
+
+
+def is_in(values: list[str], container: list) -> bool:
+    return any(value in container for value in values)
+
+
+def compute_base_path(initial_path: str, template_type: str) -> str:
+    if template_type == TemplateTypes.DDD:
+        return initial_path
+
+    path_components = initial_path.split(".")
+    if template_type == TemplateTypes.CLEAN:
+        return ".".join(path_components[1:])
+    elif template_type == TemplateTypes.STANDARD:
+        return ".".join(path_components[2:])
+    else:
+        raise ValueError(f"Unknown template type: {template_type}")

instant_python/project_generator/node.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from enum import StrEnum
+from pathlib import Path
+
+
+class NodeType(StrEnum):
+    DIRECTORY = "directory"
+    FILE = "file"
+
+
+class Node(ABC):
+    @abstractmethod
+    def create(self, base_path: Path) -> None:
+        raise NotImplementedError

instant_python/project_generator/project_generator.py

@@ -0,0 +1,31 @@
+import subprocess
+
+from instant_python.project_generator.folder_tree import FolderTree
+from instant_python.project_generator.default_template_manager import TemplateManager
+
+
+class ProjectGenerator:
+
+    def __init__(self, folder_tree: FolderTree,
+                 template_manager: TemplateManager) -> None:
+        self._folder_tree = folder_tree
+        self._template_manager = template_manager
+
+    def generate(self) -> None:
+        raw_project_structure = self._template_manager.get_project(
+            template_name="project_structure")
+        self._folder_tree.create(raw_project_structure)
+        self._format_project_files()
+
+    def _format_project_files(self) -> None:
+        subprocess.run(
+            "uvx ruff format",
+            shell=True,
+            check=True,
+            cwd=self._folder_tree.project_directory,
+            stdout=subprocess.DEVNULL,
+        )
+
+    @property
+    def path(self) -> str:
+        return self._folder_tree.project_directory

instant_python/project_generator/template_manager.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class TemplateManager(ABC):
+    @abstractmethod
+    def get_project(self, template_name: str) -> dict:
+        raise NotImplementedError