bow-cli 0.4.2__tar.gz → 0.4.4__tar.gz

{bow_cli-0.4.2 → bow_cli-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bow-cli
-Version: 0.4.2
+Version: 0.4.4
 Summary: Pythonic Kubernetes DSL — As powerful as Helm, as easy as Pulumi, as readable as Python
 License-Expression: MIT
 Requires-Python: >=3.11

{bow_cli-0.4.2 → bow_cli-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bow-cli"
-version = "0.4.2"
+version = "0.4.4"
 description = "Pythonic Kubernetes DSL — As powerful as Helm, as easy as Pulumi, as readable as Python"
 readme = "README.md"
 license = "MIT"

{bow_cli-0.4.2 → bow_cli-0.4.4}/src/bow/chart/base.py

@@ -8,7 +8,6 @@ Render logic is written in Python, default values are read from YAML.
 
 from __future__ import annotations
 
-import importlib.metadata
 from pathlib import Path
 from typing import Any, ClassVar
 
@@ -54,29 +53,12 @@ class Chart:
     description: ClassVar[str] = ""
     requires: ClassVar[list[ChartDep]] = []
 
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Auto-populate version from package metadata."""
-        super().__init_subclass__(**kwargs)
-        # Skip for Chart base class itself
-        if cls.__name__ == "Chart":
-            return
-        # Try to read version from package metadata
-        # Package name patterns: bow-<name>, bow_<name>, <name>
-        if cls.name:
-            for pkg_name in [f"bow-{cls.name}", f"bow_{cls.name}", cls.name]:
-                try:
-                    cls.version = importlib.metadata.version(pkg_name)
-                    break
-                except importlib.metadata.PackageNotFoundError:
-                    continue
-
     def default_values(self) -> dict[str, Any]:
-        """Return default values.
+        """Load defaults from defaults.yaml next to the chart module.
 
-        First looks for defaults.yaml next to the chart module,
-        returns an empty dict if not found. Subclass may override.
+        defaults.yaml is required. If missing, raises FileNotFoundError
+        so chart developers are forced to define all defaults explicitly.
         """
-        # Look for defaults.yaml next to the chart module
         module_file = getattr(self.__class__, "__module__", None)
         if module_file:
             import importlib
@@ -87,10 +69,18 @@ class Chart:
                     with open(defaults_path) as f:
                         data = yaml.safe_load(f)
                     return data if isinstance(data, dict) else {}
+                raise FileNotFoundError(
+                    f"defaults.yaml not found for chart '{self.name}'. "
+                    f"Expected at: {defaults_path}"
+                )
         return {}
 
-    def render(self, values: dict[str, Any]) -> None:
-        """Create resources. Subclass MUST implement."""
+    def render(self, values) -> None:
+        """Render chart resources. Subclass MUST implement.
+
+        Args:
+            values: A Values object with dot-access (v.service.port).
+        """
         raise NotImplementedError(f"{self.__class__.__name__}.render()")
 
     def template(
@@ -146,11 +136,14 @@ class Chart:
                     f"Install it with: pip install bow-{dep.chart}"
                 )
 
-            # Dependency values
-            dep_values = get_dep_values(values, dep)
+            # Dependency values: dep chart defaults → dep.default_values → parent overrides
+            dep_defaults = dep_chart.default_values()
+            dep_overrides = get_dep_values(values, dep)
+            from bow.chart.values import deep_merge as _dm, Values
+            dep_values = _dm(dep_defaults, dep_overrides)
 
-            # Render
-            dep_chart.render(dep_values)
+            # Render (wrap in Values for dot-access)
+            dep_chart.render(Values(dep_values))
 
     def info(self) -> dict[str, Any]:
         """Return chart information (for bow inspect)."""

{bow_cli-0.4.2 → bow_cli-0.4.4}/src/bow/chart/dependency.py

@@ -28,8 +28,10 @@ class ChartDep:
     default_values: dict[str, Any] = field(default_factory=dict)
 
 
-def resolve_condition(values: dict, condition: str | None) -> bool:
-    """Check the condition string in the values dict.
+def resolve_condition(values, condition: str | None) -> bool:
+    """Check a dot-path condition against values.
+
+    Works with both dict and Values objects.
 
     >>> resolve_condition({"postgresql": {"enabled": True}}, "postgresql.enabled")
     True
@@ -44,22 +46,28 @@ def resolve_condition(values: dict, condition: str | None) -> bool:
     parts = condition.split(".")
     current: Any = values
     for part in parts:
-        if isinstance(current, dict) and part in current:
+        if _is_mapping(current) and part in current:
             current = current[part]
         else:
-            return True  # Key not found, default enabled
+            return True  # Key missing = default enabled
     return bool(current)
 
 
-def get_dep_values(values: dict, dep: ChartDep) -> dict:
-    """Extract values for the dependency chart.
+def get_dep_values(values, dep: ChartDep) -> dict:
+    """Extract dependency values from parent chart values.
 
-    Uses the nested dict matching the dependency name in the
-    main chart's values; falls back to default_values.
+    Works with both dict and Values objects.
+    Returns a plain dict (dependency chart wraps it in Values itself).
     """
     from bow.chart.values import deep_merge
 
     result = dict(dep.default_values)
-    if dep.chart in values and isinstance(values[dep.chart], dict):
-        result = deep_merge(result, values[dep.chart])
+    raw = values._data if hasattr(values, "_data") else values
+    if dep.chart in raw and isinstance(raw[dep.chart], dict):
+        result = deep_merge(result, raw[dep.chart])
     return result
+
+
+def _is_mapping(obj) -> bool:
+    """Check if obj supports dict-like access (dict or Values)."""
+    return isinstance(obj, dict) or hasattr(obj, "_data")

{bow_cli-0.4.2 → bow_cli-0.4.4}/src/bow/chart/values.py

@@ -68,7 +68,7 @@ def parse_set_values(set_args: list[str]) -> dict:
 
 
 def _coerce_value(value: str) -> Any:
-    """Convert a string value to the appropriate Python type.
+    """String değeri uygun Python tipine çevir.
 
     >>> _coerce_value("3")
     3
@@ -98,8 +98,8 @@ def merge_all_values(
     defaults: dict,
     value_files: list[str | Path],
     set_args: list[str],
-) -> dict:
-    """Merge all value sources.
+) -> Values:
+    """Merge all value sources and return a Values object.
 
     Precedence (low to high):
       defaults → value_files (in order) → set_args
@@ -111,4 +111,73 @@ def merge_all_values(
     if set_args:
         set_values = parse_set_values(set_args)
         result = deep_merge(result, set_values)
-    return result
+    return Values(result)
+
+
+class Values:
+    """Dot-notation access wrapper over a dict.
+
+    Provides clean attribute-style access to nested config::
+
+        v.service.port          # instead of values["service"]["port"]
+        v.resources.cpu         # nested access
+        v.replicas              # scalar
+
+    If a key is missing, raises AttributeError with a clear message
+    pointing to the missing key path (means defaults.yaml is incomplete).
+
+    The underlying dict is always accessible via ``v._data``.
+    Dict-style access (v["key"]) and iteration also work.
+    """
+
+    __slots__ = ("_data",)
+
+    def __init__(self, data: dict[str, Any]):
+        object.__setattr__(self, "_data", data)
+
+    def __getattr__(self, key: str) -> Any:
+        try:
+            val = self._data[key]
+        except KeyError:
+            raise AttributeError(
+                f"Value '{key}' not found. "
+                f"Add it to defaults.yaml or pass via -f / --set"
+            ) from None
+        if isinstance(val, dict):
+            return Values(val)
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        val = self._data[key]
+        if isinstance(val, dict):
+            return Values(val)
+        return val
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __repr__(self) -> str:
+        return f"Values({self._data!r})"
+
+    def __bool__(self) -> bool:
+        return bool(self._data)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Dict-compatible get with fallback."""
+        val = self._data.get(key, default)
+        if isinstance(val, dict):
+            return Values(val)
+        return val
+
+    def items(self):
+        return self._data.items()
+
+    def keys(self):
+        return self._data.keys()
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the underlying raw dict."""
+        return self._data

{bow_cli-0.4.2 → bow_cli-0.4.4}/src/bow/core/resources.py

@@ -468,6 +468,9 @@ class StatefulSet(Resource):
 # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 # SERVICE — both leaf and with
 # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+_UNSET = object()  # Sentinel value for cluster_ip
+
+
 class ServicePort:
     """Service port definition. Used as a leaf inside a Service context."""
 
@@ -523,6 +526,7 @@ class Service(Resource):
     ):
         self.type = type
         self.selector: dict = kwargs.pop("selector", {})
+        self.cluster_ip = kwargs.pop("cluster_ip", _UNSET)
         self.ports: list[dict] = []
 
         # Leaf mode: if port is provided, add it immediately
@@ -542,15 +546,23 @@ class Service(Resource):
         pass  # ServicePort adds directly to self.ports
 
     def render(self) -> dict[str, Any]:
+        spec: dict[str, Any] = {
+            "type": self.type,
+            "selector": self.selector,
+            "ports": self.ports,
+        }
+        if self.cluster_ip is not _UNSET:
+            # User explicitly set cluster_ip
+            if self.cluster_ip is None:
+                # For headless services: cluster_ip=None → clusterIP: "None"
+                spec["clusterIP"] = "None"
+            else:
+                spec["clusterIP"] = self.cluster_ip
         return {
             "apiVersion": self._api_version,
             "kind": self._kind,
             "metadata": {"name": self.metadata["name"]},
-            "spec": {
-                "type": self.type,
-                "selector": self.selector,
-                "ports": self.ports,
-            },
+            "spec": spec,
         }
 
 
@@ -766,3 +778,61 @@ class CronJob(Resource):
                 },
             },
         }
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# ENV HELPERS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+def env_from(credentials, *keys: str) -> None:
+    """Set env vars from a credentials block.
+
+    Routes each key to the right source based on what's
+    configured in the credentials block:
+
+    defaults.yaml — plain values (default)::
+
+        credentials:
+          POSTGRES_USER: postgres
+          POSTGRES_DB: appdb
+          POSTGRES_PASSWORD: secret123
+
+    user overrides with secret::
+
+        credentials:
+          secret_ref: pg-credentials
+
+    user overrides with configmap::
+
+        credentials:
+          configmap_ref: pg-config
+
+    mixed — configmap with one value override::
+
+        credentials:
+          configmap_ref: pg-config
+          POSTGRES_DB: override_db
+
+    Chart code (always the same regardless of source)::
+
+        env_from(v.credentials,
+                 "POSTGRES_USER", "POSTGRES_DB", "POSTGRES_PASSWORD")
+    """
+    data = credentials._data if hasattr(credentials, "_data") else credentials
+    if not isinstance(data, dict):
+        data = {}
+
+    secret_ref = data.get("secret_ref")
+    secrets = data.get("secrets")
+    configmap_ref = data.get("configmap_ref")
+    configmaps = data.get("configmaps")
+    reserved = {"secret_ref", "configmap_ref"}
+
+    for key in keys:
+        if key in data and key not in reserved:
+            # Explicit value — always wins
+            EnvVar(key, value=data[key])
+        elif key in secrets and secret_ref:
+            EnvVar(key, secret_ref=secret_ref, secret_key=secrets[key])
+        elif key in configmaps and configmap_ref:
+            EnvVar(key, configmap_ref=configmap_ref, configmap_key=configmaps[key])
+        else:
+            EnvVar(key, value="")

bow_cli-0.4.4/tests/postgresql/__init__.py

@@ -0,0 +1,77 @@
+"""
+bow.charts.postgresql — PostgreSQL chart.
+
+Minimal PostgreSQL deployment for Kubernetes using bow DSL.
+"""
+
+from __future__ import annotations
+from contextlib import contextmanager
+from typing import Any
+
+from bow import Deployment
+from bow.chart.base import Chart
+from bow.core.resources import (
+    StatefulSet, Container, Secret, Service, PersistentVolumeClaim,
+    Port, EnvVar, Resources, Probe
+)
+from bow.utils import full_image, apply_resources
+
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# REUSABLE COMPONENTS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+@contextmanager
+def postgresql_container(
+    name: str, 
+    image: str, 
+    port: int = 5432, 
+    secret_name: str = "postgres",
+    postgres_user: str = "postgres",
+    postgres_db: str = "postgres",
+    resources: dict | None = None) -> None:
+    """PostgreSQL main container component."""
+    with Container(name, image=image):
+        Port(port, name="postgresql")
+
+        # Core postgres settings
+        EnvVar("POSTGRES_USER", postgres_user)
+        EnvVar("POSTGRES_DB", postgres_db)
+        EnvVar("POSTGRES_PASSWORD", secret_ref=secret_name, secret_key="POSTGRES_PASSWORD")
+        EnvVar("PGDATA", "/var/lib/postgresql/data")
+        
+        apply_resources(resources)
+        yield
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# CHART CLASS
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+class PostgreSQLChart(Chart):
+    name = "postgresql"
+    description = "PostgreSQL chart for bow."
+
+    def render(self, values: dict[str, Any]) -> None:
+        name = values.get("name", self.name)
+        image = full_image(values.get("image", {}))
+        port = values.get("service", {}).get("port", 5432)
+        resources = values.get("resources")        
+        architecture = values.get("architecture", "standalone")
+        persistence = values.get("persistence", {})
+
+        if architecture == "replication":
+            with StatefulSet(name, replicas=values.get("replicas", 1), service_name=f"{name}-headless"):
+                with postgresql_container(name, image, port, resources=resources):
+                    pass
+
+                if persistence.get("enabled", True):
+                    PersistentVolumeClaim("data", size=persistence.get("size", "8Gi"))
+
+                Service(port=port, type=values.get("service", {}).get("type", "ClusterIP"))
+        else:
+            with Deployment(name, replicas=values.get("replicas", 1)):
+                with postgresql_container(name, image, port, resources=resources):
+                    pass
+
+                if persistence.get("enabled", True):
+                    PersistentVolumeClaim("data", size=persistence.get("size", "8Gi"))
+
+                Service(port=port, type=values.get("service", {}).get("type", "ClusterIP"))

{bow_cli-0.4.2 → bow_cli-0.4.4}/tests/test_chart.py

@@ -16,7 +16,7 @@ from bow.core.stack import _reset
 from bow.chart.values import deep_merge, parse_set_values, merge_all_values
 from bow.chart.registry import register_chart, get_chart, list_charts, reset_registry
 from bow.chart.dependency import ChartDep, resolve_condition, get_dep_values
-from bow_postgresql import PostgreSQLChart
+from postgresql import PostgreSQLChart
 
 
 @pytest.fixture(autouse=True)

{bow_cli-0.4.2 → bow_cli-0.4.4}/tests/test_charts.py

@@ -13,9 +13,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
 
 from bow.core.stack import _reset
 from bow.chart.registry import register_chart, get_chart, reset_registry
-from bow_postgresql import PostgreSQLChart, pg_container, pg_service
-from bow_redis import RedisChart, redis_container
-from bow_redmine import RedmineChart, redmine_container, redmine_ingress
+from postgresql import PostgreSQLChart, postgresql_container
 from bow.core.manifest import manifest
 from bow.core.resources import (
     Deployment, Container, Service, Ingress,
@@ -28,8 +26,6 @@ def clean():
     _reset()
     reset_registry()
     register_chart(PostgreSQLChart)
-    register_chart(RedisChart)
-    register_chart(RedmineChart)
     yield
     _reset()
     reset_registry()
@@ -148,7 +144,7 @@ class TestComponentComposition:
         """pg_container can be used directly."""
         with manifest() as m:
             with Deployment("custom-db"):
-                with pg_container(database="custom_db", image="postgres:15"):
+                with postgresql_container(database="custom_db", image="postgres:15"):
                     EnvVar("EXTRA_CONFIG", "value")  # Extend
                 Service(port=5432)
 
@@ -158,28 +154,6 @@ class TestComponentComposition:
         assert "POSTGRES_DB" in env_names
         assert "EXTRA_CONFIG" in env_names  # extended with `with`
 
-    def test_redis_container_standalone(self):
-        """redis_container can be used directly."""
-        with manifest() as m:
-            with Deployment("cache"):
-                with redis_container(name="cache", image="redis:6"):
-                    EnvVar("CUSTOM", "yes")
-                Service(port=6379)
-
-        dep = m.to_dicts()[0]
-        c = dep["spec"]["template"]["spec"]["containers"][0]
-        assert c["image"] == "redis:6"
-        env_names = [e["name"] for e in c.get("env", [])]
-        assert "CUSTOM" in env_names
-
-    def test_redmine_container_extend(self):
-        """redmine_container can be extended."""
-        with manifest() as m:
-            with Deployment("my-redmine"):
-                with redmine_container(db_host="external-pg"):
-                    EnvVar("REDMINE_PLUGINS_MIGRATE", "true")
-                Service(port=3000)
-
         dep = m.to_dicts()[0]
         c = dep["spec"]["template"]["spec"]["containers"][0]
         env_names = [e["name"] for e in c["env"]]
@@ -190,7 +164,7 @@ class TestComponentComposition:
         """Different chart components used together."""
         with manifest() as m:
             with Deployment("pg"):
-                with pg_container(database="app"):
+                with postgresql_container(database="app"):
                     pass
                 Service(port=5432)
 
@@ -214,10 +188,9 @@ class TestComponentComposition:
         """pg_service component in multi-port mode."""
         with manifest() as m:
             with Deployment("pg"):
-                with pg_container():
-                    pass
-                with pg_service(metrics=True):
+                with postgresql_container():
                     pass
+                Service(port=5432, name="pg")
 
         docs = m.to_dicts()
         svc = [d for d in docs if d["kind"] == "Service"][0]
@@ -226,12 +199,4 @@ class TestComponentComposition:
         assert "pg" in port_names
         assert "metrics" in port_names
 
-    def test_ingress_component_extend(self):
-        """redmine_ingress can be extended."""
-        with manifest() as m:
-            with redmine_ingress(host="app.example.com", tls=True):
-                IngressRule("/api", "api-service", 8080)
 
-        ing = m.to_dicts()[0]
-        paths = ing["spec"]["rules"][0]["http"]["paths"]
-        assert len(paths) == 2  # / + /api

{bow_cli-0.4.2 → bow_cli-0.4.4}/tests/test_cli.py

@@ -16,7 +16,7 @@ from click.testing import CliRunner
 
 from bow.core.stack import _reset
 from bow.chart.registry import register_chart, reset_registry
-from bow_postgresql import PostgreSQLChart
+from postgresql import PostgreSQLChart
 from bow.cli import main
 
 

{bow_cli-0.4.2 → bow_cli-0.4.4}/tests/test_stack.py

@@ -14,7 +14,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
 
 from bow.core.stack import _reset
 from bow.chart.registry import register_chart, reset_registry
-from bow_postgresql import PostgreSQLChart
+from postgresql import PostgreSQLChart
 from bow.stack.parser import parse_stack_file, parse_stack_dict, StackParseError
 from bow.stack.refs import resolve_refs, RefError
 from bow.stack.merger import merge_stack_files, apply_set_to_stack

{bow_cli-0.4.2 → bow_cli-0.4.4}/tests/test_workspace.py

@@ -16,9 +16,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
 
 from bow.core.stack import _reset
 from bow.chart.registry import register_chart, reset_registry
-from bow_postgresql import PostgreSQLChart
-from bow_redis import RedisChart
-from bow_redmine import RedmineChart
+from postgresql import PostgreSQLChart
 from bow.workspace.lock import (
     LockSpec, parse_lock, write_lock, compute_checksum, check_drift, LockError,
 )
@@ -31,8 +29,6 @@ def clean():
     _reset()
     reset_registry()
     register_chart(PostgreSQLChart)
-    register_chart(RedisChart)
-    register_chart(RedmineChart)
     yield
     _reset()
     reset_registry()