contex-python 0.1.0__py3-none-any.whl

contex/__init__.py

@@ -0,0 +1,49 @@
+"""
+Contex Python SDK
+~~~~~~~~~~~~~~~~~
+
+Official Python client for Contex - Semantic context routing for AI agents.
+
+Basic usage:
+
+    >>> from contex import ContexClient
+    >>> client = ContexClient(url="http://localhost:8001", api_key="ck_...")
+    >>> await client.publish(project_id="my-app", data_key="config", data={"env": "prod"})
+
+Full documentation: https://github.com/cahoots-org/contex
+"""
+
+__version__ = "0.2.0"
+__author__ = "Contex Team"
+__license__ = "MIT"
+
+from .client import ContexClient, ContexAsyncClient
+from .models import (
+    DataEvent,
+    AgentRegistration,
+    RegistrationResponse,
+    MatchedData,
+)
+from .exceptions import (
+    ContexError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    NotFoundError,
+    ServerError,
+)
+
+__all__ = [
+    "ContexClient",
+    "ContexAsyncClient",
+    "DataEvent",
+    "AgentRegistration",
+    "RegistrationResponse",
+    "MatchedData",
+    "ContexError",
+    "AuthenticationError",
+    "RateLimitError",
+    "ValidationError",
+    "NotFoundError",
+    "ServerError",
+]

contex/client.py

