forgepy-cli 1.0.0__py3-none-any.whl

config/user_config.py

@@ -0,0 +1,238 @@
+"""
+Persistent user-level configuration for ForgePy.
+"""
+
+import json
+import os
+import tempfile
+from collections.abc import Mapping
+from json import JSONDecodeError
+from pathlib import Path
+from types import MappingProxyType
+
+
+CONFIG_DIRECTORY_NAME = ".forgepy"
+CONFIG_FILENAME = "config.json"
+
+DEFAULT_CONFIG: Mapping[str, str] = MappingProxyType(
+    {
+        "default_template": "basic",
+        "default_location": "",
+        "author": "",
+        "license": "MIT",
+    }
+)
+
+SUPPORTED_SETTINGS = frozenset(DEFAULT_CONFIG)
+
+
+class ForgePyConfigError(Exception):
+    """
+    Base error for ForgePy user configuration operations.
+    """
+
+
+class ConfigFormatError(ForgePyConfigError):
+    """
+    Raised when the configuration file is not valid ForgePy JSON data.
+    """
+
+
+class ConfigIOError(ForgePyConfigError):
+    """
+    Raised when the configuration file cannot be read or written.
+    """
+
+
+class UnknownConfigSettingError(ForgePyConfigError):
+    """
+    Raised when a setting is not supported by ForgePy.
+    """
+
+
+class InvalidConfigValueError(ForgePyConfigError):
+    """
+    Raised when a supported setting has an invalid value.
+    """
+
+
+class ConfigStore:
+    """
+    Load and persist ForgePy user configuration as JSON.
+
+    A custom home directory can be provided for tests and isolated callers.
+    """
+
+    def __init__(
+        self,
+        home_directory: Path | None = None,
+    ) -> None:
+        self.home_directory = (
+            Path.home()
+            if home_directory is None
+            else Path(home_directory)
+        )
+        self.config_directory = (
+            self.home_directory
+            / CONFIG_DIRECTORY_NAME
+        )
+        self.config_path = (
+            self.config_directory
+            / CONFIG_FILENAME
+        )
+
+    @staticmethod
+    def defaults() -> dict[str, str]:
+        """
+        Return a new dictionary containing the safe defaults.
+        """
+
+        return dict(DEFAULT_CONFIG)
+
+    def load(self) -> dict[str, str]:
+        """
+        Load configuration or return defaults when no file exists.
+        """
+
+        try:
+            content = self.config_path.read_text(
+                encoding="utf-8",
+            )
+            data = json.loads(content)
+        except FileNotFoundError:
+            return self.defaults()
+        except UnicodeDecodeError as error:
+            raise ConfigFormatError(
+                "ForgePy configuration is not valid UTF-8 at "
+                f"'{self.config_path}'."
+            ) from error
+        except JSONDecodeError as error:
+            raise ConfigFormatError(
+                "ForgePy configuration contains malformed JSON "
+                f"at '{self.config_path}' "
+                f"(line {error.lineno}, column {error.colno})."
+            ) from error
+        except OSError as error:
+            raise ConfigIOError(
+                "ForgePy could not read configuration from "
+                f"'{self.config_path}': {error}"
+            ) from error
+
+        return self._normalize(data)
+
+    def save(
+        self,
+        config: Mapping[str, str],
+    ) -> dict[str, str]:
+        """
+        Validate and save configuration, creating its directory as needed.
+        """
+
+        normalized = self._normalize(config)
+        serialized = json.dumps(
+            normalized,
+            indent=4,
+            ensure_ascii=False,
+        ) + "\n"
+
+        try:
+            self.config_directory.mkdir(
+                parents=True,
+                exist_ok=True,
+            )
+
+            temporary_path: Path | None = None
+
+            try:
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    newline="\n",
+                    dir=self.config_directory,
+                    prefix=f".{CONFIG_FILENAME}.",
+                    suffix=".tmp",
+                    delete=False,
+                ) as temporary_file:
+                    temporary_path = Path(
+                        temporary_file.name,
+                    )
+                    temporary_file.write(serialized)
+                    temporary_file.flush()
+                    os.fsync(temporary_file.fileno())
+
+                temporary_path.replace(
+                    self.config_path,
+                )
+            finally:
+                if (
+                    temporary_path is not None
+                    and temporary_path.exists()
+                ):
+                    temporary_path.unlink()
+        except OSError as error:
+            raise ConfigIOError(
+                "ForgePy could not save configuration to "
+                f"'{self.config_path}': {error}"
+            ) from error
+
+        return normalized.copy()
+
+    def reset(self) -> dict[str, str]:
+        """
+        Explicitly replace persisted configuration with the safe defaults.
+        """
+
+        return self.save(self.defaults())
+
+    def update(
+        self,
+        setting: str,
+        value: str,
+    ) -> dict[str, str]:
+        """
+        Update one supported setting while preserving all other values.
+        """
+
+        self._validate_setting(setting)
+        self._validate_value(setting, value)
+
+        config = self.load()
+        config[setting] = value
+
+        return self.save(config)
+
+    def _normalize(
+        self,
+        data: object,
+    ) -> dict[str, str]:
+        if not isinstance(data, Mapping):
+            raise ConfigFormatError(
+                "ForgePy configuration must contain a JSON object."
+            )
+
+        normalized = self.defaults()
+
+        for setting, value in data.items():
+            self._validate_setting(setting)
+            self._validate_value(setting, value)
+            normalized[setting] = value
+
+        return normalized
+
+    @staticmethod
+    def _validate_setting(setting: object) -> None:
+        if setting not in SUPPORTED_SETTINGS:
+            raise UnknownConfigSettingError(
+                f"Unknown ForgePy configuration setting: '{setting}'."
+            )
+
+    @staticmethod
+    def _validate_value(
+        setting: object,
+        value: object,
+    ) -> None:
+        if not isinstance(value, str):
+            raise InvalidConfigValueError(
+                "ForgePy configuration setting "
+                f"'{setting}' must be a string."
+            )

