configvault-sdk 0.1.0__py3-none-any.whl

configvault/__init__.py

@@ -0,0 +1,25 @@
+"""ConfigVault Python SDK."""
+
+from configvault.client import ConfigVaultClient
+from configvault.models import ConfigResponse, ConfigListResponse, HealthResponse
+from configvault.exceptions import (
+    ConfigVaultError,
+    ConfigNotFoundError,
+    AuthenticationError,
+    ServiceUnavailableError,
+)
+from configvault.watcher import ConfigWatcher, ConfigChangedEvent
+
+__version__ = "0.1.0"
+__all__ = [
+    "ConfigVaultClient",
+    "ConfigResponse",
+    "ConfigListResponse",
+    "HealthResponse",
+    "ConfigVaultError",
+    "ConfigNotFoundError",
+    "AuthenticationError",
+    "ServiceUnavailableError",
+    "ConfigWatcher",
+    "ConfigChangedEvent",
+]

configvault/client.py

@@ -0,0 +1,165 @@
+"""ConfigVault API client."""
+
+from typing import Optional
+
+import httpx
+
+from configvault.exceptions import (
+    AuthenticationError,
+    ConfigNotFoundError,
+    ConfigVaultError,
+    ServiceUnavailableError,
+)
+from configvault.models import ConfigListResponse, ConfigResponse, HealthResponse
+
+
+class ConfigVaultClient:
+    """Async client for ConfigVault API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+    ) -> None:
+        """
+        Initialize the ConfigVault client.
+
+        Args:
+            base_url: Base URL of the ConfigVault API (e.g., "http://localhost:5000")
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+        """
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create the HTTP client."""
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers={"X-Api-Key": self._api_key},
+                timeout=self._timeout,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> "ConfigVaultClient":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        """Async context manager exit."""
+        await self.close()
+
+    def watch(self, filter_pattern: str | None = None) -> "ConfigWatcher":
+        """
+        Create a watcher for configuration changes.
+
+        Args:
+            filter_pattern: Optional glob pattern to filter keys (e.g., "production/*")
+
+        Returns:
+            ConfigWatcher instance for async iteration
+        """
+        from configvault.watcher import ConfigWatcher
+
+        return ConfigWatcher(
+            base_url=self._base_url,
+            api_key=self._api_key,
+            filter_pattern=filter_pattern,
+        )
+
+    def _handle_error_response(self, response: httpx.Response, key: Optional[str] = None) -> None:
+        """Handle error responses from the API."""
+        if response.status_code == 401:
+            raise AuthenticationError()
+        if response.status_code == 404 and key:
+            raise ConfigNotFoundError(key)
+        if response.status_code == 503:
+            raise ServiceUnavailableError()
+        if response.status_code >= 400:
+            raise ConfigVaultError(f"API error: {response.status_code}")
+
+    async def get(self, key: str) -> str:
+        """
+        Get a configuration value by key.
+
+        Args:
+            key: Hierarchical key (e.g., "production/database/connection")
+
+        Returns:
+            The configuration value
+
+        Raises:
+            ConfigNotFoundError: If the key does not exist
+            AuthenticationError: If the API key is invalid
+            ServiceUnavailableError: If the service is unavailable
+        """
+        client = await self._get_client()
+        response = await client.get(f"/config/{key}")
+
+        self._handle_error_response(response, key)
+
+        data = ConfigResponse.model_validate(response.json())
+        return data.value
+
+    async def exists(self, key: str) -> bool:
+        """
+        Check if a configuration key exists.
+
+        Args:
+            key: Hierarchical key to check
+
+        Returns:
+            True if the key exists, False otherwise
+        """
+        client = await self._get_client()
+        response = await client.head(f"/config/{key}")
+
+        if response.status_code == 404:
+            return False
+        if response.status_code == 401:
+            raise AuthenticationError()
+        if response.status_code == 503:
+            raise ServiceUnavailableError()
+
+        return response.status_code == 200
+
+    async def list(self, namespace: str) -> dict[str, str]:
+        """
+        List all configurations in a namespace.
+
+        Args:
+            namespace: The namespace (folder) to list
+
+        Returns:
+            Dictionary mapping keys to values
+        """
+        client = await self._get_client()
+        response = await client.get("/config", params={"prefix": namespace})
+
+        self._handle_error_response(response)
+
+        data = ConfigListResponse.model_validate(response.json())
+        return data.configs
+
+    async def health(self) -> HealthResponse:
+        """
+        Check the health of the ConfigVault service.
+
+        Returns:
+            Health status information
+        """
+        client = await self._get_client()
+        # Health endpoint doesn't require API key, but we send it anyway
+        response = await client.get("/health")
+
+        return HealthResponse.model_validate(response.json())

configvault/exceptions.py

@@ -0,0 +1,29 @@
+"""ConfigVault SDK exceptions."""
+
+
+class ConfigVaultError(Exception):
+    """Base exception for ConfigVault SDK."""
+
+    pass
+
+
+class ConfigNotFoundError(ConfigVaultError):
+    """Raised when a configuration key is not found."""
+
+    def __init__(self, key: str) -> None:
+        self.key = key
+        super().__init__(f"Configuration key '{key}' not found")
+
+
+class AuthenticationError(ConfigVaultError):
+    """Raised when API key authentication fails."""
+
+    def __init__(self, message: str = "Invalid or missing API key") -> None:
+        super().__init__(message)
+
+
+class ServiceUnavailableError(ConfigVaultError):
+    """Raised when the ConfigVault service is unavailable."""
+
+    def __init__(self, message: str = "ConfigVault service unavailable") -> None:
+        super().__init__(message)

configvault/models.py