@@ -0,0 +1,412 @@
+"""Contex Python SDK client implementation"""
+
+import asyncio
+from typing import Any, Dict, List, Optional, AsyncIterator
+import httpx
+from .models import (
+    DataEvent,
+    AgentRegistration,
+    RegistrationResponse,
+    QueryRequest,
+    QueryResponse,
+    APIKeyResponse,
+    RateLimitInfo,
+)
+from .exceptions import (
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    NotFoundError,
+    ServerError,
+    NetworkError,
+    TimeoutError as ContexTimeoutError,
+)
+
+
+class ContexAsyncClient:
+    """
+    Async Contex client for Python.
+    
+    Example:
+        >>> client = ContexAsyncClient(url="http://localhost:8001", api_key="ck_...")
+        >>> await client.publish(project_id="my-app", data_key="config", data={"env": "prod"})
+    """
+    
+    def __init__(
+        self,
+        url: str = "http://localhost:8001",
+        api_key: Optional[str] = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        """
+        Initialize Contex client.
+        
+        Args:
+            url: Contex server URL
+            api_key: API key for authentication
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+        """
+        self.url = url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._client: Optional[httpx.AsyncClient] = None
+    
+    async def __aenter__(self):
+        """Async context manager entry"""
+        self._client = httpx.AsyncClient(timeout=self.timeout)
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        if self._client:
+            await self._client.aclose()
+    
+    def _get_headers(self) -> Dict[str, str]:
+        """Get request headers"""
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "contex-python/0.2.0",
+        }
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        return headers
+    
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[Dict] = None,
+        params: Optional[Dict] = None,
+    ) -> Any:
+        """Make HTTP request with error handling and retries"""
+        url = f"{self.url}{path}"
+        headers = self._get_headers()
+        
+        # Create client if not in context manager
+        if self._client is None:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                return await self._do_request(client, method, url, headers, json, params)
+        else:
+            return await self._do_request(self._client, method, url, headers, json, params)
+    
+    async def _do_request(
+        self,
+        client: httpx.AsyncClient,
+        method: str,
+        url: str,
+        headers: Dict[str, str],
+        json: Optional[Dict] = None,
+        params: Optional[Dict] = None,
+    ) -> Any:
+        """Execute HTTP request with retries"""
+        last_exception = None
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    json=json,
+                    params=params,
+                )
+                
+                # Handle response
+                if response.status_code == 200 or response.status_code == 201:
+                    return response.json()
+                
+                elif response.status_code == 401:
+                    raise AuthenticationError("Invalid or missing API key")
+                
+                elif response.status_code == 403:
+                    raise AuthenticationError("Insufficient permissions")
+                
+                elif response.status_code == 404:
+                    raise NotFoundError(f"Resource not found: {url}")
+                
+                elif response.status_code == 422:
+                    error_detail = response.json().get("detail", "Validation error")
+                    raise ValidationError(f"Validation error: {error_detail}")
+                
+                elif response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    raise RateLimitError(
+                        "Rate limit exceeded",
+                        retry_after=int(retry_after) if retry_after else None
+                    )
+                
+                elif response.status_code >= 500:
+                    error_msg = response.json().get("detail", "Server error")
+                    raise ServerError(f"Server error: {error_msg}")
+                
+                else:
+                    raise ServerError(f"Unexpected status code: {response.status_code}")
+            
+            except httpx.TimeoutException as e:
+                last_exception = ContexTimeoutError(f"Request timed out: {e}")
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(2 ** attempt)  # Exponential backoff
+                    continue
+            
+            except httpx.RequestError as e:
+                last_exception = NetworkError(f"Network error: {e}")
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(2 ** attempt)
+                    continue
+        
+        # All retries failed
+        if last_exception:
+            raise last_exception
+    
+    # ========================================================================
+    # Data Publishing
+    # ========================================================================
+    
+    async def publish(
+        self,
+        project_id: str,
+        data_key: str,
+        data: Any,
+        data_format: str = "json",
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Publish data to Contex.
+        
+        Args:
+            project_id: Project identifier
+            data_key: Unique key for this data
+            data: Data payload (any JSON-serializable type)
+            data_format: Data format (json, yaml, toml, text)
+            metadata: Optional metadata
+        
+        Returns:
+            Response with status and sequence number
+        
+        Example:
+            >>> await client.publish(
+            ...     project_id="my-app",
+            ...     data_key="config",
+            ...     data={"env": "prod", "debug": False}
+            ... )
+        """
+        event = DataEvent(
+            project_id=project_id,
+            data_key=data_key,
+            data=data,
+            data_format=data_format,
+            metadata=metadata,
+        )
+        return await self._request("POST", "/api/data/publish", json=event.model_dump())
+    
+    # ========================================================================
+    # Agent Management
+    # ========================================================================
+    
+    async def register_agent(
+        self,
+        agent_id: str,
+        project_id: str,
+        data_needs: List[str],
+        notification_method: str = "redis",
+        webhook_url: Optional[str] = None,
+        webhook_secret: Optional[str] = None,
+        last_seen_sequence: str = "0",
+    ) -> RegistrationResponse:
+        """
+        Register an agent with Contex.
+        
+        Args:
+            agent_id: Unique agent identifier
+            project_id: Project identifier
+            data_needs: List of data needs in natural language
+            notification_method: Notification method (redis or webhook)
+            webhook_url: Webhook URL (if using webhook notifications)
+            webhook_secret: Webhook secret for HMAC verification
+            last_seen_sequence: Last seen sequence number
+        
+        Returns:
+            Registration response with matched data
+        
+        Example:
+            >>> response = await client.register_agent(
+            ...     agent_id="code-reviewer",
+            ...     project_id="my-app",
+            ...     data_needs=["coding standards", "test requirements"]
+            ... )
+            >>> print(f"Matched {len(response.matched_data)} items")
+        """
+        registration = AgentRegistration(
+            agent_id=agent_id,
+            project_id=project_id,
+            data_needs=data_needs,
+            notification_method=notification_method,
+            webhook_url=webhook_url,
+            webhook_secret=webhook_secret,
+            last_seen_sequence=last_seen_sequence,
+        )
+        result = await self._request("POST", "/api/agents/register", json=registration.model_dump())
+        return RegistrationResponse(**result)
+    
+    async def unregister_agent(self, agent_id: str) -> Dict[str, Any]:
+        """
+        Unregister an agent.
+        
+        Args:
+            agent_id: Agent identifier
+        
+        Returns:
+            Response confirming unregistration
+        """
+        return await self._request("DELETE", f"/api/agents/{agent_id}")
+    
+    async def get_agent_status(self, agent_id: str) -> Dict[str, Any]:
+        """
+        Get agent status.
+        
+        Args:
+            agent_id: Agent identifier
+        
+        Returns:
+            Agent status information
+        """
+        return await self._request("GET", f"/api/agents/{agent_id}/status")
+    
+    # ========================================================================
+    # Querying
+    # ========================================================================
+    
+    async def query(
+        self,
+        project_id: str,
+        query: str,
+        max_results: int = 10,
+    ) -> QueryResponse:
+        """
+        Query for relevant data.
+        
+        Args:
+            project_id: Project identifier
+            query: Query string in natural language
+            max_results: Maximum number of results
+        
+        Returns:
+            Query response with matched data
+        
+        Example:
+            >>> response = await client.query(
+            ...     project_id="my-app",
+            ...     query="authentication configuration"
+            ... )
+            >>> for result in response.results:
+            ...     print(f"{result.data_key}: {result.similarity_score}")
+        """
+        request = QueryRequest(
+            project_id=project_id,
+            query=query,
+            max_results=max_results,
+        )
+        result = await self._request("POST", "/api/query", json=request.model_dump())
+        return QueryResponse(**result)
+    
+    # ========================================================================
+    # API Key Management
+    # ========================================================================
+    
+    async def create_api_key(self, name: str) -> APIKeyResponse:
+        """
+        Create a new API key.
+        
+        Args:
+            name: Name for the API key
+        
+        Returns:
+            API key response with key details
+        
+        Note:
+            The API key is only returned once. Store it securely!
+        """
+        result = await self._request("POST", f"/api/auth/keys?name={name}")
+        return APIKeyResponse(**result)
+    
+    async def list_api_keys(self) -> List[Dict[str, Any]]:
+        """List all API keys (without the actual key values)"""
+        return await self._request("GET", "/api/auth/keys")
+    
+    async def revoke_api_key(self, key_id: str) -> Dict[str, Any]:
+        """
+        Revoke an API key.
+        
+        Args:
+            key_id: Key identifier
+        """
+        return await self._request("DELETE", f"/api/auth/keys/{key_id}")
+    
+    # ========================================================================
+    # Health & Status
+    # ========================================================================
+    
+    async def health(self) -> Dict[str, Any]:
+        """Get comprehensive health status"""
+        return await self._request("GET", "/api/health")
+    
+    async def ready(self) -> Dict[str, Any]:
+        """Get readiness status"""
+        return await self._request("GET", "/api/health/ready")
+    
+    async def rate_limit_status(self) -> RateLimitInfo:
+        """Get current rate limit status"""
+        result = await self._request("GET", "/api/rate-limit/status")
+        return RateLimitInfo(**result)
+
+
+class ContexClient(ContexAsyncClient):
+    """
+    Synchronous Contex client (wrapper around async client).
+    
+    Example:
+        >>> client = ContexClient(url="http://localhost:8001", api_key="ck_...")
+        >>> client.publish(project_id="my-app", data_key="config", data={"env": "prod"})
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+    
+    def _run_async(self, coro):
+        """Run async coroutine in sync context"""
+        if self._loop is None:
+            self._loop = asyncio.new_event_loop()
+        return self._loop.run_until_complete(coro)
+    
+    def publish(self, *args, **kwargs):
+        """Synchronous publish"""
+        return self._run_async(super().publish(*args, **kwargs))
+    
+    def register_agent(self, *args, **kwargs):
+        """Synchronous register_agent"""
+        return self._run_async(super().register_agent(*args, **kwargs))
+    
+    def unregister_agent(self, *args, **kwargs):
+        """Synchronous unregister_agent"""
+        return self._run_async(super().unregister_agent(*args, **kwargs))
+    
+    def query(self, *args, **kwargs):
+        """Synchronous query"""
+        return self._run_async(super().query(*args, **kwargs))
+    
+    def health(self, *args, **kwargs):
+        """Synchronous health"""
+        return self._run_async(super().health(*args, **kwargs))
+    
+    def create_api_key(self, *args, **kwargs):
+        """Synchronous create_api_key"""
+        return self._run_async(super().create_api_key(*args, **kwargs))
+    
+    def __del__(self):
+        """Cleanup event loop"""
+        if self._loop:
+            self._loop.close()

contex/exceptions.py

@@ -0,0 +1,44 @@
+"""Contex SDK exceptions"""
+
+
+class ContexError(Exception):
+    """Base exception for all Contex SDK errors"""
+    pass
+
+
+class AuthenticationError(ContexError):
+    """Raised when authentication fails"""
+    pass
+
+
+class RateLimitError(ContexError):
+    """Raised when rate limit is exceeded"""
+    
+    def __init__(self, message: str, retry_after: int = None):
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+class ValidationError(ContexError):
+    """Raised when request validation fails"""
+    pass
+
+
+class NotFoundError(ContexError):
+    """Raised when resource is not found"""
+    pass
+
+
+class ServerError(ContexError):
+    """Raised when server returns 5xx error"""
+    pass
+
+
+class NetworkError(ContexError):
+    """Raised when network request fails"""
+    pass
+
+
+class TimeoutError(ContexError):
+    """Raised when request times out"""
+    pass

contex/models.py

@@ -0,0 +1,70 @@
+"""Contex SDK data models"""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class DataEvent(BaseModel):
+    """Data event to publish"""
+    project_id: str = Field(..., description="Project identifier")
+    data_key: str = Field(..., description="Unique key for this data")
+    data: Any = Field(..., description="Data payload (any JSON-serializable type)")
+    data_format: Optional[str] = Field(default="json", description="Data format: json, yaml, toml, text")
+    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Optional metadata")
+
+
+class AgentRegistration(BaseModel):
+    """Agent registration request"""
+    agent_id: str = Field(..., description="Unique agent identifier")
+    project_id: str = Field(..., description="Project identifier")
+    data_needs: List[str] = Field(..., description="List of data needs in natural language")
+    notification_method: Optional[str] = Field(default="redis", description="Notification method: redis or webhook")
+    webhook_url: Optional[str] = Field(default=None, description="Webhook URL (if notification_method=webhook)")
+    webhook_secret: Optional[str] = Field(default=None, description="Webhook secret for HMAC verification")
+    last_seen_sequence: Optional[str] = Field(default="0", description="Last seen sequence number")
+
+
+class MatchedData(BaseModel):
+    """Matched data returned to agent"""
+    data_key: str
+    data: Any
+    similarity_score: float
+    sequence: str
+    timestamp: str
+
+
+class RegistrationResponse(BaseModel):
+    """Agent registration response"""
+    agent_id: str
+    project_id: str
+    notification_channel: Optional[str] = None
+    matched_data: List[MatchedData]
+    last_seen_sequence: str
+
+
+class QueryRequest(BaseModel):
+    """Query request"""
+    project_id: str
+    query: str
+    max_results: Optional[int] = Field(default=10, ge=1, le=100)
+
+
+class QueryResponse(BaseModel):
+    """Query response"""
+    results: List[MatchedData]
+    total: int
+
+
+class APIKeyResponse(BaseModel):
+    """API key creation response"""
+    key_id: str
+    key: str
+    name: str
+    created_at: str
+
+
+class RateLimitInfo(BaseModel):
+    """Rate limit information"""
+    limit: int
+    remaining: int
+    reset_at: str

contex_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: contex-python
+Version: 0.1.0
+Summary: Official Python SDK for Contex - Semantic context routing for AI agents
+Author-email: Cahoots <admin@cahoots.cc>
+License: MIT
+Project-URL: Homepage, https://github.com/cahoots-org/contex
+Project-URL: Repository, https://github.com/cahoots-org/contex
+Project-URL: Issues, https://github.com/cahoots-org/contex/issues
+Keywords: ai,agents,context,semantic-search,machine-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Contex Python SDK
+
+Official Python client for [Contex](https://github.com/cahoots-org/contex) - Semantic context routing for AI agents.
+
+## Installation
+
+```bash
+pip install contex-python
+```
+
+## Quick Start
+
+### Async Client (Recommended)
+
+```python
+from contex import ContexAsyncClient
+
+async def main():
+    async with ContexAsyncClient(
+        url="http://localhost:8001",
+        api_key="ck_your_api_key_here"
+    ) as client:
+        # Publish data
+        await client.publish(
+            project_id="my-app",
+            data_key="coding_standards",
+            data={
+                "style": "PEP 8",
+                "max_line_length": 100,
+                "quotes": "double"
+            }
+        )
+        
+        # Register agent
+        response = await client.register_agent(
+            agent_id="code-reviewer",
+            project_id="my-app",
+            data_needs=[
+                "coding standards and style guidelines",
+                "testing requirements and coverage goals"
+            ]
+        )
+        
+        print(f"Matched {len(response.matched_data)} items")
+        for match in response.matched_data:
+            print(f"  {match.data_key}: {match.similarity_score:.2f}")
+        
+        # Query for data
+        results = await client.query(
+            project_id="my-app",
+            query="authentication configuration"
+        )
+        
+        for result in results.results:
+            print(f"{result.data_key}: {result.data}")
+
+import asyncio
+asyncio.run(main())
+```
+
+### Sync Client
+
+```python
+from contex import ContexClient
+
+client = ContexClient(
+    url="http://localhost:8001",
+    api_key="ck_your_api_key_here"
+)
+
+# Publish data
+client.publish(
+    project_id="my-app",
+    data_key="config",
+    data={"env": "prod", "debug": False}
+)
+
+# Register agent
+response = client.register_agent(
+    agent_id="my-agent",
+    project_id="my-app",
+    data_needs=["configuration", "secrets"]
+)
+```
+
+## Features
+
+- ✅ **Async & Sync**: Both async and synchronous interfaces
+- ✅ **Type Hints**: Full type annotations with Pydantic models
+- ✅ **Error Handling**: Comprehensive exception hierarchy
+- ✅ **Retry Logic**: Automatic retries with exponential backoff
+- ✅ **Rate Limiting**: Built-in rate limit handling
+- ✅ **Authentication**: API key authentication support
+
+## API Reference
+
+### Client Initialization
+
+```python
+client = ContexAsyncClient(
+    url="http://localhost:8001",  # Contex server URL
+    api_key="ck_...",              # API key for authentication
+    timeout=30.0,                  # Request timeout in seconds
+    max_retries=3,                 # Maximum number of retries
+)
+```
+
+### Publishing Data
+
+```python
+await client.publish(
+    project_id="my-app",           # Project identifier
+    data_key="unique-key",         # Unique key for this data
+    data={"any": "json"},          # Data payload
+    data_format="json",            # Format: json, yaml, toml, text
+    metadata={"tags": ["prod"]},   # Optional metadata
+)
+```
+
+### Registering Agents
+
+```python
+response = await client.register_agent(
+    agent_id="agent-1",                    # Unique agent ID
+    project_id="my-app",                   # Project ID
+    data_needs=["config", "secrets"],      # Data needs (natural language)
+    notification_method="redis",           # redis or webhook
+    webhook_url="https://...",             # Optional webhook URL
+    webhook_secret="secret",               # Optional webhook secret
+    last_seen_sequence="0",                # Last seen sequence
+)
+```
+
+### Querying Data
+
+```python
+results = await client.query(
+    project_id="my-app",
+    query="authentication settings",
+    max_results=10,
+)
+
+for result in results.results:
+    print(f"{result.data_key}: {result.similarity_score}")
+```
+
+### API Key Management
+
+```python
+# Create API key
+key_response = await client.create_api_key(name="production-key")
+print(f"API Key: {key_response.key}")  # Store this securely!
+
+# List keys
+keys = await client.list_api_keys()
+
+# Revoke key
+await client.revoke_api_key(key_id="key-123")
+```
+
+### Health Checks
+
+```python
+# Comprehensive health
+health = await client.health()
+
+# Readiness check
+ready = await client.ready()
+
+# Rate limit status
+rate_limit = await client.rate_limit_status()
+print(f"Remaining: {rate_limit.remaining}/{rate_limit.limit}")
+```
+
+## Exception Handling
+
+```python
+from contex import (
+    ContexError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    NotFoundError,
+    ServerError,
+)
+
+try:
+    await client.publish(...)
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Validation error: {e}")
+except NotFoundError:
+    print("Resource not found")
+except ServerError:
+    print("Server error")
+except ContexError as e:
+    print(f"Contex error: {e}")
+```
+
+## Development
+
+### Setup
+
+```bash
+cd sdk/python
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Formatting
+
+```bash
+black contex/
+ruff check contex/
+mypy contex/
+```
+
+## Examples
+
+See the [examples](examples/) directory for more usage examples:
+
+- `basic_usage.py` - Basic publish and query
+- `agent_registration.py` - Agent registration and updates
+- `webhook_agent.py` - Webhook-based agent
+- `error_handling.py` - Error handling patterns
+- `batch_operations.py` - Batch publishing
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [Documentation](https://contex.readthedocs.io)
+- [GitHub](https://github.com/cahoots-org/contex)
+- [PyPI](https://pypi.org/project/contex-python/)
+- [Issues](https://github.com/cahoots-org/contex/issues)

contex_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+contex/__init__.py,sha256=bx7OgH5qs3fANEQ1NGTeRq6J2feBkEZ-lwKAzccZfTk,1058
+contex/client.py,sha256=Mdw_5Ez22wFJTlKEptw-5dgSVfhwYjCmhnjmAq2EoNA,14106
+contex/exceptions.py,sha256=pqzfumyLkMvRDELsE5TmI7d1P9NT-ZRJyMB7X-SWHHE,882
+contex/models.py,sha256=TdLNEOvUqpAM_9L3mpWDR2mCCTVDlYNCOyT1519r2K4,2253
+contex_python-0.1.0.dist-info/licenses/LICENSE,sha256=ocKsEnLoJ4FUPpfVkwLpK__UOQ6UrKCOGVWopyCOM7g,1068
+contex_python-0.1.0.dist-info/METADATA,sha256=dGaJ0PLkyrHemoHrD7eVS577GGZZ1NuLerWavDI7ylU,7056
+contex_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+contex_python-0.1.0.dist-info/top_level.txt,sha256=Jk2ojGh-mGli0p8efzIi5IM8OEc4Et-0TAiBfNtGaTo,7
+contex_python-0.1.0.dist-info/RECORD,,

contex_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

contex_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Contex Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

contex_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+contex