bakefile 0.0.7__tar.gz → 0.0.8__tar.gz

{bakefile-0.0.7 → bakefile-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.7
+Version: 0.0.8
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
@@ -10,6 +10,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: orjson>=3.11.5
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=14.2.0
 Requires-Dist: ruff>=0.14.10

{bakefile-0.0.7 → bakefile-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bakefile"
-version = "0.0.7" # use git tag
+version = "0.0.8" # use git tag
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -14,6 +14,7 @@ dependencies = [
   "orjson>=3.11.5",
   "pydantic-settings>=2.0.0",
   "pydantic>=2.12.5",
+  "python-dotenv>=1.2.1",
   "pyyaml>=6.0.3",
   "rich>=14.2.0",
   "ruff>=0.14.10",
@@ -40,8 +41,7 @@ dev = [
   "pre-commit>=4.5.1",
   "pytest-cov>=7.0.0",
   "pytest>=9.0.2",
-  "python-dotenv>=1.2.1",
-  "python_package",
+  "python-package",
   "toml-sort>=0.24.3"
 ]
 
@@ -52,6 +52,9 @@ build-backend = "uv_build"
 [tool.deptry]
 known_first_party = ["bake", "bakelib", "python_package"]
 
+[tool.deptry.package_module_name_map]
+pydantic = ["pydantic", "pydantic_core"]
+
 [tool.ruff]
 line-length = 100
 

bakefile-0.0.8/src/bake/manage/write_bakefile.py

@@ -0,0 +1,20 @@
+import types
+from pathlib import Path
+
+from bake.utils.constants import BAKEBOOK_NAME_IN_SAMPLES
+
+
+def write_bakefile(
+    bakefile_path: Path, bakebook_name: str, sample_module: types.ModuleType
+) -> None:
+    if not hasattr(sample_module, BAKEBOOK_NAME_IN_SAMPLES):
+        raise ValueError(
+            f"Module `{sample_module.__name__}` must have `{BAKEBOOK_NAME_IN_SAMPLES}` attribute"
+        )
+
+    if sample_module.__file__ is None:
+        raise ValueError(f"Could not find `{sample_module.__name__}`")
+
+    original_bakefile_content = Path(sample_module.__file__).read_text()
+    customized_content = original_bakefile_content.replace(BAKEBOOK_NAME_IN_SAMPLES, bakebook_name)
+    bakefile_path.write_text(customized_content)

bakefile-0.0.8/src/bakelib/__init__.py

@@ -0,0 +1,23 @@
+from bakelib.environ import (
+    BaseEnv,
+    DevEnvBakebook,
+    EnvBakebook,
+    GcpLandingZoneEnv,
+    ProdEnvBakebook,
+    StagingEnvBakebook,
+    get_bakebook,
+)
+from bakelib.space.base import BaseSpace
+from bakelib.space.python import PythonSpace
+
+__all__ = [
+    "BaseEnv",
+    "BaseSpace",
+    "DevEnvBakebook",
+    "EnvBakebook",
+    "GcpLandingZoneEnv",
+    "ProdEnvBakebook",
+    "PythonSpace",
+    "StagingEnvBakebook",
+    "get_bakebook",
+]

bakefile-0.0.8/src/bakelib/environ/__init__.py

@@ -0,0 +1,14 @@
+from .bakebook import DevEnvBakebook, EnvBakebook, ProdEnvBakebook, StagingEnvBakebook
+from .base import BaseEnv
+from .get_bakebook import get_bakebook
+from .presets import GcpLandingZoneEnv
+
+__all__ = [
+    "BaseEnv",
+    "DevEnvBakebook",
+    "EnvBakebook",
+    "GcpLandingZoneEnv",
+    "ProdEnvBakebook",
+    "StagingEnvBakebook",
+    "get_bakebook",
+]

bakefile-0.0.8/src/bakelib/environ/bakebook.py

@@ -0,0 +1,30 @@
+from typing import Annotated
+
+from pydantic import Field, computed_field
+
+from bake.bakebook.bakebook import Bakebook
+from bakelib.environ.base import BaseEnv
+
+BaseEnvFieldType = Annotated[BaseEnv, Field(exclude=True, repr=False)]
+
+
+class EnvBakebook(Bakebook):
+    # Field name uses underscore suffix to avoid Pydantic reading from ENV env var
+    env_: BaseEnvFieldType = Field(exclude=True, repr=False)
+
+    @computed_field
+    @property
+    def env(self) -> BaseEnv:
+        return self.env_
+
+
+class DevEnvBakebook(EnvBakebook):
+    env_: BaseEnvFieldType = BaseEnv("dev")
+
+
+class StagingEnvBakebook(EnvBakebook):
+    env_: BaseEnvFieldType = BaseEnv("staging")
+
+
+class ProdEnvBakebook(EnvBakebook):
+    env_: BaseEnvFieldType = BaseEnv("prod")

bakefile-0.0.8/src/bakelib/environ/base.py

@@ -0,0 +1,112 @@
+from typing import Any, ClassVar
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+class BaseEnv(str):
+    """BaseEnvironment string with comparison and Pydantic support.
+
+    Inherits from str to provide natural string behavior while adding
+    comparison operators for priority-based ordering.
+
+    ENV_ORDER is a list where each element is either:
+    - A string (normal priority, order matters)
+    - A set of strings (equal priority group)
+
+    Example: ["dev", "staging", {"prod", "share"}]
+    - "dev" has highest priority (index 0)
+    - "staging" has medium priority (index 1)
+    - "prod" and "share" have equal lowest priority (both in set at index 2)
+    """
+
+    ENV_ORDER: ClassVar[list[str | set[str]]] = ["dev", "staging", "prod"]
+
+    def __init__(self, value: str):
+        if not self._is_valid(value):
+            raise ValueError(
+                f"Invalid {self.__class__.__name__}: '{value}'. "
+                f"Must be one of: {self._flattened_env_order()}"
+            )
+
+    @classmethod
+    def _is_valid(cls, value: str) -> bool:
+        try:
+            cls._get_priority_index(value)
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def _flattened_env_order(cls) -> list[str]:
+        result: list[str] = []
+        for item in cls.ENV_ORDER:
+            if isinstance(item, set):
+                result.extend(sorted(item))
+            else:
+                result.append(item)
+        return result
+
+    @classmethod
+    def _get_priority_index(cls, value: str) -> int:
+        for idx, item in enumerate(cls.ENV_ORDER):
+            is_in_set = isinstance(item, set) and value in item
+            is_equal = item == value
+            if is_in_set or is_equal:
+                return idx
+        raise ValueError(f"Value '{value}' not found in ENV_ORDER")
+
+    def __lt__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        self_idx = self._get_priority_index(str(self))
+        other_idx = self._get_priority_index(str(other))
+        if self_idx != other_idx:
+            return self_idx < other_idx
+        # Same priority group, use alphabetical as tiebreaker
+        return str(self) < str(other)
+
+    def __le__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return self < other or self == other
+
+    def __gt__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return not (self < other) and self != other
+
+    def __ge__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return not (self < other)
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is not type(self):
+            return False
+        return str(self) == str(other)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}('{self!s}')"
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        """Pydantic v2 integration for custom type validation."""
+        return core_schema.no_info_after_validator_function(cls, handler(str))
+
+    @classmethod
+    def validate(cls, v: object) -> "BaseEnv":
+        """Validate and convert input to BaseEnv."""
+        if isinstance(v, cls):
+            return v
+        if isinstance(v, str):
+            return cls(v)
+        raise ValueError(f"Cannot convert {type(v).__name__} to {cls.__name__}")

bakefile-0.0.8/src/bakelib/environ/get_bakebook.py

@@ -0,0 +1,49 @@
+import os
+from typing import TypeVar
+
+from dotenv import load_dotenv as _load_dotenv
+
+from .bakebook import EnvBakebook
+
+# TODO: When min Python >= 3.12, use PEP 695 type parameter syntax:
+# def get_bakebook[E: EnvBakebook](bakebooks: list[E], ...) -> E:
+E = TypeVar("E", bound=EnvBakebook)
+
+
+def get_bakebook(
+    bakebooks: list[E],
+    *,
+    env_var_name: str = "ENV",
+    env_value: str | None = None,
+    load_dotenv: bool = True,
+) -> E:
+    if not bakebooks:
+        raise ValueError("bakebooks list cannot be empty")
+
+    # Convert to dict for O(1) lookup and duplicate detection
+    bakebooks_by_env: dict[str, E] = {}
+    for bb in bakebooks:
+        if not hasattr(bb, "env") or bb.env is None:
+            raise ValueError(f"All bakebooks must have an 'env' attribute. Found: {bb}")
+        env = str(bb.env)
+        if env in bakebooks_by_env:
+            raise ValueError(f"Duplicate env '{env}' found in bakebooks list")
+        bakebooks_by_env[env] = bb
+
+    # Get environment value
+    if env_value is None:
+        if load_dotenv:
+            _load_dotenv()
+        env_value = os.getenv(env_var_name)
+
+    # Env var not set - return lowest priority (min)
+    if env_value is None or env_value == "":
+        return bakebooks_by_env[str(min(bb.env for bb in bakebooks))]
+    # If env var is set, require exact match
+    elif env_value in bakebooks_by_env:
+        return bakebooks_by_env[env_value]
+
+    raise ValueError(
+        f"No bakebook found with env='{env_value}'. "
+        f"Available envs: {sorted(bakebooks_by_env.keys())}"
+    )

bakefile-0.0.8/src/bakelib/environ/presets.py

@@ -0,0 +1,70 @@
+"""Preset environment configurations.
+
+This module contains pre-configured environment classes for common use cases.
+Users can also create their own environments by inheriting from BaseEnv.
+"""
+
+from typing import ClassVar
+
+from bakelib.environ.base import BaseEnv
+
+
+class GcpLandingZoneEnv(BaseEnv):
+    """GCP Landing Zone base environments.
+
+    Environment codes follow GCP Security Foundations Blueprint conventions:
+    https://docs.cloud.google.com/architecture/blueprints/security-foundations/summary
+
+    Environment Codes:
+    - d               - Development
+    - n               - Nonproduction
+    - p               - Production
+    - s               - Shared
+    - b               - Bootstrap
+    - c               - Common
+    - net             - Network
+
+    Tiers (ordered by priority, lower index = higher priority):
+    - d (development) - lowest priority
+    - n (nonprod)
+    - p/s/b/c/net     - highest priority, all equal (production + shared)
+
+    Example:
+        env = GcpLandingZoneEnv("d")
+        assert env < GcpLandingZoneEnv("n")
+        assert GcpLandingZoneEnv("n") < GcpLandingZoneEnv("p")
+    """
+
+    ENV_ORDER: ClassVar[list[str | set[str]]] = [
+        "d",
+        "n",
+        {"p", "s", "b", "c", "net"},
+    ]
+
+    def is_shared(self) -> bool:
+        return self.code in {"s", "b", "c", "net"}
+
+    @property
+    def name(self) -> str:
+        names = {
+            "d": "Development",
+            "n": "Nonproduction",
+            "p": "Production",
+            "s": "Shared",
+            "b": "Bootstrap",
+            "c": "Common",
+            "net": "Network",
+        }
+        return names[self.code]
+
+    @property
+    def code(self) -> str:
+        return str(self)
+
+    @property
+    def secondary_name(self) -> str:
+        return self.name if not self.is_shared() else "Shared"
+
+    @property
+    def secondary_code(self) -> str:
+        return self.code if not self.is_shared() else "s"

bakefile-0.0.7/src/bake/manage/write_bakefile.py

@@ -1,39 +0,0 @@
-import types
-from pathlib import Path
-
-from bake.samples import simple
-from bake.utils.constants import BAKEBOOK_NAME_IN_SAMPLES
-
-# Allowed sample modules
-# This dictionary acts as a whitelist for security - only these modules can be used
-ALLOWED_SAMPLE_MODULES: dict[str, types.ModuleType] = {
-    simple.__name__: simple,
-}
-
-
-def write_bakefile(
-    bakefile_path: Path, bakebook_name: str, sample_module: types.ModuleType
-) -> None:
-    if not hasattr(sample_module, BAKEBOOK_NAME_IN_SAMPLES):
-        raise ValueError(
-            f"Module `{sample_module.__name__}` must have `{BAKEBOOK_NAME_IN_SAMPLES}` attribute"
-        )
-
-    module_name = sample_module.__name__
-    if module_name not in ALLOWED_SAMPLE_MODULES:
-        raise ValueError(
-            f"Module `{module_name}` is not in the allowed sample modules list. "
-            f"Allowed modules: {list(ALLOWED_SAMPLE_MODULES.keys())}"
-        )
-
-    allowed_module = ALLOWED_SAMPLE_MODULES[module_name]
-    if sample_module is not allowed_module:
-        raise ValueError(f"Module `{module_name}` does not match the allowed module object")
-
-    if allowed_module.__file__ is None:
-        raise ValueError(f"Could not find file for module `{module_name}`")
-
-    source_file_path = Path(allowed_module.__file__)
-    original_bakefile_content = source_file_path.read_text()
-    customized_content = original_bakefile_content.replace(BAKEBOOK_NAME_IN_SAMPLES, bakebook_name)
-    bakefile_path.write_text(customized_content)

bakefile-0.0.7/src/bakelib/__init__.py

@@ -1,4 +0,0 @@
-from bakelib.space.base import BaseSpace
-from bakelib.space.python import PythonSpace
-
-__all__ = ["BaseSpace", "PythonSpace"]