@@ -0,0 +1,27 @@
+"""ConfigVault SDK models."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class ConfigResponse(BaseModel):
+    """Response model for a single configuration value."""
+
+    key: str
+    value: str
+
+
+class ConfigListResponse(BaseModel):
+    """Response model for listing configurations."""
+
+    namespace: str = Field(alias="namespace")
+    configs: dict[str, str]
+
+
+class HealthResponse(BaseModel):
+    """Response model for health check."""
+
+    status: str
+    vault: str
+    timestamp: datetime

configvault/watcher.py

@@ -0,0 +1,94 @@
+"""Configuration change watcher using SSE."""
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from datetime import datetime
+import asyncio
+import json
+
+import httpx
+from httpx_sse import aconnect_sse
+
+from configvault.exceptions import AuthenticationError, ServiceUnavailableError
+
+
+@dataclass
+class ConfigChangedEvent:
+    """Event emitted when configuration changes are detected."""
+
+    keys: list[str]
+    timestamp: datetime
+
+
+class ConfigWatcher:
+    """Watches for configuration changes via SSE."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        filter_pattern: str | None = None,
+        reconnect_delay: float = 5.0,
+    ) -> None:
+        """
+        Initialize the watcher.
+
+        Args:
+            base_url: Base URL of the ConfigVault API.
+            api_key: API key for authentication.
+            filter_pattern: Optional glob pattern to filter keys.
+            reconnect_delay: Delay before reconnecting after a failure.
+        """
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._filter_pattern = filter_pattern
+        self._reconnect_delay = reconnect_delay
+        self._running = False
+
+    async def watch(self) -> AsyncIterator[ConfigChangedEvent]:
+        """
+        Watch for configuration changes.
+
+        Yields:
+            ConfigChangedEvent instances when changes are detected.
+        """
+        self._running = True
+
+        while self._running:
+            try:
+                async for event in self._connect():
+                    yield event
+            except httpx.HTTPStatusError as exc:
+                if exc.response.status_code == 401:
+                    raise AuthenticationError() from exc
+                if exc.response.status_code == 503:
+                    raise ServiceUnavailableError() from exc
+                raise
+            except (httpx.ConnectError, httpx.ReadError):
+                if self._running:
+                    await asyncio.sleep(self._reconnect_delay)
+
+    async def _connect(self) -> AsyncIterator[ConfigChangedEvent]:
+        """Connect to the SSE endpoint and yield events."""
+        url = f"{self._base_url}/events"
+        if self._filter_pattern:
+            url += f"?filter={self._filter_pattern}"
+
+        async with httpx.AsyncClient() as client:
+            async with aconnect_sse(
+                client,
+                "GET",
+                url,
+                headers={"X-Api-Key": self._api_key},
+            ) as event_source:
+                async for sse in event_source.aiter_sse():
+                    if sse.event == "config-changed":
+                        data = json.loads(sse.data)
+                        timestamp = datetime.fromisoformat(
+                            data["timestamp"].replace("Z", "+00:00")
+                        )
+                        yield ConfigChangedEvent(keys=data["keys"], timestamp=timestamp)
+
+    def stop(self) -> None:
+        """Stop watching for changes."""
+        self._running = False

configvault_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: configvault-sdk
+Version: 0.1.0
+Summary: Python SDK for ConfigVault API
+Project-URL: Homepage, https://github.com/sitien173/config-vault
+Project-URL: Repository, https://github.com/sitien173/config-vault
+Project-URL: Issues, https://github.com/sitien173/config-vault/issues
+Author: nst173
+License-Expression: MIT
+Keywords: config,configvault,sdk,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx-sse>=0.4.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.21.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ConfigVault Python SDK
+
+Python client for the ConfigVault configuration management API.
+
+## Installation
+
+```bash
+pip install configvault-sdk
+```
+
+## Usage
+
+```python
+from configvault import ConfigVaultClient
+
+client = ConfigVaultClient(
+    base_url="http://localhost:5000",
+    api_key="your-api-key"
+)
+
+# Get a configuration value
+value = await client.get("production/database/connection")
+
+# Check if key exists
+exists = await client.exists("production/database/connection")
+
+# List all configs in namespace
+configs = await client.list("production")
+
+# Check service health
+health = await client.health()
+```
+
+## Watching for Changes
+
+```python
+from configvault import ConfigVaultClient
+
+client = ConfigVaultClient(
+    base_url="http://localhost:5000",
+    api_key="your-api-key"
+)
+
+# Watch all changes
+watcher = client.watch()
+
+# Or filter by pattern
+watcher = client.watch("production/*")
+
+async for event in watcher.watch():
+    print(f"Changed keys: {event.keys}")
+    print(f"Timestamp: {event.timestamp}")
+
+# Stop watching
+watcher.stop()
+```

configvault_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+configvault/__init__.py,sha256=ESiYECMXPPpbT6nKSZK2uleDtoQ09NV-fsS6t-ohbqg,681
+configvault/client.py,sha256=wBGLlSXG7XFA-2tzur5CkUC8I508rDeMyrsnF_YsQqo,5181
+configvault/exceptions.py,sha256=9ixmSz5tu-AkAIer9y3h3nxjZS0fwyzl_dRKsZyyUbg,829
+configvault/models.py,sha256=r9aWA1707i97KZwBHEgrAFx9UusU5HMMN0rV8n2lK2g,549
+configvault/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+configvault/watcher.py,sha256=LTZDa2yb16KPFnSsrE9D87iyWlSsEdsRtvmpVcvDxXk,3146
+configvault_sdk-0.1.0.dist-info/METADATA,sha256=AbN9IsaLfmiGl1S698rBhTjZ_B1uiwFnJjRoMfjAWo4,2170
+configvault_sdk-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+configvault_sdk-0.1.0.dist-info/RECORD,,

configvault_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any