juniper-data-client 0.3.0__py3-none-any.whl

juniper_data_client/__init__.py

@@ -0,0 +1,28 @@
+"""JuniperData Client - Python client library for the JuniperData REST API.
+
+This package provides a simple, robust client for interacting with the JuniperData
+dataset generation service, used by both JuniperCascor and JuniperCanopy.
+"""
+
+from juniper_data_client.client import JuniperDataClient
+from juniper_data_client.exceptions import (
+    JuniperDataClientError,
+    JuniperDataConfigurationError,
+    JuniperDataConnectionError,
+    JuniperDataNotFoundError,
+    JuniperDataTimeoutError,
+    JuniperDataValidationError,
+)
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "JuniperDataClient",
+    "JuniperDataClientError",
+    "JuniperDataConfigurationError",
+    "JuniperDataConnectionError",
+    "JuniperDataNotFoundError",
+    "JuniperDataTimeoutError",
+    "JuniperDataValidationError",
+    "__version__",
+]

juniper_data_client/client.py

@@ -0,0 +1,407 @@
+"""REST API client for JuniperData service integration.
+
+Provides dataset creation, artifact download, and preview functionality
+for JuniperCascor and JuniperCanopy applications.
+"""
+
+import io
+import os
+import time
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlparse
+
+import numpy as np
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from juniper_data_client.exceptions import (
+    JuniperDataClientError,
+    JuniperDataConnectionError,
+    JuniperDataNotFoundError,
+    JuniperDataTimeoutError,
+    JuniperDataValidationError,
+)
+
+
+class JuniperDataClient:
+    """Client for interacting with the JuniperData REST API.
+
+    Provides methods for dataset creation, artifact retrieval, and service health
+    checking with automatic retry logic and connection pooling.
+
+    Example:
+        >>> client = JuniperDataClient("http://localhost:8100")
+        >>> result = client.create_dataset("spiral", {"n_spirals": 2, "seed": 42})
+        >>> arrays = client.download_artifact_npz(result["dataset_id"])
+        >>> X_train, y_train = arrays["X_train"], arrays["y_train"]
+    """
+
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_RETRIES = 3
+    DEFAULT_BACKOFF_FACTOR = 0.5
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8100",
+        timeout: int = DEFAULT_TIMEOUT,
+        retries: int = DEFAULT_RETRIES,
+        backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+        api_key: Optional[str] = None,
+    ):
+        """Initialize the JuniperData client.
+
+        Args:
+            base_url: Base URL for the JuniperData API (default: http://localhost:8100)
+            timeout: Request timeout in seconds (default: 30)
+            retries: Number of retry attempts for failed requests (default: 3)
+            backoff_factor: Backoff factor for retry delays (default: 0.5)
+            api_key: API key for authentication. If not provided, reads from
+                JUNIPER_DATA_API_KEY environment variable.
+        """
+        self.base_url = self._normalize_url(base_url)
+        self.timeout = timeout
+        self.retries = retries
+        self.backoff_factor = backoff_factor
+        self.session = self._create_session()
+
+        resolved_api_key = api_key or os.environ.get("JUNIPER_DATA_API_KEY")
+        if resolved_api_key:
+            self.session.headers["X-API-Key"] = resolved_api_key
+
+    def _normalize_url(self, url: str) -> str:
+        """Normalize the base URL for consistent API calls.
+
+        Args:
+            url: Raw URL string to normalize
+
+        Returns:
+            Normalized URL with scheme, no trailing slash, no /v1 suffix
+        """
+        url = url.strip()
+
+        if not url.startswith(("http://", "https://")):
+            url = f"http://{url}"
+
+        parsed = urlparse(url)
+        normalized = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
+        normalized = normalized.rstrip("/")
+
+        if normalized.endswith("/v1"):
+            normalized = normalized[:-3]
+
+        return normalized
+
+    def _create_session(self) -> requests.Session:
+        """Create a requests session with retry logic and connection pooling.
+
+        Returns:
+            Configured requests.Session with retry adapter
+        """
+        session = requests.Session()
+
+        retry_strategy = Retry(
+            total=self.retries,
+            backoff_factor=self.backoff_factor,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["HEAD", "GET", "POST", "DELETE"],
+        )
+
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_connections=10,
+            pool_maxsize=10,
+        )
+
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+
+        return session
+
+    def _request(self, method: str, endpoint: str, **kwargs: Any) -> requests.Response:
+        """Make an HTTP request with error handling.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint path
+            **kwargs: Additional arguments passed to requests
+
+        Returns:
+            Response object
+
+        Raises:
+            JuniperDataConnectionError: On connection failure
+            JuniperDataTimeoutError: On request timeout
+            JuniperDataNotFoundError: On 404 response
+            JuniperDataValidationError: On 400/422 response
+            JuniperDataClientError: On other HTTP errors
+        """
+        url = f"{self.base_url}{endpoint}"
+        kwargs.setdefault("timeout", self.timeout)
+
+        try:
+            response = self.session.request(method, url, **kwargs)
+        except requests.exceptions.ConnectionError as e:
+            raise JuniperDataConnectionError(f"Failed to connect to JuniperData at {self.base_url}: {e}") from e
+        except requests.exceptions.Timeout as e:
+            raise JuniperDataTimeoutError(f"Request to {url} timed out after {self.timeout}s: {e}") from e
+        except requests.exceptions.RequestException as e:
+            raise JuniperDataClientError(f"Request failed: {e}") from e
+
+        if response.ok:
+            return response
+
+        error_detail = response.text
+        try:
+            error_json = response.json()
+            if "detail" in error_json:
+                error_detail = error_json["detail"]
+        except (ValueError, KeyError):
+            # If the response body is not valid JSON or lacks a 'detail' field,
+            # fall back to using the raw response text as the error detail.
+            error_detail = response.text
+
+        if response.status_code == 404:
+            raise JuniperDataNotFoundError(f"Resource not found: {error_detail}")
+        elif response.status_code in (400, 422):
+            raise JuniperDataValidationError(f"Validation error: {error_detail}")
+        else:
+            raise JuniperDataClientError(f"Request failed ({response.status_code}): {error_detail}")
+
+    def health_check(self) -> Dict[str, Any]:
+        """Check if the JuniperData service is healthy.
+
+        Returns:
+            Health status response from the service
+
+        Raises:
+            JuniperDataConnectionError: If service is unreachable
+        """
+        response = self._request("GET", "/v1/health")
+        return response.json()
+
+    def is_ready(self) -> bool:
+        """Check if the JuniperData service is ready to accept requests.
+
+        Returns:
+            True if service is ready, False otherwise
+        """
+        try:
+            response = self._request("GET", "/v1/health/ready")
+            return response.json().get("status") == "ready"
+        except JuniperDataClientError:
+            return False
+
+    def wait_for_ready(self, timeout: float = 30.0, poll_interval: float = 0.5) -> bool:
+        """Wait for the JuniperData service to become ready.
+
+        Args:
+            timeout: Maximum time to wait in seconds (default: 30)
+            poll_interval: Time between readiness checks in seconds (default: 0.5)
+
+        Returns:
+            True if service became ready within timeout, False otherwise
+        """
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_ready():
+                return True
+            time.sleep(poll_interval)
+        return False
+
+    def list_generators(self) -> List[Dict[str, Any]]:
+        """List available dataset generators.
+
+        Returns:
+            List of generator information dictionaries
+        """
+        response = self._request("GET", "/v1/generators")
+        return response.json()
+
+    def get_generator_schema(self, name: str) -> Dict[str, Any]:
+        """Get the parameter schema for a generator.
+
+        Args:
+            name: Generator name (e.g., "spiral")
+
+        Returns:
+            JSON schema for generator parameters
+
+        Raises:
+            JuniperDataNotFoundError: If generator not found
+        """
+        response = self._request("GET", f"/v1/generators/{name}/schema")
+        return response.json()
+
+    def create_dataset(self, generator: str, params: Dict[str, Any], persist: bool = True) -> Dict[str, Any]:
+        """Create a new dataset via the JuniperData API.
+
+        If a dataset with the same parameters already exists, the existing
+        dataset is returned (caching behavior).
+
+        Args:
+            generator: Name of the dataset generator to use (e.g., "spiral")
+            params: Parameters to pass to the generator
+            persist: Whether to persist the dataset (default: True)
+
+        Returns:
+            Parsed JSON response containing dataset_id, generator, meta, and artifact_url
+
+        Raises:
+            JuniperDataValidationError: If parameters are invalid
+            JuniperDataNotFoundError: If generator not found
+        """
+        payload = {
+            "generator": generator,
+            "params": params,
+            "persist": persist,
+        }
+
+        response = self._request("POST", "/v1/datasets", json=payload)
+        return response.json()
+
+    def list_datasets(self, limit: int = 100, offset: int = 0) -> List[str]:
+        """List dataset IDs.
+
+        Args:
+            limit: Maximum number of dataset IDs to return (default: 100)
+            offset: Number of dataset IDs to skip (default: 0)
+
+        Returns:
+            List of dataset ID strings
+        """
+        response = self._request("GET", "/v1/datasets", params={"limit": limit, "offset": offset})
+        return response.json()
+
+    def get_dataset_metadata(self, dataset_id: str) -> Dict[str, Any]:
+        """Get metadata for a specific dataset.
+
+        Args:
+            dataset_id: Unique dataset identifier
+
+        Returns:
+            Dataset metadata dictionary
+
+        Raises:
+            JuniperDataNotFoundError: If dataset not found
+        """
+        response = self._request("GET", f"/v1/datasets/{dataset_id}")
+        return response.json()
+
+    def download_artifact_bytes(self, dataset_id: str) -> bytes:
+        """Download the raw NPZ artifact bytes for a dataset.
+
+        Args:
+            dataset_id: ID of the dataset whose artifact to download
+
+        Returns:
+            Raw bytes of the NPZ file
+
+        Raises:
+            JuniperDataNotFoundError: If dataset not found
+        """
+        response = self._request("GET", f"/v1/datasets/{dataset_id}/artifact")
+        return response.content
+
+    def download_artifact_npz(self, dataset_id: str) -> Dict[str, np.ndarray]:
+        """Download and load an NPZ artifact for a dataset.
+
+        The returned dictionary contains numpy arrays with the standard keys:
+        - X_train, y_train: Training features and one-hot labels
+        - X_test, y_test: Test features and one-hot labels
+        - X_full, y_full: Full dataset features and one-hot labels
+
+        All arrays are float32 dtype.
+
+        Args:
+            dataset_id: ID of the dataset whose artifact to download
+
+        Returns:
+            Dictionary mapping array names to numpy arrays
+
+        Raises:
+            JuniperDataNotFoundError: If dataset not found
+        """
+        content = self.download_artifact_bytes(dataset_id)
+        npz_file = np.load(io.BytesIO(content))
+        return {key: npz_file[key] for key in npz_file.files}
+
+    def get_preview(self, dataset_id: str, n: int = 100) -> Dict[str, Any]:
+        """Get a preview of dataset samples as JSON.
+
+        Args:
+            dataset_id: ID of the dataset to preview
+            n: Number of samples to include in preview (default: 100, max: 1000)
+
+        Returns:
+            Dictionary containing n_samples, X_sample, and y_sample
+
+        Raises:
+            JuniperDataNotFoundError: If dataset not found
+        """
+        response = self._request("GET", f"/v1/datasets/{dataset_id}/preview", params={"n": n})
+        return response.json()
+
+    def delete_dataset(self, dataset_id: str) -> bool:
+        """Delete a dataset.
+
+        Args:
+            dataset_id: Unique dataset identifier
+
+        Returns:
+            True if dataset was deleted
+
+        Raises:
+            JuniperDataNotFoundError: If dataset not found
+        """
+        self._request("DELETE", f"/v1/datasets/{dataset_id}")
+        return True
+
+    def create_spiral_dataset(
+        self,
+        n_spirals: int = 2,
+        n_points_per_spiral: int = 100,
+        noise: float = 0.1,
+        seed: Optional[int] = None,
+        algorithm: str = "modern",
+        train_ratio: float = 0.8,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """Convenience method for creating spiral datasets.
+
+        Args:
+            n_spirals: Number of spiral arms (default: 2)
+            n_points_per_spiral: Points per spiral arm (default: 100)
+            noise: Noise level (default: 0.1)
+            seed: Random seed for reproducibility (optional)
+            algorithm: Generation algorithm - "modern" or "legacy_cascor" (default: "modern")
+            train_ratio: Fraction of data for training (default: 0.8)
+            **kwargs: Additional parameters passed to the generator
+
+        Returns:
+            Dataset creation response with dataset_id and metadata
+        """
+        params: Dict[str, Any] = {
+            "n_spirals": n_spirals,
+            "n_points_per_spiral": n_points_per_spiral,
+            "noise": noise,
+            "algorithm": algorithm,
+            "train_ratio": train_ratio,
+        }
+        if seed is not None:
+            params["seed"] = seed
+        params.update(kwargs)
+
+        return self.create_dataset("spiral", params)
+
+    def close(self) -> None:
+        """Close the client session and release resources."""
+        self.session.close()
+
+    def __enter__(self) -> "JuniperDataClient":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Context manager exit - closes the session."""
+        self.close()

juniper_data_client/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for the JuniperData client library."""
+
+
+class JuniperDataClientError(Exception):
+    """Base exception for all JuniperData client errors."""
+
+    pass
+
+
+class JuniperDataConnectionError(JuniperDataClientError):
+    """Raised when connection to JuniperData service fails."""
+
+    pass
+
+
+class JuniperDataTimeoutError(JuniperDataClientError):
+    """Raised when a request to JuniperData times out."""
+
+    pass
+
+
+class JuniperDataNotFoundError(JuniperDataClientError):
+    """Raised when a requested resource is not found (404)."""
+
+    pass
+
+
+class JuniperDataValidationError(JuniperDataClientError):
+    """Raised when request parameters fail validation (400/422)."""
+
+    pass
+
+
+class JuniperDataConfigurationError(JuniperDataClientError):
+    """Raised when JuniperData configuration is missing or invalid."""
+
+    pass

juniper_data_client-0.3.0.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: juniper-data-client
+Version: 0.3.0
+Summary: HTTP client for the JuniperData dataset generation service
+Author: Paul Calnon
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pcalnon/juniper-data-client
+Project-URL: Repository, https://github.com/pcalnon/juniper-data-client
+Project-URL: Documentation, https://github.com/pcalnon/juniper-data-client#readme
+Project-URL: Issues, https://github.com/pcalnon/juniper-data-client/issues
+Keywords: juniper,dataset,machine-learning,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: urllib3>=2.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.2.0; extra == "test"
+Requires-Dist: responses>=0.23.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: juniper-data-client[test]; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: flake8>=7.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.28.0; extra == "dev"
+Dynamic: license-file
+
+# juniper-data-client
+
+Python client library for the JuniperData REST API.
+
+## Overview
+
+`juniper-data-client` provides a simple, robust client for interacting with the JuniperData dataset generation service. It is the official client library used by both JuniperCascor (neural network backend) and JuniperCanopy (web dashboard).
+
+## Installation
+
+```bash
+pip install juniper-data-client
+```
+
+Or install from source:
+
+```bash
+cd juniper-data-client
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from juniper_data_client import JuniperDataClient
+
+# Create client (default: localhost:8100)
+client = JuniperDataClient("http://localhost:8100")
+
+# Check service health
+health = client.health_check()
+print(f"Service status: {health['status']}")
+
+# Create a spiral dataset
+result = client.create_spiral_dataset(
+    n_spirals=2,
+    n_points_per_spiral=100,
+    noise=0.1,
+    seed=42,
+)
+dataset_id = result["dataset_id"]
+print(f"Created dataset: {dataset_id}")
+
+# Download as numpy arrays
+arrays = client.download_artifact_npz(dataset_id)
+X_train = arrays["X_train"]  # (160, 2) float32
+y_train = arrays["y_train"]  # (160, 2) float32 one-hot
+X_test = arrays["X_test"]    # (40, 2) float32
+y_test = arrays["y_test"]    # (40, 2) float32 one-hot
+
+print(f"Training samples: {len(X_train)}")
+print(f"Test samples: {len(X_test)}")
+```
+
+## Features
+
+- **Simple API**: Easy-to-use methods for all JuniperData endpoints
+- **Automatic Retries**: Built-in retry logic for transient failures (429, 5xx)
+- **Connection Pooling**: Efficient HTTP connection reuse
+- **Type Hints**: Full type annotations for IDE support
+- **Context Manager**: Resource cleanup with `with` statement
+- **Custom Exceptions**: Granular error handling
+
+## Usage Examples
+
+### Context Manager
+
+```python
+with JuniperDataClient("http://localhost:8100") as client:
+    result = client.create_spiral_dataset(seed=42)
+    arrays = client.download_artifact_npz(result["dataset_id"])
+# Session automatically closed
+```
+
+### Wait for Service
+
+```python
+client = JuniperDataClient("http://localhost:8100")
+
+# Wait up to 30 seconds for service to be ready
+if client.wait_for_ready(timeout=30):
+    result = client.create_spiral_dataset(seed=42)
+else:
+    print("Service not available")
+```
+
+### Custom Parameters
+
+```python
+# Using the general create_dataset method
+result = client.create_dataset(
+    generator="spiral",
+    params={
+        "n_spirals": 3,
+        "n_points_per_spiral": 200,
+        "noise": 0.2,
+        "seed": 12345,
+        "algorithm": "legacy_cascor",
+        "radius": 10.0,
+    }
+)
+```
+
+### Error Handling
+
+```python
+from juniper_data_client import (
+    JuniperDataClient,
+    JuniperDataConnectionError,
+    JuniperDataNotFoundError,
+    JuniperDataValidationError,
+)
+
+client = JuniperDataClient()
+
+try:
+    result = client.create_dataset("spiral", {"n_spirals": -1})
+except JuniperDataValidationError as e:
+    print(f"Invalid parameters: {e}")
+except JuniperDataConnectionError as e:
+    print(f"Service unreachable: {e}")
+```
+
+### PyTorch Integration
+
+```python
+import torch
+from juniper_data_client import JuniperDataClient
+
+client = JuniperDataClient()
+result = client.create_spiral_dataset(seed=42)
+arrays = client.download_artifact_npz(result["dataset_id"])
+
+# Convert to PyTorch tensors
+X_train = torch.from_numpy(arrays["X_train"])  # torch.float32
+y_train = torch.from_numpy(arrays["y_train"])  # torch.float32
+```
+
+## API Reference
+
+### JuniperDataClient
+
+| Method                              | Description                            |
+| ----------------------------------- | -------------------------------------- |
+| `health_check()`                    | Get service health status              |
+| `is_ready()`                        | Check if service is ready (boolean)    |
+| `wait_for_ready(timeout)`           | Wait for service to become ready       |
+| `list_generators()`                 | List available generators              |
+| `get_generator_schema(name)`        | Get parameter schema for generator     |
+| `create_dataset(generator, params)` | Create dataset with generator          |
+| `create_spiral_dataset(**kwargs)`   | Convenience method for spiral datasets |
+| `list_datasets(limit, offset)`      | List dataset IDs                       |
+| `get_dataset_metadata(id)`          | Get dataset metadata                   |
+| `download_artifact_npz(id)`         | Download NPZ as dict of arrays         |
+| `download_artifact_bytes(id)`       | Download raw NPZ bytes                 |
+| `get_preview(id, n)`                | Get JSON preview of samples            |
+| `delete_dataset(id)`                | Delete a dataset                       |
+| `close()`                           | Close the client session               |
+
+### Exceptions
+
+| Exception                    | Description                   |
+| ---------------------------- | ----------------------------- |
+| `JuniperDataClientError`     | Base exception for all errors |
+| `JuniperDataConnectionError` | Connection to service failed  |
+| `JuniperDataTimeoutError`    | Request timed out             |
+| `JuniperDataNotFoundError`   | Resource not found (404)      |
+| `JuniperDataValidationError` | Invalid parameters (400/422)  |
+
+## NPZ Artifact Schema
+
+Downloaded artifacts contain the following numpy arrays (all `float32`):
+
+| Key       | Shape                  | Description                   |
+| --------- | ---------------------- | ----------------------------- |
+| `X_train` | `(n_train, 2)`         | Training features             |
+| `y_train` | `(n_train, n_classes)` | Training labels (one-hot)     |
+| `X_test`  | `(n_test, 2)`          | Test features                 |
+| `y_test`  | `(n_test, n_classes)`  | Test labels (one-hot)         |
+| `X_full`  | `(n_total, 2)`         | Full dataset features         |
+| `y_full`  | `(n_total, n_classes)` | Full dataset labels (one-hot) |
+
+## Configuration
+
+| Parameter        | Default                 | Description                        |
+| ---------------- | ----------------------- | ---------------------------------- |
+| `base_url`       | `http://localhost:8100` | JuniperData service URL            |
+| `timeout`        | `30`                    | Request timeout in seconds         |
+| `retries`        | `3`                     | Number of retry attempts           |
+| `backoff_factor` | `0.5`                   | Backoff multiplier between retries |
+
+## Requirements
+
+- Python >=3.11
+- numpy >=1.24.0
+- requests >=2.28.0
+- urllib3 >=2.0.0
+
+## License
+
+MIT License - Copyright (c) 2024-2026 Paul Calnon
+
+## See Also
+
+- [JuniperData](https://github.com/pcalnon/Juniper/tree/main/JuniperData)
+- [JuniperCascor](https://github.com/pcalnon/Juniper/tree/main/JuniperCascor)
+- [JuniperCanopy](https://github.com/pcalnon/Juniper/tree/main/JuniperCanopy)

juniper_data_client-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+juniper_data_client/__init__.py,sha256=qHsZY6awA6GZmcksi7GGGNKBrbsKuYo6ukR4LAs-RgI,809
+juniper_data_client/client.py,sha256=Fkblt8BrMeJ0S9EoVXExlADcYVISXf9JaBsVQE1Wddc,13904
+juniper_data_client/exceptions.py,sha256=PiZynlAebexJl-rm5x9yPzGwc9oSshhxSpgL0tI-Zho,844
+juniper_data_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+juniper_data_client-0.3.0.dist-info/licenses/LICENSE,sha256=dyw35rgU8rmukcWEiETN0fwCwKz7donu9vGNP5LgBW8,1073
+juniper_data_client-0.3.0.dist-info/METADATA,sha256=3jy6AEsSFiSUdE2Gr2k8ii7u1fO7kvWBJaDoZ4n6mdc,8670
+juniper_data_client-0.3.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+juniper_data_client-0.3.0.dist-info/top_level.txt,sha256=JKjJnFGsHKzI9pOYlHh3uS4LzBR3lQ9q13mKfHrGdu0,20
+juniper_data_client-0.3.0.dist-info/RECORD,,

juniper_data_client-0.3.0.dist-info/WHEEL

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

juniper_data_client-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Paul Calnon
+
+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.

juniper_data_client-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+juniper_data_client