orb-cloud-client 1.2.1__py3-none-any.whl

orb_cloud_client/__init__.py

@@ -0,0 +1,15 @@
+"""Orb Cloud API Client
+
+A Python client library for interacting with the Orb Cloud API.
+"""
+
+try:
+    from .client import OrbCloudClient
+    from .models import *
+except ImportError:
+    # Handle case where package is not installed
+    from orb_cloud_client.client import OrbCloudClient
+    from orb_cloud_client.models import *
+
+__version__ = "1.0.0"
+__all__ = ["OrbCloudClient"]

orb_cloud_client/client.py

@@ -0,0 +1,107 @@
+"""
+Simple HTTP client for Orb Cloud API.
+"""
+
+import httpx
+from typing import Dict, Any, Optional, List
+
+try:
+    from .models import Device, TempDatasetsRequest, Organization
+except ImportError:
+    # Handle direct execution
+    from models import Device, TempDatasetsRequest, Organization
+
+class OrbCloudClientBase(object):
+    def __init__(self, base_url: str = "https://panel.orb.net", token: Optional[str] = None):
+        self.base_url = base_url.rstrip('/')
+        self.headers = {"Content-Type": "application/json"}
+        if token:
+            self.headers["Authorization"] = f"Bearer {token}"
+
+    def _get_organization_devices(self, response: httpx.Response) -> List[Device]:
+        """Get list of devices for the organization from a response."""
+        response.raise_for_status()
+        return [Device(**device) for device in response.json()]
+
+    def _configure_temporary_datasets(self, response: httpx.Response) -> Dict[str, Any]:
+        """Process the response for configuring temporary datasets."""
+        response.raise_for_status()
+        return response.json()
+
+    def _get_organizations(self, response: httpx.Response) -> List[Organization]:
+        """Get list of organizations accessible with the provided token."""
+        response.raise_for_status()
+        return [Organization(**org) for org in response.json()]
+
+class OrbCloudClient(OrbCloudClientBase):
+    """Simple HTTP client for Orb Cloud API."""
+
+    def __init__(self, base_url: str = "https://panel.orb.net", token: Optional[str] = None):
+        super().__init__(base_url, token)
+        self.client = httpx.Client(base_url=self.base_url, headers=self.headers)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+
+    def close(self):
+        """Close the HTTP client."""
+        self.client.close()
+
+    def get_organization_devices(self, organization_id: str) -> List[Device]:
+        """Get list of devices for the organization."""
+        response = self.client.get(f"/api/v2/organization/{organization_id}/devices")
+        return self._get_organization_devices(response)
+
+    def configure_temporary_datasets(self, device_id: str, temp_datasets_request: TempDatasetsRequest) -> Dict[str, Any]:
+        """Enable temporary data reporting to a custom endpoint with a given config for a specified duration."""
+        response = self.client.post(f"/api/v1/device/{device_id}/temp-datasets", json=temp_datasets_request.model_dump())
+        return self._configure_temporary_datasets(response)
+
+    def get_organizations(self) -> List[Organization]:
+        """Get list of organizations accessible with the provided token."""
+        response = self.client.get("/api/v2/organizations")
+        return self._get_organizations(response)
+
+    def request(self, method: str, endpoint: str, **kwargs) -> httpx.Response:
+        """Make a raw HTTP request for any other endpoints."""
+        return self.client.request(method, endpoint, **kwargs)
+
+
+class OrbCloudClientAsync(OrbCloudClientBase):
+    """Simple async HTTP client for Orb Cloud API."""
+
+    def __init__(self, base_url: str = "https://panel.orb.net", token: Optional[str] = None):
+        super().__init__(base_url, token)
+        self.client = httpx.AsyncClient(base_url=self.base_url, headers=self.headers)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.client.aclose()
+
+    async def close(self):
+        """Close the HTTP client."""
+        await self.client.aclose()
+
+    async def get_organization_devices(self, organization_id: str) -> List[Device]:
+        """Get list of devices for the organization."""
+        response = await self.client.get(f"/api/v2/organization/{organization_id}/devices")
+        return self._get_organization_devices(response)
+
+    async def configure_temporary_datasets(self, device_id: str, temp_datasets_request: TempDatasetsRequest) -> Dict[str, Any]:
+        """Enable temporary data reporting to a custom endpoint with a given config for a specified duration."""
+        response = await self.client.post(f"/api/v1/device/{device_id}/temp-datasets", json=temp_datasets_request.model_dump())
+        return self._configure_temporary_datasets(response)
+
+    async def get_organizations(self) -> List[Organization]:
+        """Get list of organizations accessible with the provided token."""
+        response = await self.client.get("/api/v2/organizations")
+        return self._get_organizations(response)
+
+    async def request(self, method: str, endpoint: str, **kwargs) -> httpx.Response:
+        """Make a raw async HTTP request for any other endpoints."""
+        return await self.client.request(method, endpoint, **kwargs)

