control-zero 0.2.0__py3-none-any.whl

control_zero/mcp/middleware.py

@@ -0,0 +1,148 @@
+"""MCP middleware for intercepting and wrapping MCP calls."""
+
+from typing import Any, Callable, Optional
+import time
+
+from control_zero.types import AuditLogEntry
+from control_zero.policy import PolicyDecision, PolicyDeniedError
+
+
+class MCPMiddleware:
+    """
+    Middleware for wrapping MCP client calls.
+
+    This intercepts calls to MCP servers and:
+    1. Checks policies before execution
+    2. Injects secrets into the request
+    3. Logs the call for audit
+
+    Usage:
+        from mcp import Client
+        from control_zero import ControlZeroClient, MCPMiddleware
+
+        cz = ControlZeroClient(api_key="cz_live_xxx")
+        await cz.initialize()
+
+        mcp_client = Client()
+        wrapped_client = MCPMiddleware(cz).wrap(mcp_client)
+
+        # Use wrapped client normally
+        result = await wrapped_client.call_tool("github", "list_issues")
+    """
+
+    def __init__(self, control_zero_client: Any):
+        """
+        Initialize the middleware.
+
+        Args:
+            control_zero_client: The ControlZeroClient instance
+        """
+        self._cz = control_zero_client
+
+    def wrap(self, mcp_client: Any) -> Any:
+        """
+        Wrap an MCP client with Control Zero middleware.
+
+        Args:
+            mcp_client: The MCP client to wrap
+
+        Returns:
+            The wrapped client
+        """
+        # Store reference to original call_tool
+        original_call_tool = getattr(mcp_client, "call_tool", None)
+
+        if original_call_tool is None:
+            raise ValueError("MCP client must have a call_tool method")
+
+        # Create wrapped version
+        async def wrapped_call_tool(
+            tool: str,
+            method: str,
+            arguments: Optional[dict[str, Any]] = None,
+            **kwargs: Any,
+        ) -> Any:
+            return await self._intercept_call(
+                original_call_tool,
+                tool,
+                method,
+                arguments,
+                **kwargs,
+            )
+
+        # Replace the method
+        mcp_client.call_tool = wrapped_call_tool
+
+        return mcp_client
+
+    async def _intercept_call(
+        self,
+        original_fn: Callable[..., Any],
+        tool: str,
+        method: str,
+        arguments: Optional[dict[str, Any]],
+        **kwargs: Any,
+    ) -> Any:
+        """Intercept and wrap an MCP call."""
+        start = time.perf_counter()
+
+        # Check policy
+        decision = self._cz._policy_cache.evaluate(tool, method)
+        if decision.effect == "deny":
+            await self._log(tool, method, "denied", 0, decision)
+            raise PolicyDeniedError(decision)
+
+        # Get secrets for this tool
+        secrets = self._cz._secrets.get_for_tool(tool)
+
+        # Inject secrets into arguments or kwargs
+        if secrets:
+            if arguments is None:
+                arguments = {}
+            arguments["_secrets"] = secrets
+
+        try:
+            # Call original function
+            result = await original_fn(tool, method, arguments, **kwargs)
+
+            latency_ms = int((time.perf_counter() - start) * 1000)
+            await self._log(tool, method, "success", latency_ms, decision)
+
+            return result
+
+        except PolicyDeniedError:
+            raise
+        except Exception as e:
+            latency_ms = int((time.perf_counter() - start) * 1000)
+            await self._log(
+                tool, method, "error", latency_ms, decision,
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            raise
+
+    async def _log(
+        self,
+        tool: str,
+        method: str,
+        status: str,
+        latency_ms: int,
+        decision: PolicyDecision,
+        error_type: Optional[str] = None,
+        error_message: Optional[str] = None,
+    ) -> None:
+        """Log the call."""
+        entry = AuditLogEntry(
+            tool_name=tool,
+            method_name=method,
+            latency_ms=latency_ms,
+            status=status,
+            policy_decision=decision.effect,
+            policy_id=decision.policy_id,
+            error_type=error_type,
+            error_message=error_message,
+        )
+
+        # Queue for async sending
+        if hasattr(self._cz, "_queue"):
+            await self._cz._queue.put(entry)

control_zero/policy/__init__.py

@@ -0,0 +1,5 @@
+"""Policy enforcement for Control Zero SDK."""
+
+from control_zero.policy.enforcer import PolicyCache, PolicyDecision, PolicyDeniedError
+
+__all__ = ["PolicyCache", "PolicyDecision", "PolicyDeniedError"]

control_zero/policy/enforcer.py

@@ -0,0 +1,99 @@
+"""Local policy cache and enforcement."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from control_zero.types import PolicyRule
+
+
+@dataclass
+class PolicyDecision:
+    """Result of a policy evaluation."""
+    effect: str  # "allow" or "deny"
+    policy_id: Optional[str] = None
+    reason: Optional[str] = None
+
+
+class PolicyDeniedError(Exception):
+    """Raised when a policy denies an action."""
+
+    def __init__(self, decision: PolicyDecision):
+        self.decision = decision
+        super().__init__(
+            f"Policy denied: {decision.reason or 'no reason provided'}"
+        )
+
+
+class PolicyCache:
+    """
+    Local cache of policies for fast evaluation.
+
+    Policies are fetched from Control Zero on init and cached locally.
+    The SDK evaluates policies before every tool call to enforce access control.
+    """
+
+    def __init__(self):
+        self._policies: list[PolicyRule] = []
+
+    def load(self, policies: list[PolicyRule]) -> None:
+        """Load policies into the cache."""
+        self._policies = policies
+
+    def evaluate(self, tool: str, method: str) -> PolicyDecision:
+        """
+        Evaluate policies for a tool call.
+
+        Args:
+            tool: The tool name
+            method: The method name
+
+        Returns:
+            PolicyDecision with effect "allow" or "deny"
+        """
+        action = f"{tool}:{method}"
+
+        # Check each policy in order
+        for policy in self._policies:
+            if self._matches_action(policy.actions, action):
+                return PolicyDecision(
+                    effect=policy.effect,
+                    policy_id=policy.id,
+                    reason=f"Matched policy {policy.id}",
+                )
+
+        # Default: allow if no policy matches
+        return PolicyDecision(
+            effect="allow",
+            reason="No matching policy",
+        )
+
+    def _matches_action(self, policy_actions: list[str], action: str) -> bool:
+        """Check if an action matches any of the policy actions."""
+        tool, method = action.split(":", 1)
+
+        for pa in policy_actions:
+            # Exact match
+            if pa == action:
+                return True
+
+            # Wildcard match
+            if pa == "*":
+                return True
+
+            # Tool wildcard: "github:*"
+            if pa.endswith(":*"):
+                policy_tool = pa[:-2]
+                if policy_tool == tool:
+                    return True
+
+            # Method wildcard: "*:read"
+            if pa.startswith("*:"):
+                policy_method = pa[2:]
+                if policy_method == method:
+                    return True
+
+        return False
+
+    def clear(self) -> None:
+        """Clear the policy cache."""
+        self._policies.clear()

control_zero/secrets/__init__.py

@@ -0,0 +1,5 @@
+"""Secrets management for Control Zero SDK."""
+
+from control_zero.secrets.manager import SecretManager
+
+__all__ = ["SecretManager"]

control_zero/secrets/manager.py

@@ -0,0 +1,77 @@
+"""In-memory secrets manager with secure handling."""
+
+import base64
+import os
+from typing import Optional
+
+from control_zero.types import ToolConfig
+
+
+class SecretManager:
+    """
+    Manages decrypted secrets in memory.
+
+    Secrets are:
+    1. Received encrypted from Control Zero
+    2. Decrypted using the session key
+    3. Held in memory only (never written to disk)
+    4. Wiped from memory when the session ends
+    """
+
+    def __init__(self):
+        # Store secrets by tool name
+        self._secrets: dict[str, dict[str, str]] = {}
+        self._session_key: Optional[bytes] = None
+
+    def set_session_key(self, key: bytes) -> None:
+        """Set the session key for decryption."""
+        self._session_key = key
+
+    def load_tool_secrets(self, tool: ToolConfig) -> None:
+        """Load and decrypt secrets for a tool."""
+        tool_secrets: dict[str, str] = {}
+
+        for secret in tool.secrets:
+            # In production, decrypt with session key
+            # For now, treat encrypted_value as base64-encoded plaintext
+            try:
+                decrypted = base64.b64decode(secret.encrypted_value).decode("utf-8")
+            except Exception:
+                # If not base64, use as-is (for development)
+                decrypted = secret.encrypted_value
+
+            tool_secrets[secret.name] = decrypted
+
+        self._secrets[tool.name] = tool_secrets
+
+    def get_for_tool(self, tool_name: str) -> dict[str, str]:
+        """Get all secrets for a tool."""
+        return self._secrets.get(tool_name, {})
+
+    def get_secret(self, tool_name: str, secret_name: str) -> Optional[str]:
+        """Get a specific secret."""
+        tool_secrets = self._secrets.get(tool_name, {})
+        return tool_secrets.get(secret_name)
+
+    def wipe(self) -> None:
+        """Securely wipe all secrets from memory."""
+        # Overwrite with random data before clearing
+        for tool_name in list(self._secrets.keys()):
+            for secret_name in list(self._secrets[tool_name].keys()):
+                # Overwrite the string content
+                secret_len = len(self._secrets[tool_name][secret_name])
+                self._secrets[tool_name][secret_name] = os.urandom(secret_len).hex()
+
+            self._secrets[tool_name].clear()
+
+        self._secrets.clear()
+
+        # Clear session key
+        if self._session_key:
+            key_len = len(self._session_key)
+            self._session_key = os.urandom(key_len)
+            self._session_key = None
+
+    def __del__(self):
+        """Ensure secrets are wiped on garbage collection."""
+        self.wipe()

control_zero/types.py

@@ -0,0 +1,51 @@
+"""Type definitions for Control Zero SDK."""
+
+from datetime import datetime
+from typing import Any, Optional
+from pydantic import BaseModel, Field
+
+
+class SecretValue(BaseModel):
+    """An encrypted secret value."""
+    name: str
+    encrypted_value: str
+
+
+class ToolConfig(BaseModel):
+    """Configuration for an MCP tool."""
+    name: str
+    methods: list[str] = Field(default_factory=list)
+    auth_type: str = "managed"  # "managed" or "passthrough"
+    auth_header: Optional[str] = None
+    secrets: list[SecretValue] = Field(default_factory=list)
+
+
+class PolicyRule(BaseModel):
+    """A policy rule for access control."""
+    id: str
+    effect: str  # "allow" or "deny"
+    actions: list[str] = Field(default_factory=list)
+
+
+class SessionConfig(BaseModel):
+    """Configuration returned from SDK init."""
+    project_id: str
+    agent_id: str
+    session_token: str
+    tools: list[ToolConfig] = Field(default_factory=list)
+    policies: list[PolicyRule] = Field(default_factory=list)
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class AuditLogEntry(BaseModel):
+    """An audit log entry for tool calls."""
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    tool_name: str
+    method_name: str
+    latency_ms: int
+    status: str  # "success", "denied", "error"
+    policy_decision: str = "allow"
+    policy_id: Optional[str] = None
+    error_type: Optional[str] = None
+    error_message: Optional[str] = None
+    tags: dict[str, str] = Field(default_factory=dict)

control_zero-0.2.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: control-zero
+Version: 0.2.0
+Summary: Enterprise MCP governance SDK - secrets, policies, and observability
+Project-URL: Homepage, https://controlzero.dev
+Project-URL: Documentation, https://docs.controlzero.dev
+Author-email: Control Zero <hello@controlzero.dev>
+License: Proprietary
+License-File: LICENSE
+Keywords: governance,mcp,observability,policy,secrets
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.20.0; extra == 'all'
+Requires-Dist: crewai>=0.30.0; extra == 'all'
+Requires-Dist: langchain-core>=0.1.0; extra == 'all'
+Requires-Dist: langchain>=0.1.0; extra == 'all'
+Requires-Dist: langgraph>=0.0.20; extra == 'all'
+Requires-Dist: mcp>=0.1.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.30.0; extra == 'crewai'
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.20.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: openai>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: respx>=0.20.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == 'langchain'
+Requires-Dist: langchain>=0.1.0; extra == 'langchain'
+Requires-Dist: langgraph>=0.0.20; extra == 'langchain'
+Provides-Extra: mcp
+Requires-Dist: mcp>=0.1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# Control Zero Python SDK
+
+Enterprise MCP governance - secrets, policies, and observability for AI agents.
+
+## Installation
+
+```bash
+pip install control-zero
+```
+
+## Quick Start
+
+```python
+from control_zero import ControlZeroClient
+
+# Initialize with your API key
+client = ControlZeroClient(api_key="cz_live_xxx")
+
+# This fetches config, secrets, and policies from Control Zero
+client.initialize()
+
+# Call MCP tools - secrets are injected automatically!
+result = client.call_tool("github", "list_issues", {"repo": "acme/app"})
+
+# Close when done (flushes logs)
+client.close()
+```
+
+## Features
+
+### Automatic Secret Injection
+
+Secrets configured in the Control Zero dashboard are automatically:
+1. Fetched encrypted from the server
+2. Decrypted in memory
+3. Injected into your MCP calls
+4. Wiped from memory on session end
+
+```python
+# No need to manage secrets in your code!
+# GitHub PAT is automatically injected
+result = client.call_tool("github", "create_issue", {
+    "repo": "acme/app",
+    "title": "Bug report",
+})
+```
+
+### Policy Enforcement
+
+Policies defined in the dashboard are enforced locally:
+
+```python
+from control_zero import PolicyDeniedError
+
+try:
+    result = client.call_tool("stripe", "create_charge", {...})
+except PolicyDeniedError as e:
+    print(f"Denied: {e.decision.reason}")
+```
+
+### Audit Logging
+
+All tool calls are automatically logged for compliance:
+
+- Timestamp, tool, method
+- Latency and status
+- Policy decisions
+- Errors (without sensitive data)
+
+Logs are batched and sent asynchronously to avoid impacting performance.
+
+## Async Usage
+
+```python
+from control_zero import AsyncControlZeroClient
+
+async with AsyncControlZeroClient(api_key="cz_live_xxx") as client:
+    result = await client.call_tool("github", "list_issues", {"repo": "acme/app"})
+```
+
+## MCP Client Wrapping
+
+Wrap an existing MCP client:
+
+```python
+from mcp import Client
+from control_zero import ControlZeroClient, MCPMiddleware
+
+# Initialize Control Zero
+cz = ControlZeroClient(api_key="cz_live_xxx")
+cz.initialize()
+
+# Wrap your MCP client
+mcp = Client()
+wrapped = MCPMiddleware(cz).wrap(mcp)
+
+# Use wrapped client - all calls go through Control Zero
+result = await wrapped.call_tool("github", "list_issues")
+```
+
+## Configuration
+
+```python
+client = ControlZeroClient(
+    api_key="cz_live_xxx",           # Required
+    agent_name="marketing-bot",       # Optional, for logging
+    base_url="https://api.controlzero.dev",  # Or self-hosted
+)
+```
+
+## API Key Types
+
+- `cz_live_*` - Production keys (real secrets, real logging)
+- `cz_test_*` - Test keys (mock responses, test logging)
+
+## Security
+
+- Secrets are held in memory only, never written to disk
+- Memory is securely wiped on session end
+- All communication is encrypted (TLS)
+- Policies are enforced locally for low latency
+
+## Development
+
+### Running Tests
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run all tests
+python -m pytest tests/ -v
+
+# Run with coverage
+python -m pytest tests/ --cov=control_zero --cov-report=term-missing
+
+# Run specific test files
+python -m pytest tests/test_types.py -v
+python -m pytest tests/test_policy.py -v
+python -m pytest tests/test_secrets.py -v
+python -m pytest tests/test_client.py -v
+```
+
+### Code Quality
+
+```bash
+# Format and lint
+ruff check --fix .
+ruff format .
+
+# Type checking
+mypy control_zero/
+```
+
+## Examples
+
+See the [examples/](./examples/) directory for complete usage examples:
+
+- **slack_bot.py** - Secure Slack messaging with channel restrictions
+- **database_agent.py** - PostgreSQL with read-only policies
+- **analytics_agent.py** - ClickHouse queries with governance
+- **github_agent.py** - GitHub operations with branch protection
+- **multi_tool_agent.py** - Complete multi-tool workflow
+
+## License
+
+Proprietary - Control Zero, Inc.

control_zero-0.2.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+control_zero/__init__.py,sha256=DMNACbWO97maJHYzHxTtsv5mzVNGCyOfU5_Of4t_Tnw,902
+control_zero/client.py,sha256=xC7lyEqx5WsaL7lOUwO2cHSQOsiV_HIXj8EbMgzpo7Q,20503
+control_zero/types.py,sha256=osJfsVNoNSTM9h1gnYBCSDAmdC_vTrD2yTFcZGS6zVU,1505
+control_zero/integrations/crewai/__init__.py,sha256=olaRH8myZpZ8-qruWIiDNs6HrLDO1C6Z2LYjJViJzsQ,1244
+control_zero/integrations/crewai/agent.py,sha256=EWY3sq4aG9HHbFJREkWDLn1f-GJZuv5gaeNJHYUVCYg,7772
+control_zero/integrations/crewai/crew.py,sha256=NgMksCotezh-S6mcXVJhj3JD8zIc4tVqHbEiasjv-II,11241
+control_zero/integrations/crewai/task.py,sha256=T61O67VwNyl88kTomn5tcs9W1QCAq8K0WS666tRFUT0,8542
+control_zero/integrations/crewai/tool.py,sha256=VgVVIrFykoDhkZ1pU7xQU-qugAE89yIxZQ57nj9BJpg,8803
+control_zero/integrations/langchain/__init__.py,sha256=Hz8wOmjPdU4sTCQYM7QBQz1i-0KM5m24S-kDUi0DjFc,1555
+control_zero/integrations/langchain/agent.py,sha256=hI7x8K65qyUhTbE-lxJtOh0WqI8FYWlXwydp2yU9_UM,9460
+control_zero/integrations/langchain/callbacks.py,sha256=3cQvX_7KQL_34eMWpIpqBbFff71FP0ihH_Ygf4chLTQ,12645
+control_zero/integrations/langchain/chain.py,sha256=5JWy08JtMTUuqIGiNlSrCt4igBFBNshnjqjVdlTWS14,9747
+control_zero/integrations/langchain/graph.py,sha256=iU5dh4VCTLbF0Oqg1hjZ7cAJtC9IwygEa7z6JAjegJ4,13618
+control_zero/integrations/langchain/tool.py,sha256=Y20MpZNIVWNTNMa7asYwicbSfVyPOyMXp54YSJwSiRw,7633
+control_zero/llm/__init__.py,sha256=_NgSQ6K54umBjL1_i--E6989ZVOAiDc-4xs9qW2JPQc,1965
+control_zero/llm/base.py,sha256=CHHdrVcE32yeybrcVoPzlcs9YEUz6H7nzG5vTblruec,19675
+control_zero/llm/anthropic/__init__.py,sha256=yzqsfqmnuXMxGpXbzOQiyIV5-WR2PXD7JqhdPyxXIeo,1038
+control_zero/llm/anthropic/client.py,sha256=d4yoUI2OMRSSpekxfgNnDFy8Xk4Cq_m5N04UKKlPVFI,4156
+control_zero/llm/anthropic/messages.py,sha256=V_3F0MdVo1uXFkNDhmQx8FuLzND421HMyqpxozCxfEE,13956
+control_zero/llm/cohere/__init__.py,sha256=rcQUnPc3tFPLsnNm3PVbvKlY4IsaEU4yOsL_t2UJMso,881
+control_zero/llm/cohere/client.py,sha256=ECHMc754BOsIr_dUVf7FDk6lZZi4bJjINATNEjqMvG4,12822
+control_zero/llm/gemini/__init__.py,sha256=y8FUmrFmrdwwROcQjXuXQlXJBww2Rk6VAmEx_9U7x78,887
+control_zero/llm/gemini/client.py,sha256=-9ymNeZz_GzmtXEqhW9r_7NPHgvUBUrQ0z-EzT2NkhY,17337
+control_zero/llm/groq/__init__.py,sha256=pHj2jUEvS4M4HYo0h6I5imw4ctVDbT44Rb8RU0Etk8Q,865
+control_zero/llm/groq/client.py,sha256=G4qgU2AwfnmC6IJiCOQEH9VrVGMmMy1QsYMlMn3nNYM,11195
+control_zero/llm/mistral/__init__.py,sha256=BhIqAkIQ_LU3F-rDZEXd177dyjIotkiid531ETc8bSQ,919
+control_zero/llm/mistral/client.py,sha256=LwHLA6pC1QaAq8QhVsLGZPP3gKg-f9MDQtVzQwZAamA,10768
+control_zero/llm/ollama/__init__.py,sha256=GLPD8tgqsSku4XtvmRlCce2aKcPLdgtuaN0AaTON5P0,797
+control_zero/llm/ollama/client.py,sha256=M2cwmLvjD_MupAArjhmBFuNv799ea8UJSk2sQp51W6s,13671
+control_zero/llm/openai/__init__.py,sha256=3W4htjS--GBi-fdQDOruuanbvzmVBMWmuReKCw_WZiQ,967
+control_zero/llm/openai/chat.py,sha256=uBQVimVFd8Dd5uYz--uwjZ_2Hhw4hRpHInyHvAvSmrM,12576
+control_zero/llm/openai/client.py,sha256=yHYirEivmAqF1NIgEYF_9fcNJUCzs_pcGVTnr4sOPdE,5274
+control_zero/logging/__init__.py,sha256=GtbB9WBhHB-av7OcSrvqaXl-8KYZLKEXpVjKEJzbyDM,128
+control_zero/logging/async_logger.py,sha256=A2BvsD3bEnJJ6_8UxiIKMlBY8eTzTz9H_lRKR-RSFWU,1977
+control_zero/mcp/__init__.py,sha256=mUFuysBHmVe4rtRwrPGcfQJLnZggmRXOn3a2alwFck4,127
+control_zero/mcp/middleware.py,sha256=6S5paoWjODOkYO-YpLMQ9ThoB5S_3Nf6ASoSN4KjWJw,4268
+control_zero/policy/__init__.py,sha256=Ex0TGXRBRcO-Tv4r5IRQgpfw1vri8-SwigE2gwHXUUQ,202
+control_zero/policy/enforcer.py,sha256=iedLkTtHEHIb8SY5b-Ii71R6plHLv8OYnl1wMEy6a1M,2766
+control_zero/secrets/__init__.py,sha256=esYdDAuk7j7wMIbPsFq36JpzMtYNq5aYXnu3-FQUBoo,132
+control_zero/secrets/manager.py,sha256=Kby3x1SBqG_5JLY4eyFpE2tiVQ-9UyuF58MfKkTTIcU,2597
+control_zero-0.2.0.dist-info/METADATA,sha256=Q_o4_LwMq4-nqOWelS5SjLM-kWDDchq5Xa11g7e5E60,5793
+control_zero-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+control_zero-0.2.0.dist-info/licenses/LICENSE,sha256=I_jItrMUVjobSKqIUgcU8NFUA2ttg8-ylLkqwuVZXt8,741
+control_zero-0.2.0.dist-info/RECORD,,

control_zero-0.2.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

control_zero-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2024 Control Zero
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.