instant-python 0.20.0__py3-none-any.whl

instant_python/shared/domain/config_repository.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from instant_python.shared.domain.config_schema import ConfigSchema
+
+
+class ConfigRepository(ABC):
+    @abstractmethod
+    def write(self, config: ConfigSchema) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def read(self, path: Path) -> ConfigSchema:
+        raise NotImplementedError
+
+    @abstractmethod
+    def move(self, config: ConfigSchema, destination_path: Path) -> None:
+        raise NotImplementedError

instant_python/shared/domain/config_schema.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TypedDict, Union
+
+from instant_python.shared.domain.dependency_config import (
+    DependencyConfig,
+)
+from instant_python.shared.domain.general_config import (
+    GeneralConfig,
+)
+from instant_python.shared.domain.git_config import GitConfig
+from instant_python.shared.domain.template_config import (
+    TemplateConfig,
+)
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.supported_templates import SupportedTemplates
+
+_GENERAL = "general"
+_DEPENDENCIES = "dependencies"
+_TEMPLATE = "template"
+_GIT = "git"
+_REQUIRED_CONFIG_KEYS = [_GENERAL, _DEPENDENCIES, _TEMPLATE, _GIT]
+
+
+@dataclass
+class ConfigSchema:
+    general: GeneralConfig
+    dependencies: list[DependencyConfig]
+    template: TemplateConfig
+    git: GitConfig
+    config_file_path: Path = field(default_factory=lambda: ConfigSchema._DEFAULT_CONFIG_PATH)
+
+    _DEFAULT_CONFIG_PATH: Path = Path.cwd() / "ipy.yml"
+
+    @classmethod
+    def from_primitives(
+        cls, content: dict[str, Union[dict, list]], custom_config_path: Union[Path, None] = None
+    ) -> "ConfigSchema":
+        cls._ensure_config_is_not_empty(content)
+        cls._ensure_all_required_sections_are_present(content)
+        return cls(
+            general=GeneralConfig(**content[_GENERAL]),
+            dependencies=[DependencyConfig(**dep) for dep in content[_DEPENDENCIES]] if content[_DEPENDENCIES] else [],
+            template=TemplateConfig(**content[_TEMPLATE]),
+            git=GitConfig(**content[_GIT]),
+            config_file_path=custom_config_path if custom_config_path else cls._DEFAULT_CONFIG_PATH,
+        )
+
+    @classmethod
+    def _ensure_config_is_not_empty(cls, content: dict[str, Union[dict, list]]) -> None:
+        if not content:
+            raise EmptyConfigurationNotAllowed
+
+    @classmethod
+    def _ensure_all_required_sections_are_present(cls, content: dict[str, Union[dict, list]]):
+        missing_keys = [key for key in _REQUIRED_CONFIG_KEYS if key not in content]
+        if missing_keys:
+            raise ConfigKeyNotPresent(missing_keys, _REQUIRED_CONFIG_KEYS)
+
+    def calculate_config_destination_path(self, base_directory: Path) -> Path:
+        return base_directory / self.project_folder_name / self.config_file_path.name
+
+    def calculate_project_structure_template_name(self) -> str:
+        if self.template_type == SupportedTemplates.CUSTOM:
+            return ""
+        return self.template_type
+
+    def to_primitives(self) -> "ConfigSchemaPrimitives":
+        return ConfigSchemaPrimitives(
+            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
+
+    @property
+    def version_control_has_to_be_initialized(self) -> bool:
+        return self.git.initialize
+
+
+class ConfigSchemaPrimitives(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]]
+
+
+class ConfigKeyNotPresent(ApplicationError):
+    def __init__(self, missing_keys: list[str], required_keys: list[str]) -> None:
+        super().__init__(
+            message=f"The following required keys are missing from the config file: {', '.join(missing_keys)}. Required keys are: {', '.join(required_keys)}."
+        )
+
+
+class EmptyConfigurationNotAllowed(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__(message="Configuration file cannot be empty.")

instant_python/shared/domain/dependency_config.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass, field, asdict
+
+from instant_python.shared.application_error import ApplicationError
+
+
+@dataclass
+class DependencyConfig:
+    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)
+
+
+class NotDevDependencyIncludedInGroup(ApplicationError):
+    def __init__(self, dependency_name: str, dependency_group: str) -> None:
+        super().__init__(
+            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."
+        )