config/version.py

@@ -0,0 +1,16 @@
+"""
+==================================================
+ForgePy
+Author  : Rendy Zou
+Module  : Version Configuration
+==================================================
+
+Deskripsi:
+- Menyimpan sumber tunggal informasi versi aplikasi.
+"""
+
+APP_NAME = "ForgePy"
+
+VERSION = "1.0.0"
+
+AUTHOR = "Rendy Zou"

core/environment_builder.py

@@ -0,0 +1,33 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+VENV_CREATION_TIMEOUT_SECONDS = 300
+
+
+class EnvironmentBuilder:
+    """
+    Membuat Virtual Environment Python.
+    """
+
+    def create(self, project_path: Path) -> None:
+
+        print("\n[INFO] Membuat Virtual Environment...")
+
+        try:
+            subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "venv",
+                    str(project_path / ".venv")
+                ],
+                check=True,
+                timeout=VENV_CREATION_TIMEOUT_SECONDS,
+            )
+        except subprocess.SubprocessError as error:
+            print(f"[ERROR] Virtual environment creation failed: {error}")
+            raise
+
+        print("[OK] Virtual Environment berhasil dibuat.")

core/git_builder.py

@@ -0,0 +1,90 @@
+"""
+==================================================
+ForgePy
+Author  : Rendy Zou
+Module  : Git Builder
+==================================================
+
+Deskripsi:
+- Menginisialisasi Git Repository.
+- Membuat commit pertama.
+"""
+
+import shutil
+import subprocess
+from pathlib import Path
+
+
+GIT_INIT_TIMEOUT_SECONDS = 60
+GIT_ADD_TIMEOUT_SECONDS = 120
+GIT_COMMIT_TIMEOUT_SECONDS = 60
+
+
+class GitBuilder:
+    """
+    Builder untuk menginisialisasi Git Repository.
+    """
+
+    def create(self, project_root: Path) -> None:
+
+        if shutil.which("git") is None:
+            raise FileNotFoundError(
+                "Git executable is required but was not found."
+            )
+
+        if (project_root / ".git").exists():
+            print("[INFO] Git Repository sudah ada.")
+            return
+
+        print("\n[INFO] Inisialisasi Git Repository...")
+
+        try:
+            subprocess.run(
+                ["git", "init"],
+                cwd=project_root,
+                check=True,
+                timeout=GIT_INIT_TIMEOUT_SECONDS,
+            )
+        except subprocess.SubprocessError as error:
+            print(f"[ERROR] Git initialization failed: {error}")
+            raise
+
+        try:
+            subprocess.run(
+                ["git", "add", "."],
+                cwd=project_root,
+                check=True,
+                timeout=GIT_ADD_TIMEOUT_SECONDS,
+            )
+        except subprocess.SubprocessError as error:
+            print(f"[ERROR] Git staging failed: {error}")
+            raise
+
+        try:
+
+            subprocess.run(
+                [
+                    "git",
+                    "commit",
+                    "-m",
+                    "Initial project created by ForgePy",
+                ],
+                cwd=project_root,
+                check=True,
+                timeout=GIT_COMMIT_TIMEOUT_SECONDS,
+            )
+
+            print("[OK] Initial Commit berhasil dibuat.")
+
+        except subprocess.CalledProcessError:
+
+            print(
+                "[WARNING] Initial Commit gagal.\n"
+                "Pastikan Git user.name dan user.email sudah dikonfigurasi."
+            )
+            raise
+        except subprocess.TimeoutExpired as error:
+            print(f"[ERROR] Initial Git commit timed out: {error}")
+            raise
+
+        print("[OK] Git Repository berhasil dibuat.")