orb_cloud_client/example.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+Example usage of the Orb Cloud API Client.
+
+This example demonstrates:
+1. Getting a list of devices for an organization
+2. Displaying the devices and letting the user select one
+3. Asking the user for a URL to push data to
+4. Configuring temporary datasets for the selected device with data push
+"""
+
+import os
+import sys
+from typing import Optional, List
+
+# Add the client to the path (for running this example directly)
+sys.path.insert(0, os.path.dirname(__file__))
+
+from client import OrbCloudClient
+from models import TempDatasetsRequest, Datasets, DataPush, Device
+
+
+def get_and_display_devices(client: OrbCloudClient, organization_id: str) -> List[Device]:
+    """Get and display all devices for the organization."""
+    print(f"Getting devices for organization: {organization_id}")
+    
+    try:
+        devices = client.get_organization_devices(organization_id)
+        print(f"Found {len(devices)} devices:\n")
+        
+        for i, device in enumerate(devices, 1):
+            connection_status = "Connected" if device.is_connected.value == 1 else "Disconnected"
+            print(f"{i:2}. {device.name}")
+            print(f"    orb_id: {device.orb_id}")
+            print(f"    status: {connection_status}")
+            print()
+        
+        return devices
+        
+    except Exception as e:
+        print(f"Error getting devices: {e}")
+        return []
+
+
+def select_device(devices: List[Device]) -> Optional[Device]:
+    """Allow user to select a device from the list."""
+    if not devices:
+        print("No devices available to select from.")
+        return None
+    
+    while True:
+        try:
+            choice = input(f"Select a device (1-{len(devices)}) or 'q' to quit: ").strip()
+            
+            if choice.lower() == 'q':
+                print("Exiting...")
+                return None
+            
+            device_index = int(choice) - 1
+            
+            if 0 <= device_index < len(devices):
+                selected_device = devices[device_index]
+                print(f"Selected: {selected_device.name}")
+                return selected_device
+            else:
+                print(f"Please enter a number between 1 and {len(devices)}")
+                
+        except ValueError:
+            print("Please enter a valid number or 'q' to quit")
+        except KeyboardInterrupt:
+            print("\nExiting...")
+            return None
+
+
+def get_push_url() -> Optional[str]:
+    """Get the push URL from the user."""
+    while True:
+        try:
+            url = input("\nEnter the URL to push data to (or 'q' to quit): ").strip()
+            
+            if url.lower() == 'q':
+                print("Exiting...")
+                return None
+            
+            if not url:
+                print("Please enter a valid URL")
+                continue
+            
+            # Basic URL validation
+            if not (url.startswith('http://') or url.startswith('https://')):
+                print("URL should start with http:// or https://")
+                continue
+            
+            print(f"Will push data to: {url}")
+            return url
+            
+        except KeyboardInterrupt:
+            print("\nExiting...")
+            return None
+
+
+def configure_temp_datasets(client: OrbCloudClient, device_id: str, push_url: str) -> bool:
+    """Configure temporary datasets for the specified device."""
+    print(f"Configuring temporary datasets for device: {device_id}")
+    
+    # Create the temporary datasets configuration
+    temp_config = TempDatasetsRequest(
+        duration="5m",  # Run for 5 minutes
+        datasets_config=Datasets(
+            enabled=True,
+            datasets=["responsiveness_1s", "scores_1s"],  # Collect these datasets
+            push=DataPush(
+                enabled=True,
+                url=push_url,  # Use the user-provided URL
+                datasets=["responsiveness_1s", "scores_1s"],
+                format="json",
+                interval_ms=500 # Push new data every 500ms (when available)
+            )
+        )
+    )
+    
+    try:
+        result = client.configure_temporary_datasets(device_id, temp_config)
+        print(f"Temporary datasets configured successfully: {result}")
+        return True
+        
+    except Exception as e:
+        print(f"Error configuring temporary datasets: {e}")
+        return False
+
+
+def main():
+    """Main example function."""
+    # Get configuration from environment variables
+    api_token = os.getenv("ORB_API_TOKEN")
+    organization_id = os.getenv("ORB_ORGANIZATION_ID")
+    
+    if not api_token:
+        print("Error: Please set ORB_API_TOKEN environment variable")
+        sys.exit(1)
+    
+    if not organization_id:
+        print("Error: Please set ORB_ORGANIZATION_ID environment variable")
+        sys.exit(1)
+    
+    print("Orb Cloud API Client Example")
+    print("=" * 30)
+    
+    # Create the client
+    with OrbCloudClient(token=api_token) as client:
+        # Step 1: Get and display all devices
+        devices = get_and_display_devices(client, organization_id)
+        
+        if not devices:
+            print("No devices found. Exiting.")
+            sys.exit(1)
+        
+        # Step 2: Let user select a device
+        selected_device = select_device(devices)
+        
+        if not selected_device:
+            sys.exit(0)
+        
+        # Step 3: Get the push URL from user
+        push_url = get_push_url()
+        
+        if not push_url:
+            sys.exit(0)
+        
+        # Step 4: Configure temporary datasets for the selected device
+        success = configure_temp_datasets(client, selected_device.orb_id, push_url)
+        
+        if success:
+            print("\nExample completed successfully!")
+            print(f"Device '{selected_device.name}' is now configured to collect temporary datasets.")
+            print(f"Data will be pushed to: {push_url}")
+        else:
+            print("\nExample failed to configure temporary datasets.")
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

orb_cloud_client/example_async.py

@@ -0,0 +1,47 @@
+from client import OrbCloudClientAsync
+import asyncio
+import os
+
+
+async def main():
+    """
+    Example of using the OrbCloudClientAsync to fetch organization devices.
+
+    Requires ORB_CLOUD_TOKEN and ORB_CLOUD_ORGANIZATION_ID environment variables to be set.
+    """
+    token = os.environ.get("ORB_CLOUD_TOKEN")
+
+    if not token:
+        print("Please set ORB_CLOUD_TOKEN environment variables.")
+        return
+
+    print("Getting organization...")
+    async with OrbCloudClientAsync(token=token) as client:
+        organizations = await client.get_organizations()
+        if not organizations:
+            print("No organizations found for this token.")
+            return
+
+        print("Organizations found:")
+        for org in organizations:
+            print(f"  - ID: {org.organization_id}, Name: {org.name}")
+
+            print(f"Fetching devices for organization: {org.organization_id}")
+            try:
+                devices = await client.get_organization_devices(org.organization_id)
+                if not devices:
+                    print("No devices found for this organization.")
+                    return
+
+                print("Devices found:")
+                for device in devices:
+                    print(f"  - ID: {device.orb_id}, Name: {device.name}")
+            except Exception as e:
+                print(f"An error occurred: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+

orb_cloud_client/models.py

@@ -0,0 +1,245 @@
+# generated by datamodel-codegen:
+#   filename:  openapi.yaml
+#   timestamp: 2025-10-16T14:05:24+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class IsConnected(Enum):
+    integer_0 = 0
+    integer_1 = 1
+
+
+class GeoIPInfo(BaseModel):
+    city: Optional[str] = Field(None, examples=['Kirkland'])
+    state: Optional[str] = Field(None, examples=['Washington'])
+    country: Optional[str] = Field(None, examples=['United States'])
+    isp_name: Optional[str] = Field(None, examples=['Comcast Cable'])
+    latitude: Optional[float] = Field(None, examples=[47.6784])
+    longitude: Optional[float] = Field(None, examples=[-122.1857])
+    country_code: Optional[str] = Field(None, examples=['US'])
+
+
+class DeviceInfo(BaseModel):
+    name: Optional[str] = Field(None, examples=['hardy-nca1515'])
+    version: Optional[str] = Field(None, examples=['v1.2.3'])
+    cpu_count: Optional[int] = Field(None, examples=[4])
+    full_name: Optional[str] = Field(
+        None, description='device full hostname', examples=['hardy-nca1515']
+    )
+    operating_system: Optional[str] = Field(None, examples=['linux'])
+
+
+class NetworkInterface(BaseModel):
+    name: Optional[str] = Field(None, examples=[''])
+    type: Optional[str] = Field(None, examples=['Ethernet'])
+    local_ip: Optional[str] = Field(
+        None,
+        description='Local IP address of the network interface',
+        examples=['192.168.207.172'],
+    )
+    mac_address: Optional[str] = Field(
+        None,
+        description='MAC address of the network interface',
+        examples=['00:90:0b:a5:de:2a'],
+    )
+
+
+class OrbScore(BaseModel):
+    score: Optional[float] = Field(
+        None, description='Raw score value', examples=[0.8283297399160232]
+    )
+    display: Optional[int] = Field(
+        None, description='Display score (0-100)', examples=[91]
+    )
+    included: Optional[bool] = Field(
+        None,
+        description='Whether there are enough measurements on the subject score that it is conclusive',
+        examples=[True],
+    )
+    value: Optional[float] = Field(
+        None,
+        description='Raw measurement value (present in leaf components)',
+        examples=[38965.44888204175],
+    )
+    components: Optional[Dict[str, OrbScore]] = Field(
+        None, description='Score components breakdown (nested OrbScore objects)'
+    )
+    duration_ms: Optional[int] = Field(
+        None, description='Duration of measurement in milliseconds', examples=[60000]
+    )
+    score_version: Optional[str] = Field(
+        None, description='Version of scoring algorithm', examples=['1.2.0']
+    )
+
+
+class DataPush(BaseModel):
+    enabled: bool = Field(
+        ..., description='Whether data push is enabled', examples=[True]
+    )
+    identifiable: Optional[bool] = Field(
+        None, description='Whether data should be identifiable', examples=[True]
+    )
+    datasets: Optional[List[str]] = Field(
+        None,
+        description='List of datasets to push',
+        examples=[['responsiveness_1s', 'speed_results']],
+    )
+    url: Optional[str] = Field(
+        None,
+        description='URL to push data to',
+        examples=['https://api.example.com/data'],
+    )
+    format: Optional[str] = Field(
+        None, description='Data format for pushing', examples=['json']
+    )
+    buffer_kb: Optional[int] = Field(
+        None, description='Buffer size in KB', examples=[64]
+    )
+    interval_ms: Optional[int] = Field(
+        None, description='Push interval in milliseconds', examples=[5000]
+    )
+
+
+class DataAPI(BaseModel):
+    enabled: bool = Field(
+        ..., description='Whether data API is enabled', examples=[True]
+    )
+    identifiable: Optional[bool] = Field(
+        None, description='Whether data should be identifiable', examples=[True]
+    )
+    datasets: Optional[List[str]] = Field(
+        None,
+        description='List of datasets to expose via API',
+        examples=[['responsiveness_1s', 'speed_results']],
+    )
+    api_key: Optional[str] = Field(
+        None,
+        description='API key for accessing the data API',
+        examples=['your-api-key-here'],
+    )
+    port: Optional[int] = Field(
+        None, description='Port for the data API', examples=[8080]
+    )
+    buffer: Optional[int] = Field(None, description='Buffer size', examples=[1000])
+
+
+class Error(BaseModel):
+    message: str = Field(
+        ..., description='Error message', examples=['Invalid organization ID']
+    )
+    code: Optional[str] = Field(
+        None, description='Error code', examples=['INVALID_ORG_ID']
+    )
+
+
+class AccountConfigEntitlements(BaseModel):
+    entitlements: Optional[List[str]] = None
+
+
+class AccountPlanLimits(BaseModel):
+    deployment_tokens: Optional[int] = None
+    devices: Optional[int] = None
+    users: Optional[int] = None
+
+
+class SummaryTags(BaseModel):
+    geoip: Optional[GeoIPInfo] = None
+    device_info: Optional[DeviceInfo] = None
+    network_interface: Optional[NetworkInterface] = None
+
+
+class Datasets(BaseModel):
+    enabled: bool = Field(
+        ..., description='Whether datasets are enabled', examples=[True]
+    )
+    datasets: Optional[List[str]] = Field(
+        None,
+        description='List of datasets to collect',
+        examples=[['responsiveness_1s', 'speed_results']],
+    )
+    cloud_push: Optional[DataPush] = None
+    push: Optional[DataPush] = None
+    api: Optional[DataAPI] = None
+
+
+class AccountPlan(BaseModel):
+    config: Optional[AccountConfigEntitlements] = None
+    features: Optional[List[str]] = None
+    limits: Optional[AccountPlanLimits] = None
+
+
+class DeviceSummary(BaseModel):
+    tags: Optional[SummaryTags] = None
+    version: Optional[str] = Field(
+        None, description='Summary version', examples=['0.1.0']
+    )
+    orb_score: Optional[OrbScore] = None
+    created_ts: Optional[int] = Field(
+        None, description='Timestamp when summary was created', examples=[1757391432134]
+    )
+    orb_scores: Optional[List[OrbScore]] = Field(
+        None, description='Array of Orb scores for different time windows'
+    )
+
+
+class TempDatasetsRequest(BaseModel):
+    duration: str = Field(
+        ..., description='Duration for temporary dataset configuration', examples=['1h']
+    )
+    datasets_config: Datasets
+
+
+class Organization(BaseModel):
+    customer_id: Optional[str] = None
+    name: Optional[str] = None
+    organization_id: Optional[str] = None
+    plan: Optional[AccountPlan] = None
+    subscription_id: Optional[str] = None
+
+
+class Device(BaseModel):
+    orb_id: str = Field(
+        ...,
+        description='Unique Orb device identifier',
+        examples=['cjwbntmuy97ta4rx3mbrjf2gj8j7'],
+    )
+    name: str = Field(..., description='Device name', examples=['hardy-house'])
+    is_connected: IsConnected = Field(
+        ...,
+        description='Connection status (0 = disconnected, 1 = connected)',
+        examples=[1],
+    )
+    is_connected_updated_at: Optional[int] = Field(
+        None,
+        description='Timestamp when connection status was last updated',
+        examples=[1757368500851],
+    )
+    can_notify: Optional[bool] = Field(
+        None, description='Whether the device can send notifications', examples=[False]
+    )
+    summary: DeviceSummary
+    created_ts: Optional[int] = Field(
+        None, description='Timestamp when device was created', examples=[1757368560803]
+    )
+    tags: Optional[List[str]] = Field(
+        None, description='Device tags', examples=[['dt=Default Configuration']]
+    )
+    config: Optional[Dict[str, List[str]]] = Field(
+        None,
+        description='Device configuration user overrides (map of strings to arrays of strings)',
+        examples=[
+            {
+                'datasets.datasets': ['responsiveness_1s', 'speed_results'],
+                'datasets.cloud_push': ['identifiable=true', 'responsiveness_1s'],
+            }
+        ],
+    )
+
+
+OrbScore.model_rebuild()

orb_cloud_client-1.2.1.dist-info/METADATA

@@ -0,0 +1,426 @@
+Metadata-Version: 2.4
+Name: orb-cloud-client
+Version: 1.2.1
+Summary: Python client library for Orb Cloud API
+Author-email: Orb Networks <support@orb.net>
+License: MIT
+Project-URL: Documentation, https://api.orb.net/docs
+Project-URL: Homepage, https://github.com/orbforge/orb-cloud
+Project-URL: Repository, https://github.com/orbforge/orb-cloud
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build>=1.2.2.post1
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Orb Cloud API Client
+
+A Python client library for interacting with the Orb Cloud API. This package provides a simple interface to manage devices, configure data collection, and interact with Orb Cloud services.
+
+## Installation
+
+Install the package from the wheel file:
+
+```bash
+pip install orb-cloud-client
+```
+
+The package will automatically install its dependencies:
+- `httpx>=0.24.0` (for HTTP requests)
+- `pydantic>=2.0.0` (for data models)
+
+## Quick Start
+
+```python
+from orb_cloud_client import OrbCloudClient
+
+# Create client
+client = OrbCloudClient(token="your-api-token")
+
+# Get organization devices
+devices = client.get_organization_devices("your-org-id")
+print(f"Found {len(devices)} devices")
+
+# Use as context manager (recommended)
+with OrbCloudClient(token="your-api-token") as client:
+    devices = client.get_organization_devices("your-org-id")
+```
+
+## API Reference
+
+### OrbCloudClient
+
+#### Constructor
+
+```python
+OrbCloudClient(base_url="https://panel.orb.net", token=None)
+```
+
+**Parameters:**
+- `base_url` (str, optional): API base URL. Defaults to production environment.
+- `token` (str, optional): Bearer authentication token.
+
+#### Methods
+
+##### get_organization_devices(organization_id)
+
+Get a list of all devices for an organization.
+
+```python
+devices = client.get_organization_devices("org-123")
+```
+
+**Parameters:**
+- `organization_id` (str): The organization ID
+
+**Returns:**
+- `List[Device]`: List of Device objects
+
+**Example:**
+```python
+devices = client.get_organization_devices("org-123")
+for device in devices:
+    print(f"Device: {device.name} (ID: {device.id})")
+    print(f"  Status: {'Connected' if device.is_connected else 'Disconnected'}")
+    print(f"  Location: {device.geo_ip_info.city}, {device.geo_ip_info.state}")
+```
+
+##### configure_temporary_datasets(device_id, temp_datasets_request)
+
+Configure temporary data collection for a device with custom data push endpoint.
+
+```python
+from orb_cloud_client.models import TempDatasetsRequest, Datasets, DataPush
+
+temp_config = TempDatasetsRequest(
+    duration="5m",  # Run for 5 minutes
+    datasets_config=Datasets(
+        enabled=True,
+        datasets=["responsiveness_1s", "scores_1s"],  # Collect these datasets
+        push=DataPush(
+            enabled=True,
+            url="https://your-endpoint.com/data",  # Your webhook URL
+            datasets=["responsiveness_1s", "scores_1s"],
+            format="json",
+            interval_ms=500  # Push new data every 500ms (when available)
+        )
+    )
+)
+
+result = client.configure_temporary_datasets("device-456", temp_config)
+```
+
+**Parameters:**
+- `device_id` (str): The device ID
+- `temp_datasets_request` (TempDatasetsRequest): Configuration object
+
+**Returns:**
+- `Dict[str, Any]`: API response
+
+##### request(method, endpoint, **kwargs)
+
+Make a custom HTTP request to any API endpoint.
+
+```python
+response = client.request("GET", "/api/v2/custom-endpoint")
+data = response.json()
+```
+
+**Parameters:**
+- `method` (str): HTTP method (GET, POST, PUT, DELETE, etc.)
+- `endpoint` (str): API endpoint path
+- `**kwargs`: Additional arguments passed to httpx
+
+**Returns:**
+- `httpx.Response`: Raw HTTP response
+
+##### close()
+
+Close the HTTP client connection.
+
+```python
+client.close()
+```
+
+### Data Models
+
+All API models are Pydantic models with full type validation and serialization.
+
+#### Device
+
+Represents an Orb device with all its properties.
+
+```python
+from orb_cloud_client.models import Device
+
+# Device properties
+device.id                    # str: Device UUID
+device.name                  # str: Device name
+device.is_connected          # IsConnected: Connection status (0 or 1)
+device.last_seen             # Optional[str]: Last seen timestamp
+device.geo_ip_info          # Optional[GeoIPInfo]: Geographic information
+device.device_info          # Optional[DeviceInfo]: Hardware/software info
+device.network_interfaces   # Optional[List[NetworkInterface]]: Network info
+device.orb_score           # Optional[OrbScore]: Performance metrics
+device.summary             # Optional[DeviceSummary]: Device summary
+```
+
+#### TempDatasetsRequest
+
+Configuration for temporary data collection.
+
+```python
+from orb_cloud_client.models import TempDatasetsRequest, Datasets, DataPush
+
+temp_request = TempDatasetsRequest(
+    duration="5m",                    # Duration (e.g., "5m", "1h", "30m", "2h")
+    datasets_config=Datasets(
+        enabled=True,
+        datasets=["responsiveness_1s", "scores_1s"],  # Dataset types to collect
+        push=DataPush(                # Data push configuration
+            enabled=True,
+            url="https://your-server.com/webhook",
+            datasets=["responsiveness_1s", "scores_1s"],
+            format="json",
+            interval_ms=500           # Push interval in milliseconds
+        )
+    )
+)
+```
+
+#### Datasets
+
+Data collection configuration with push settings.
+
+```python
+datasets = Datasets(
+    enabled=True,                     # bool: Enable data collection
+    datasets=[                        # List[str]: Dataset types to collect
+        "responsiveness_1s",
+        "scores_1s",
+        "latency_1s",
+        "throughput_1s"
+    ],
+    push=DataPush(                    # Optional: Push configuration
+        enabled=True,
+        url="https://api.example.com/webhook",
+        datasets=["responsiveness_1s", "scores_1s"],
+        format="json",                # Data format
+        interval_ms=500               # Push interval in milliseconds
+    )
+)
+```
+
+#### DataPush
+
+Configuration for pushing data to external endpoints.
+
+```python
+data_push = DataPush(
+    enabled=True,                             # bool: Enable data pushing
+    url="https://api.example.com/webhook",    # str: Webhook URL
+    datasets=["responsiveness_1s", "scores_1s"],  # List[str]: Datasets to push
+    format="json",                            # str: Data format
+    interval_ms=500                           # int: Push interval in milliseconds
+)
+```
+
+#### GeoIPInfo
+
+Geographic information from device IP address.
+
+```python
+geo_info.city           # Optional[str]: City name
+geo_info.state          # Optional[str]: State/region
+geo_info.country        # Optional[str]: Country name
+geo_info.country_code   # Optional[str]: Country code (e.g., "US")
+geo_info.isp_name       # Optional[str]: Internet service provider
+geo_info.latitude       # Optional[float]: Latitude coordinate
+geo_info.longitude      # Optional[float]: Longitude coordinate
+```
+
+#### DeviceInfo
+
+Device hardware and software information.
+
+```python
+device_info.name               # Optional[str]: Device hostname
+device_info.version            # Optional[str]: Software version
+device_info.cpu_count          # Optional[int]: Number of CPU cores
+device_info.full_name          # Optional[str]: Full hostname
+device_info.operating_system   # Optional[str]: OS name
+```
+
+#### NetworkInterface
+
+Network interface information.
+
+```python
+interface.name          # Optional[str]: Interface name
+interface.type          # Optional[str]: Interface type (e.g., "Ethernet")
+interface.local_ip      # Optional[str]: Local IP address
+interface.mac_address   # Optional[str]: MAC address
+```
+
+## Usage Examples
+
+### Basic Device Management
+
+```python
+from orb_cloud_client import OrbCloudClient
+
+with OrbCloudClient(token="your-token") as client:
+    # Get all devices
+    devices = client.get_organization_devices("org-123")
+
+    # Filter connected devices
+    connected_devices = [d for d in devices if d.is_connected == 1]
+
+    # Find specific device
+    target_device = next((d for d in devices if "hardy" in d.name.lower()), None)
+    if target_device:
+        print(f"Found device: {target_device.name}")
+```
+
+### Configure Data Collection
+
+```python
+from orb_cloud_client import OrbCloudClient
+from orb_cloud_client.models import TempDatasetsRequest, Datasets, DataPush
+
+with OrbCloudClient(token="your-token") as client:
+    # Configure temporary datasets with custom endpoint
+    config = TempDatasetsRequest(
+        duration="5m",  # Run for 5 minutes
+        datasets_config=Datasets(
+            enabled=True,
+            datasets=["responsiveness_1s", "scores_1s"],
+            push=DataPush(
+                enabled=True,
+                url="https://your-analytics.com/orb-data",
+                datasets=["responsiveness_1s", "scores_1s"],
+                format="json",
+                interval_ms=500  # Push every 500ms when data available
+            )
+        )
+    )
+
+    result = client.configure_temporary_datasets("device-456", config)
+    print("Configuration successful:", result)
+```
+
+### Error Handling
+
+```python
+from orb_cloud_client import OrbCloudClient
+import httpx
+
+with OrbCloudClient(token="your-token") as client:
+    try:
+        devices = client.get_organization_devices("org-123")
+    except httpx.HTTPStatusError as e:
+        print(f"HTTP error {e.response.status_code}: {e.response.text}")
+    except httpx.RequestError as e:
+        print(f"Request error: {e}")
+```
+
+### Working with Device Data
+
+```python
+from orb_cloud_client import OrbCloudClient
+
+with OrbCloudClient(token="your-token") as client:
+    devices = client.get_organization_devices("org-123")
+
+    for device in devices:
+        print(f"\n--- {device.name} ---")
+        print(f"ID: {device.id}")
+        print(f"Connected: {'Yes' if device.is_connected else 'No'}")
+
+        if device.geo_ip_info:
+            print(f"Location: {device.geo_ip_info.city}, {device.geo_ip_info.state}")
+            print(f"ISP: {device.geo_ip_info.isp_name}")
+
+        if device.device_info:
+            print(f"OS: {device.device_info.operating_system}")
+            print(f"Version: {device.device_info.version}")
+
+        if device.network_interfaces:
+            for interface in device.network_interfaces:
+                print(f"Interface: {interface.name} ({interface.local_ip})")
+```
+
+## Interactive Example
+
+The package includes an interactive example that demonstrates the complete workflow:
+
+```bash
+export ORB_API_TOKEN="your-api-token"
+export ORB_ORGANIZATION_ID="your-org-id"
+python3 -m orb_cloud_client.example
+```
+
+The example will:
+1. Fetch and display all devices
+2. Configure temporary datasets for the selected device
+
+
+See `example.py` for example code.
+
+
+## Available Dataset Types
+
+Common dataset types you can collect:
+- `responsiveness_{timeframe}` - time-binned responsiveness (example `responiveness_1s`, `responsiveness_15s`)
+- `scores_{timeframe}` - time-binned scores (example `scores_1s`, `scores_1m`)
+- `speed_results` - Result-level speed measurements
+- `web_responsiveness_results` - Result-level DNS resolve and TTFB measurements
+
+## Authentication
+
+The client uses Bearer token authentication. Get your API token from the Orb Cloud dashboard and pass it to the client constructor:
+
+```python
+client = OrbCloudClient(token="your-bearer-token")
+```
+
+## Environment Support
+
+- **Staging**: `https://api.staging.orb.net` (default)
+- **Production**: `https://api.orb.net`
+
+```python
+# Production client
+client = OrbCloudClient(
+    base_url="https://api.orb.net",
+    token="your-token"
+)
+```
+
+## Requirements
+
+- Python 3.8+
+- httpx >= 0.24.0
+- pydantic >= 2.0.0
+
+## Error Handling
+
+The client raises standard httpx exceptions:
+- `httpx.HTTPStatusError` - For HTTP error responses (4xx, 5xx)
+- `httpx.RequestError` - For network/connection errors
+- `httpx.TimeoutException` - For request timeouts
+
+Always wrap API calls in try-catch blocks for production use.

orb_cloud_client-1.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+orb_cloud_client/__init__.py,sha256=zLbPCBXomXt5df4vyQVNVVRyRcM9ic4Fv93Vc9dOxN4,382
+orb_cloud_client/client.py,sha256=z2LWiKEakOP-kC4ElXmSPs-VVoWmPSz8WMVAVnWSIn8,4781
+orb_cloud_client/example.py,sha256=2izr6hF7gJyV_Gjqa3v0j9rkDwCjCYJsLXRgJTI_pIU,6046
+orb_cloud_client/example_async.py,sha256=OZb55zsYL_-Lo2TEgbBLVW1rdKldeWOmWI_HwPV1LMg,1427
+orb_cloud_client/models.py,sha256=5TTJBKunvLnvGBNAGmUFXepTi6K44AFzrSOXpDcoQKg,7955
+orb_cloud_client-1.2.1.dist-info/licenses/LICENSE,sha256=eUe4cBliuPkBMknHKwcgVbFlu53hoolIo-YrsynYrug,1069
+orb_cloud_client-1.2.1.dist-info/METADATA,sha256=uHkzxpK5pq-KF-mNyBqJjNNTcAI-btjpnoQdZ1omc1s,12482
+orb_cloud_client-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orb_cloud_client-1.2.1.dist-info/entry_points.txt,sha256=3i38Vp8ALWRx-BCL66C8m5BXCIF3vAJq8VMpOu_wT8Q,62
+orb_cloud_client-1.2.1.dist-info/top_level.txt,sha256=WMPN64HVd0BGfTV4BnMef1lroq7nUv_ZVf8wjYH8DdE,17
+orb_cloud_client-1.2.1.dist-info/RECORD,,

orb_cloud_client-1.2.1.dist-info/WHEEL

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

orb_cloud_client-1.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+orb-example = orb_cloud_client.example:main

orb_cloud_client-1.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Orb Networks
+
+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.

orb_cloud_client-1.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+orb_cloud_client