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

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

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: bow-cli
-Version: 0.3.1
+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
 Requires-Dist: click>=8.0
 Requires-Dist: jq-utils<0.2.0,>=0.1.1
+Requires-Dist: oras>=0.2.30
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: semver>=3.0
 Description-Content-Type: text/markdown

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bow-cli"
-version = "0.3.1"
+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"
@@ -14,6 +14,7 @@ dependencies = [
     "click>=8.0",
     "semver>=3.0",
     "jq-utils (>=0.1.1,<0.2.0)",
+    "oras>=0.2.30",
 ]
 
 [project.scripts]

{bow_cli-0.3.1 → 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.3.1 → 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.3.1 → 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.3.1 → bow_cli-0.4.4}/src/bow/cli/pull_cmd.py

@@ -22,15 +22,6 @@ def pull_cmd(reference):
     # Parse reference: name:version or oci://reg/name:version
     name, version, registry_url = _parse_reference(reference, cfg)
 
-    # Whitelist check
-    if not cfg.is_registry_allowed(registry_url):
-        click.echo(
-            f"❌ Registry not allowed: {registry_url}\n"
-            f"Add it to security.allowed_registries in ~/.bow/config.yaml",
-            err=True,
-        )
-        sys.exit(1)
-
     # Pull
     try:
         env = get_env()
@@ -83,13 +74,7 @@ def _parse_reference(ref: str, cfg) -> tuple[str, str, str]:
     else:
         # postgresql:16.4.0 — use default registry
         name_version = ref
-        default_reg = cfg.default_registry()
-        if default_reg is None:
-            raise click.BadParameter(
-                "No default registry configured. "
-                "Run: bow registry add default oci://..."
-            )
-        registry_base = default_reg.url
+        registry_base = cfg.default_registry().url
 
     if ":" in name_version:
         name, version = name_version.rsplit(":", 1)

{bow_cli-0.3.1 → bow_cli-0.4.4}/src/bow/cli/push_cmd.py

@@ -3,7 +3,7 @@ bow.cli.push_cmd — bow push command.
 
   bow push . --tag 16.4.0
   bow push ./charts/bow-postgresql
-  bow push . --registry oci://harbor.internal/charts
+  bow push . --registry oci://ghcr.io/getbow/charts
 """
 
 import sys
@@ -21,17 +21,9 @@ def push_cmd(chart_dir, tag, registry):
 
     cfg = load_config()
 
-    # Resolve registry
+    # Resolve registry (always has a default now)
     if registry is None:
-        default_reg = cfg.default_registry()
-        if default_reg is None:
-            click.echo(
-                "Error: No registry specified and no default configured.\n"
-                "Run: bow registry add default oci://...",
-                err=True,
-            )
-            sys.exit(1)
-        registry = default_reg.url
+        registry = cfg.default_registry().url
 
     # Package
     try:
@@ -48,6 +40,7 @@ def push_cmd(chart_dir, tag, registry):
         )
 
         # Push
+        click.echo(f"Pushing to {registry}...", err=True)
         ref = push_chart(artifact, registry)
         click.echo(f"✓ Pushed to {ref}", err=True)
 

{bow_cli-0.3.1 → bow_cli-0.4.4}/src/bow/cli/registry_cmd.py

@@ -1,10 +1,12 @@
 """
 bow.cli.registry_cmd — bow registry command.
 
-  bow registry add default oci://ghcr.io/myorg/charts
+  bow registry add default oci://ghcr.io/getbow/charts
   bow registry add harbor oci://harbor.internal/bow --default
   bow registry list
   bow registry remove harbor
+  bow registry login ghcr.io
+  bow registry login ghcr.io -u USERNAME -p TOKEN
 """
 
 import sys
@@ -17,6 +19,45 @@ def registry_cmd():
     pass
 
 
+@registry_cmd.command("login")
+@click.argument("hostname")
+@click.option("--username", "-u", default=None, help="Registry username")
+@click.option("--password", "-p", default=None,
+              help="Registry password/token (or use --password-stdin)")
+@click.option("--password-stdin", is_flag=True,
+              help="Read password from stdin")
+def registry_login(hostname, username, password, password_stdin):
+    """Login to an OCI registry.
+
+    \b
+    Examples:
+      bow registry login ghcr.io
+      bow registry login ghcr.io -u USERNAME -p ghp_TOKEN
+      echo $GITHUB_TOKEN | bow registry login ghcr.io -u USERNAME --password-stdin
+    """
+    import oras.client
+
+    if password_stdin:
+        password = sys.stdin.readline().strip()
+
+    if not username:
+        username = click.prompt("Username")
+    if not password:
+        password = click.prompt("Password/Token", hide_input=True)
+
+    try:
+        client = oras.client.OrasClient()
+        client.login(
+            hostname=hostname,
+            username=username,
+            password=password,
+        )
+        click.echo(f"✓ Logged in to {hostname}")
+    except Exception as e:
+        click.echo(f"Error: Login failed: {e}", err=True)
+        sys.exit(1)
+
+
 @registry_cmd.command("add")
 @click.argument("name")
 @click.argument("url")

{bow_cli-0.3.1 → bow_cli-0.4.4}/src/bow/core/resource.py

@@ -70,6 +70,8 @@ class Resource:
         self.props = kwargs
 
         # Attach to parent or register as top-level
+        if self.enabled is False:
+            return
         parent = _current()
         if parent is not None:
             parent._adopt(self)

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

@@ -348,6 +348,8 @@ class Deployment(Resource):
                 child.selector = dict(self.labels)
             self.services.append(child)
         elif isinstance(child, PersistentVolumeClaim):
+            if child.enabled is False:
+                return
             self.pvcs.append(child)
             self.volumes.append({
                 "name": child.claim_name,
@@ -423,6 +425,8 @@ class StatefulSet(Resource):
                 child.selector = dict(self.labels)
             self.services.append(child)
         elif isinstance(child, PersistentVolumeClaim):
+            if child.enabled is False:
+                return
             self.volume_claim_templates.append(child.render_template())
         else:
             super()._adopt(child)
@@ -464,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."""
 
@@ -519,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
@@ -538,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,
         }
 
 
@@ -762,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.3.1 → bow_cli-0.4.4}/src/bow/oci/__init__.py

@@ -2,6 +2,7 @@
 
 from bow.oci.config import (
     BowConfig, RegistryConfig, load_config, save_config, BOW_HOME,
+    DEFAULT_REGISTRY_URL, DEFAULT_REGISTRY_NAME,
 )
 from bow.oci.env import (
     EnvInfo, EnvError,
@@ -15,6 +16,7 @@ from bow.oci.client import (
 
 __all__ = [
     "BowConfig", "RegistryConfig", "load_config", "save_config", "BOW_HOME",
+    "DEFAULT_REGISTRY_URL", "DEFAULT_REGISTRY_NAME",
     "EnvInfo", "EnvError",
     "create_env", "delete_env", "get_env", "use_env", "list_envs",
     "resolve_active_env", "pip_install_in_env",