core/project_generator.py

@@ -0,0 +1,125 @@
+import os
+from pathlib import Path
+
+from builders.python_tools_builder import PythonToolsBuilder
+
+from core.environment_builder import EnvironmentBuilder
+from core.git_builder import GitBuilder
+from core.requirements_installer import RequirementsInstaller
+from core.vscode_builder import VSCodeBuilder
+
+from models.project_config import ProjectConfig
+
+from templates.template_engine.template_registry import TemplateRegistry
+
+
+class ProjectPreflightError(ValueError):
+    """An expected project validation failure before root creation."""
+
+
+class UnknownProjectTemplateError(KeyError):
+    """The requested project template is not registered."""
+
+
+class ProjectGenerator:
+
+    def create(
+        self,
+        project_name: str,
+        location: str,
+        template_name: str = "basic",
+    ) -> None:
+
+        try:
+            location_path = Path(location).resolve()
+
+            if not location_path.exists():
+                raise ValueError(
+                    f"Project location does not exist: '{location_path}'."
+                )
+
+            if not location_path.is_dir():
+                raise ValueError(
+                    f"Project location must be a directory: '{location_path}'."
+                )
+
+            config = ProjectConfig(
+                name=project_name,
+                location=location_path,
+            )
+
+            destination = config.root
+
+            if os.path.lexists(destination):
+                raise FileExistsError(
+                    f"Project destination already exists: '{destination}'."
+                )
+
+            resolved_destination = destination.resolve(strict=False)
+
+            if resolved_destination.parent != location_path:
+                raise ValueError(
+                    "Project destination must remain directly below the "
+                    f"selected location: '{resolved_destination}'."
+                )
+
+            registry = TemplateRegistry()
+
+            try:
+                template = registry.get(template_name)
+            except KeyError as error:
+                raise UnknownProjectTemplateError(template_name) from error
+
+            template.preflight(destination)
+        except ValueError as error:
+            raise ProjectPreflightError(str(error)) from error
+
+        destination.mkdir(
+            parents=True,
+            exist_ok=False,
+        )
+
+        # ==========================
+        # Template
+        # ==========================
+
+        template.create(config.root)
+
+        # ==========================
+        # Virtual Environment
+        # ==========================
+
+        EnvironmentBuilder().create(config.root)
+
+        # ==========================
+        # Update Python Tools
+        # ==========================
+
+        PythonToolsBuilder().update(config.root)
+
+        # ==========================
+        # Install Requirements
+        # ==========================
+
+        RequirementsInstaller().install(config.root)
+
+        # ==========================
+        # VSCode
+        # ==========================
+
+        VSCodeBuilder().create(
+            config.root,
+            entry_point=template.vscode_entry_point,
+        )
+
+        # ==========================
+        # Git
+        # ==========================
+
+        GitBuilder().create(config.root)
+
+        print()
+        print("=" * 40)
+        print("Project berhasil dibuat.")
+        print(config.root)
+        print("=" * 40)