instant_python/shared/domain/general_config.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from dataclasses import dataclass, asdict, field
+from typing import ClassVar
+
+from instant_python.shared.application_error import ApplicationError
+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 GeneralConfig:
+    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)
+
+
+class InvalidDependencyManagerValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        super().__init__(
+            message=f"Invalid dependency manager: {value}. Allowed values are {', '.join(supported_values)}."
+        )
+
+
+class InvalidLicenseValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        super().__init__(message=f"Invalid license: {value}. Allowed values are {', '.join(supported_values)}.")
+
+
+class InvalidPythonVersionValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        super().__init__(
+            message=f"Invalid Python version: {value}. Allowed versions are {', '.join(supported_values)}."
+        )

instant_python/shared/domain/git_config.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+
+from instant_python.shared.application_error import ApplicationError
+
+
+@dataclass
+class GitConfig:
+    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_not_specified() or self._email_is_not_specified()):
+            raise GitUserOrEmailNotPresent()
+
+    def _email_is_not_specified(self) -> bool:
+        return self.email is None or self.email == ""
+
+    def _username_is_not_specified(self) -> bool:
+        return self.username is None or self.username == ""
+
+    def to_primitives(self) -> dict[str, str | bool]:
+        return asdict(self)
+
+
+class GitUserOrEmailNotPresent(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__(message="When initializing a git repository, both username and email must be provided.")

instant_python/shared/domain/template_config.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass, field, asdict
+from typing import ClassVar, Optional, Union
+
+from instant_python.shared.application_error import ApplicationError
+from instant_python.shared.supported_built_in_features import SupportedBuiltInFeatures
+from instant_python.shared.supported_templates import SupportedTemplates
+
+
+@dataclass
+class TemplateConfig:
+    name: str
+    built_in_features: list[str] = field(default_factory=list)
+    specify_bounded_context: bool = field(default=False)
+    bounded_context: Optional[str] = field(default=None)
+    aggregate_name: Optional[str] = field(default=None)
+
+    _SUPPORTED_TEMPLATES: ClassVar[list[str]] = SupportedTemplates.get_supported_templates()
+    _SUPPORTED_BUILT_IN_FEATURES: ClassVar[list[str]] = SupportedBuiltInFeatures.get_supported_built_in_features()
+
+    def __post_init__(self) -> None:
+        self._ensure_template_is_supported()
+        self._ensure_built_in_features_are_supported()
+        self._ensure_bounded_context_is_only_applicable_for_ddd_template()
+        self._ensure_bounded_context_is_set_if_specified()
+
+    def _ensure_template_is_supported(self) -> None:
+        if self.name not in self._SUPPORTED_TEMPLATES:
+            raise InvalidTemplateValue(self.name, self._SUPPORTED_TEMPLATES)
+
+    def _ensure_built_in_features_are_supported(self) -> None:
+        unsupported_features = [
+            feature for feature in self.built_in_features if feature not in self._SUPPORTED_BUILT_IN_FEATURES
+        ]
+        if unsupported_features:
+            raise InvalidBuiltInFeaturesValues(unsupported_features, self._SUPPORTED_BUILT_IN_FEATURES)
+
+    def _ensure_bounded_context_is_only_applicable_for_ddd_template(self) -> None:
+        if (
+            self.specify_bounded_context or self.bounded_context or self.aggregate_name
+        ) and self.name != SupportedTemplates.DDD:
+            raise BoundedContextNotApplicable(self.name)
+
+    def _ensure_bounded_context_is_set_if_specified(self) -> None:
+        if self.specify_bounded_context and (not self.bounded_context or not self.aggregate_name):
+            raise BoundedContextNotSpecified()
+
+    def to_primitives(self) -> dict[str, Union[str, list[str]]]:
+        return asdict(self)
+
+
+class BoundedContextNotApplicable(ApplicationError):
+    def __init__(self, value: str) -> None:
+        super().__init__(
+            message=f"Bounded context feature is not applicable for template '{value}'. Is only applicable for 'domain_driven_design' template."
+        )
+
+
+class BoundedContextNotSpecified(ApplicationError):
+    def __init__(self) -> None:
+        super().__init__(
+            message="Option to specify bounded context is set as True, but either bounded context or aggregate name is not specified."
+        )
+
+
+class InvalidBuiltInFeaturesValues(ApplicationError):
+    def __init__(self, values: list[str], supported_values: list[str]) -> None:
+        super().__init__(
+            message=f"Features {', '.join(values)} are not supported. Supported features are: {', '.join(supported_values)}."
+        )
+
+
+class InvalidTemplateValue(ApplicationError):
+    def __init__(self, value: str, supported_values: list[str]) -> None:
+        super().__init__(
+            message=f"Invalid template: '{value}'. Supported templates are: {', '.join(supported_values)}."
+        )

instant_python/shared/infra/persistence/yaml_config_repository.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+import shutil
+import yaml
+
+from instant_python.shared.domain.config_schema import ConfigSchema
+from instant_python.shared.domain.config_repository import ConfigRepository
+from instant_python.shared.application_error import ApplicationError
+
+
+class YamlConfigRepository(ConfigRepository):
+    def write(self, config: ConfigSchema) -> None:
+        destination_path = config.config_file_path
+        with destination_path.open("w") as file:
+            yaml.dump(config.to_primitives(), file)
+
+    def read(self, path: Path) -> ConfigSchema:
+        try:
+            with path.open("r") as file:
+                raw_config = yaml.safe_load(file)
+                return ConfigSchema.from_primitives(content=raw_config, custom_config_path=path)
+        except FileNotFoundError:
+            raise ConfigurationFileNotFound(str(path))
+
+    def move(self, config: ConfigSchema, base_directory: Path) -> None:
+        final_destination = config.calculate_config_destination_path(
+            base_directory=base_directory,
+        )
+        ipy_config_project_folder = final_destination.parent / "ipy.yml"
+        shutil.move(config.config_file_path, ipy_config_project_folder)
+
+
+class ConfigurationFileNotFound(ApplicationError):
+    def __init__(self, path: str) -> None:
+        super().__init__(
+            message=f"Configuration file not found at '{path}'. To create a project, you first"
+            f" need a configuration file. Please, run 'ipy config' command to create one.\n"
+            f"If you have the configuration file in another location, use the '-c' flag.",
+        )

instant_python/shared/supported_built_in_features.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class SupportedBuiltInFeatures(str, Enum):
+    VALUE_OBJECTS = "value_objects"
+    GITHUB_ACTIONS = "github_actions"
+    GITHUB_ISSUES_TEMPLATE = "github_issues_template"
+    MAKEFILE = "makefile"
+    LOGGER = "logger"
+    EVENT_BUS = "event_bus"
+    ASYNC_SQLALCHEMY = "async_sqlalchemy"
+    ASYNC_ALEMBIC = "async_alembic"
+    FASTAPI = "fastapi_application"
+    PRECOMMIT = "precommit_hook"
+    CITATION = "citation_file"
+    SECURITY = "security_file"
+
+    @classmethod
+    def get_supported_built_in_features(cls) -> list[str]:
+        return [feature.value for feature in cls]

instant_python/shared/supported_licenses.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SupportedLicenses(str, Enum):
+    MIT = "MIT"
+    APACHE = "Apache"
+    GPL = "GPL"
+
+    @classmethod
+    def get_supported_licenses(cls) -> list[str]:
+        return [license.value for license in cls]

instant_python/shared/supported_managers.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SupportedManagers(str, Enum):
+    UV = "uv"
+    PDM = "pdm"
+
+    @classmethod
+    def get_supported_managers(cls) -> list[str]:
+        return [manager.value for manager in cls]

instant_python/shared/supported_python_versions.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class SupportedPythonVersions(str, Enum):
+    PYTHON_3_10 = "3.10"
+    PYTHON_3_11 = "3.11"
+    PYTHON_3_12 = "3.12"
+    PYTHON_3_13 = "3.13"
+
+    @classmethod
+    def get_supported_versions(cls) -> list[str]:
+        return [version.value for version in cls]

instant_python/shared/supported_templates.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class SupportedTemplates(str, Enum):
+    DDD = "domain_driven_design"
+    CLEAN = "clean_architecture"
+    STANDARD = "standard_project"
+    CUSTOM = "custom"
+
+    @classmethod
+    def get_supported_templates(cls) -> list[str]:
+        return [template.value for template in cls]

instant_python/templates/boilerplate/.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyPI configuration file
+.pypirc