core/requirements_installer.py

@@ -0,0 +1,50 @@
+import subprocess
+from pathlib import Path
+
+
+REQUIREMENTS_INSTALL_TIMEOUT_SECONDS = 900
+
+
+class RequirementsInstaller:
+    """
+    Menginstal package dari requirements.txt
+    menggunakan virtual environment yang baru dibuat.
+    """
+
+    def install(self, project_path: Path) -> None:
+
+        requirements = project_path / "requirements.txt"
+
+        if not requirements.exists():
+            print("[WARNING] requirements.txt tidak ditemukan.")
+            return
+
+        # Jika requirements.txt kosong
+        if requirements.read_text(encoding="utf-8").strip() == "":
+            print("[INFO] requirements.txt kosong, tidak ada dependency yang di-install.")
+            return
+
+        pip = project_path / ".venv" / "Scripts" / "pip.exe"
+
+        if not pip.exists():
+            print("[WARNING] Virtual Environment belum tersedia.")
+            return
+
+        print("\n[INFO] Menginstal dependencies...")
+
+        try:
+            subprocess.run(
+                [
+                    str(pip),
+                    "install",
+                    "-r",
+                    str(requirements),
+                ],
+                check=True,
+                timeout=REQUIREMENTS_INSTALL_TIMEOUT_SECONDS,
+            )
+        except subprocess.SubprocessError as error:
+            print(f"[ERROR] Requirements installation failed: {error}")
+            raise
+
+        print("[OK] Dependencies berhasil di-install.")

core/vscode_builder.py

@@ -0,0 +1,103 @@
+"""
+==================================================
+ForgePy
+Author  : Rendy Zou
+Module  : VSCode Builder
+==================================================
+
+Deskripsi:
+- Membuat konfigurasi Visual Studio Code
+- (.vscode/settings.json)
+- (.vscode/launch.json)
+- (.vscode/tasks.json)
+- (.vscode/extensions.json)
+"""
+
+from pathlib import Path
+
+from templates.vscode import (
+    settings_template,
+    launch_template,
+    tasks_template,
+    extensions_template,
+)
+
+
+class VSCodeBuilder:
+    """
+    Builder untuk membuat konfigurasi Visual Studio Code.
+    """
+
+    def create(
+        self,
+        project_root: Path,
+        entry_point: str | None = "app.py",
+    ) -> None:
+
+        vscode_folder = project_root / ".vscode"
+        vscode_folder.mkdir(exist_ok=True)
+
+        self._write_settings(vscode_folder)
+        self._write_launch(
+            vscode_folder,
+            entry_point,
+        )
+        self._write_tasks(
+            vscode_folder,
+            entry_point,
+        )
+        self._write_extensions(vscode_folder)
+
+        print("[OK] VS Code configuration berhasil dibuat.")
+
+    def _write_settings(self, vscode_folder: Path) -> None:
+
+        path = vscode_folder / "settings.json"
+
+        path.write_text(
+            settings_template.build(),
+            encoding="utf-8",
+        )
+
+        print(f"[OK] File dibuat : {path}")
+
+    def _write_launch(
+        self,
+        vscode_folder: Path,
+        entry_point: str | None,
+    ) -> None:
+
+        path = vscode_folder / "launch.json"
+
+        path.write_text(
+            launch_template.build(entry_point),
+            encoding="utf-8",
+        )
+
+        print(f"[OK] File dibuat : {path}")
+
+    def _write_tasks(
+        self,
+        vscode_folder: Path,
+        entry_point: str | None,
+    ) -> None:
+
+        path = vscode_folder / "tasks.json"
+
+        path.write_text(
+            tasks_template.build(entry_point),
+            encoding="utf-8",
+        )
+
+        print(f"[OK] File dibuat : {path}")
+
+    def _write_extensions(self, vscode_folder: Path) -> None:
+
+        path = vscode_folder / "extensions.json"
+
+        path.write_text(
+            extensions_template.build(),
+            encoding="utf-8",
+        )
+
+        print(f"[OK] File dibuat : {path}")