nys-client 0.1.0__tar.gz

nys_client-0.1.0/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2024 Noyes
+
+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.
+
+
+
+
+
+

nys_client-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include LICENSE
+
+
+
+
+
+

nys_client-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: nys_client
+Version: 0.1.0
+Summary: Python client library for the Noyes API
+Home-page: https://github.com/noyes/nys_client
+Author: Noyes
+Author-email: dev@noyes.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.1
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: pydantic<2.0.0,>=1.10.0
+Requires-Dist: fastapi-pagination>=0.12.0
+Requires-Dist: nys_constants>=0.1.0
+Requires-Dist: nys_schemas>=0.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# NysClient
+
+A Python client library for the Noyes API.
+
+## Installation
+
+```bash
+pip install nys-client
+```
+
+## Usage
+
+```python
+from nys_client import NysClient, TriggerStatus
+
+# Initialize client
+client = NysClient(api_key="your_api_key")
+
+# Get requests with filtering
+requests = client.requests.list(
+    status="ACCEPTED",
+    type="FULFILLMENT",
+    sort_by="created_at",
+)
+
+# Create a new request
+new_request = client.requests.create(
+    type="FULFILLMENT",
+    priority=10,
+    entities=[{
+        "entity_type": "SKU",
+        "sku_id": "SKU123",
+        "quantity": 1
+    }]
+)
+
+# Get jobs with search
+jobs = client.jobs.list(
+    quick_search="PICKING",
+    status="EXECUTING"
+)
+
+# Trigger a job
+client.trigger_job(
+    job_id="job-uuid",
+    trigger_status=TriggerStatus.SUCCEEDED_TRIGGER
+)
+```
+
+## Development
+
+This package is part of the Noyes monorepo. To install in development mode:
+
+```bash
+pip install -e .
+```

nys_client-0.1.0/README.md

@@ -0,0 +1,56 @@
+# NysClient
+
+A Python client library for the Noyes API.
+
+## Installation
+
+```bash
+pip install nys-client
+```
+
+## Usage
+
+```python
+from nys_client import NysClient, TriggerStatus
+
+# Initialize client
+client = NysClient(api_key="your_api_key")
+
+# Get requests with filtering
+requests = client.requests.list(
+    status="ACCEPTED",
+    type="FULFILLMENT",
+    sort_by="created_at",
+)
+
+# Create a new request
+new_request = client.requests.create(
+    type="FULFILLMENT",
+    priority=10,
+    entities=[{
+        "entity_type": "SKU",
+        "sku_id": "SKU123",
+        "quantity": 1
+    }]
+)
+
+# Get jobs with search
+jobs = client.jobs.list(
+    quick_search="PICKING",
+    status="EXECUTING"
+)
+
+# Trigger a job
+client.trigger_job(
+    job_id="job-uuid",
+    trigger_status=TriggerStatus.SUCCEEDED_TRIGGER
+)
+```
+
+## Development
+
+This package is part of the Noyes monorepo. To install in development mode:
+
+```bash
+pip install -e .
+```

nys_client-0.1.0/nys_client/__init__.py

@@ -0,0 +1,116 @@
+"""
+A Python client library for the Noyes API.
+            
+        Example:
+    >>> from nys_client import NysClient, RequestType, TriggerStatus
+    >>> 
+    >>> # Initialize client
+    >>> client = NysClient(api_key="your_api_key")
+    >>> 
+    >>> # Create a request
+    >>> new_request = client.requests.create( #TODO
+            ...     request_type=RequestType.FULFILLMENT,
+    ...     entities=[("123", 1)]
+    ... )
+    >>> 
+    >>> # Search for jobs
+    >>> jobs = client.jobs.search(
+    ...     filters={"status": "EXECUTING", "type": "PICKING"}
+    ... )
+    >>> 
+    >>> # Trigger a job
+    >>> client.jobs.trigger(
+    ...     job_id="job-123",
+    ...     trigger_status=TriggerStatus.SUCCEEDED_TRIGGER
+            ... )
+        """
+
+from .client import NysClient
+from .system import SystemResource
+from .bot import BotResource
+
+# Re-export commonly used types from nys_schemas and nys_constants
+from nys_constants.nys_constants import (
+    RequestType,
+    RequestStatus,
+    JobType,
+    JobStatus,
+    TriggerStatus,
+    SortOrder,
+)
+
+from nys_schemas.request_schema import (
+    RequestResponseComposite,
+    RequestFilter,
+    FulfillmentRequestCreateInput,
+    FetchRequestCreateInput,
+    ReplenishmentRequestCreateInput,
+    OnboardingRequestCreateInput,
+    OffboardingRequestCreateInput,
+    RFIDWriteRequestCreateInput,
+    PauseRequestCreateInput,
+    ResumeRequestCreateInput,
+)
+from nys_schemas.job_schema import (
+    JobResponse,
+    JobFilter,
+)
+from nys_schemas.bot_schema import (
+    Bot,
+    BotResponse,
+    BotChargingRequest,
+    BotChargingResponse,
+    BotStopChargingRequest,
+    BotStopChargingResponse,
+    BotRemoveResponse,
+)
+from nys_schemas.load_schema import (
+    LoadResponse,
+    LoadCreate,
+    LoadPatch,
+)
+
+__all__ = [
+    # Main client class
+    'NysClient',
+    
+    # Response models - Core entities
+    'RequestResponseComposite',
+    'JobResponse',
+    'BotResponse',
+    
+    # Request/Input models
+    'RequestCreateInputGeneric',
+    'RequestFilter',
+    'JobFilter',
+    'BotChargingRequest',
+    'BotChargingResponse',
+    'BotStopChargingRequest', 
+    'BotStopChargingResponse',
+    'BotRemoveResponse',
+    'Bot',
+    'FetchRequestCreateInput',
+    'FulfillmentRequestCreateInput',
+    'ReplenishmentRequestCreateInput',
+    'OnboardingRequestCreateInput',
+    'OffboardingRequestCreateInput',
+    'RFIDWriteRequestCreateInput',
+    'PauseRequestCreateInput',
+    'ResumeRequestCreateInput',
+    
+    # Load models
+    'LoadResponse',
+    'LoadCreate',
+    'LoadPatch',
+
+    
+    # Enums and Constants
+    'RequestType',
+    'RequestStatus',
+    'JobType',
+    'JobStatus',
+    'TriggerStatus',
+    'SortOrder',
+] 
+
+__version__ = "0.1.0"

nys_client-0.1.0/nys_client/base.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union, Tuple
+from pydantic import BaseModel
+
+from nys_constants.nys_constants import SortOrder
+from .utils import prepare_filter_value
+
+T = TypeVar('T', bound=BaseModel)
+FilterType = TypeVar('FilterType', bound=BaseModel)
+
+class BaseResource(Generic[T]):
+    """Base class for API resources. e.g. Job, Request, Sku, etc"""
+    
+    def __init__(self, client: 'NysClient'):
+        self._client = client
+
+    #TODO consider renaming to _get
+    def _search(
+        self,
+        *,
+        endpoint: str,
+        response_model: Type[T],
+        filters: Optional[FilterType] = None,
+        search: Optional[str] = None,
+        sort_by: Optional[Union[str, List[Tuple[str, SortOrder]]]] = None,
+        page: int = 1,
+        size: int = 50
+    ) -> List[T]:
+        """Generic search method used by all resource-specific search methods."""
+        params: Dict[str, Any] = {
+            "page": page,
+            "size": size
+        }
+
+        # Add sorting parameters if provided
+        if sort_by:
+            if isinstance(sort_by, str):
+                params["sort_by"] = sort_by
+            else:
+                # Convert list of tuples to comma-separated string with prefixes
+                sort_str = ','.join(
+                    f"{'-' if order == SortOrder.DESC else ''}{field}"
+                    for field, order in sort_by
+                )
+                params["sort_by"] = sort_str
+
+        # Add search fields if provided
+        if search:
+            if isinstance(search, str):
+                # leave the validation to the API
+                params['search'] = search
+            else:
+                raise ValueError("search must be a string")
+
+        # Add filters if provided
+        if filters:
+            # Convert filter model to dict and remove None values
+            filter_dict = filters.dict(exclude_unset=True, exclude_defaults=True)
+            
+            # Add each non-None filter to params, converting values as needed
+            for field_name, value in filter_dict.items():
+                if value is not None:
+                    params[field_name] = prepare_filter_value(value)
+
+        # Make API request
+        response = self._client._request(
+            method="GET",
+            endpoint=endpoint,
+            params=params
+        )
+        
+        # Parse response into list of model instances
+        data = response.json()
+        return [response_model(**item) for item in data["items"]] 

nys_client-0.1.0/nys_client/bot.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+from nys_schemas.bot_schema import (
+    Bot,
+    BotResponse,
+    BotFilter,
+    BotSort,
+    BotChargingRequest,
+    BotChargingResponse,
+    BotStopChargingRequest,
+    BotStopChargingResponse,
+    BotRemoveResponse
+)
+from .base import BaseResource
+
+__all__ = [
+    'BotResource',  # The main resource class
+    'Bot',
+    'BotResponse',
+    'BotFilter',
+    'BotSort',
+    'BotChargingRequest',
+    'BotChargingResponse',
+    'BotStopChargingRequest',
+    'BotStopChargingResponse',
+    'BotRemoveResponse'
+]
+
+class BotResource(BaseResource[BotResponse]):
+    """Resource for interacting with Bots."""
+
+    def get_bots(self) -> List[BotResponse]:
+        """
+        Get all bots.
+        
+        Returns:
+            List[BotResponse]: List of all bots in the system
+            
+        Examples:
+            >>> bots = client.bots.get_bots()
+            >>> for bot in bots:
+            ...     print(f"Bot ID: {bot.idx}, Level: {bot.level_id}, Battery: {bot.battery_level}%")
+        """
+        response = self._client._request(
+            method="GET",
+            endpoint="api/v2/bots"
+        )
+        return [BotResponse(**item) for item in response.json()]
+
+    def go_charging(self, charging_request: BotChargingRequest) -> BotChargingResponse:
+        """
+        Send specified bots to charging stations.
+        
+        This endpoint proxies the request to the brain API which handles the ROS communication.
+        
+        Args:
+            charging_request: The request parameters including bot_idxs, force flag, 
+                             block_until_done flag, and timeout
+                             
+        Returns:
+            BotChargingResponse: Response with success/failure information
+            
+        Examples:
+            >>> from nys_client.bot import BotChargingRequest
+            >>> response = client.bots.go_charging(
+            ...     BotChargingRequest(
+            ...         bot_ids=["1", "2"],
+            ...         force=True,
+            ...         block_until_done=False,
+            ...         timeout=180
+            ...     )
+            ... )
+            >>> print(f"Success: {response.success}, Message: {response.message}")
+        """
+        response = self._client._request(
+            method="POST",
+            endpoint="api/v2/bot/go_charging",
+            json=charging_request.dict()
+        )
+        return BotChargingResponse(**response.json())
+
+    def stop_charging(self, stop_charging_request: BotStopChargingRequest) -> BotStopChargingResponse:
+        """
+        Stop charging for specified bots.
+        
+        This endpoint proxies the request to the brain API which handles the ROS communication.
+        
+        Args:
+            stop_charging_request: The request parameters including bot_idxs and force flag
+            
+        Returns:
+            BotStopChargingResponse: Response with success/failure information
+            
+        Examples:
+            >>> from nys_client.bot import BotStopChargingRequest
+            >>> response = client.bots.stop_charging(
+            ...     BotStopChargingRequest(
+            ...         bot_ids=["1", "2"],
+            ...         force=True
+            ...     )
+            ... )
+            >>> print(f"Success: {response.success}, Message: {response.message}")
+        """
+        response = self._client._request(
+            method="POST",
+            endpoint="api/v2/bot/stop_charging",
+            json=stop_charging_request.dict()
+        )
+        return BotStopChargingResponse(**response.json())
+
+    def remove_bots(self, bot_ids: List[str]) -> BotRemoveResponse:
+        """
+        Remove specified bots from the database.
+        
+        Warning: This is not the usual offboarding process. Use at your own risk!
+        
+        Args:
+            bot_ids: List of bot IDs to remove from database; use ["*"] for all bots
+            
+        Returns:
+            BotRemoveResponse: Response with success/failure information
+            
+        Examples:
+            >>> response = client.bots.remove_bots(["1", "2"])
+            >>> print(f"Success: {response.success}, Message: {response.message}")
+        """
+        response = self._client._request(
+            method="DELETE",
+            endpoint="api/v2/bot",
+            params={"bot_ids": bot_ids}
+        )
+        return BotRemoveResponse(**response.json())

nys_client-0.1.0/nys_client/client.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+import logging
+import requests
+from typing import Optional
+
+from .request import RequestResource
+from .job import JobResource
+from .skus import SkuResource
+from .loads import LoadResource
+from .requests_and_jobs_view import RequestsAndJobsViewResource
+from .inventory_view import InventoryViewResource
+from .system import SystemResource
+from .bot import BotResource
+from .events import EventResource
+logger = logging.getLogger(__name__)
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+class NysClient:
+    """Client for interacting with the Noyes API."""
+    
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "http://noyes-api:8003",
+        # TODO: Increased timeout to 60 seconds for long-running requests. Eg. stop_brain endpoint
+        timeout: int = 60 # seconds
+    ):
+        """
+        Initialize the NysClient.
+        
+        Args:
+            api_key: Your API key
+            base_url: Base URL of the API (default: http://noyes-api:8003)
+            timeout: Request timeout in seconds (default: 60)
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+        self._headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        }
+        
+        # Initialize resources
+        self._requests = RequestResource(self)
+        self._jobs = JobResource(self)
+        self._skus = SkuResource(self)
+        self._loads = LoadResource(self)
+        self._requests_and_jobs_view = RequestsAndJobsViewResource(self)
+        self._inventory_view = InventoryViewResource(self)
+        self._system = SystemResource(self)
+        self._bots = BotResource(self)
+        self._events = EventResource(self)
+    
+    @property
+    def requests(self) -> RequestResource:
+        """Access request-related operations."""
+        return self._requests
+    
+    @property
+    def jobs(self) -> JobResource:
+        """Access job-related operations."""
+        return self._jobs
+
+    @property
+    def skus(self) -> SkuResource:
+        """Access SKU-related operations."""
+        return self._skus
+
+    @property
+    def loads(self) -> LoadResource:
+        """Access load-related operations."""
+        return self._loads
+
+    @property
+    def requests_and_jobs_view(self) -> RequestsAndJobsViewResource:
+        """Access requests and jobs view operations."""
+        return self._requests_and_jobs_view
+
+    @property
+    def inventory_view(self) -> InventoryViewResource:
+        """Access inventory view operations."""
+        return self._inventory_view
+
+    @property
+    def system(self) -> SystemResource:
+        """Access system-related operations."""
+        return self._system
+        
+    @property
+    def bots(self) -> BotResource:
+        """Access bot-related operations."""
+        return self._bots
+
+    @property
+    def events(self) -> EventResource:
+        """Access event-related operations."""
+        return self._events
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[dict] = None,
+        json: Optional[dict] = None,
+        **kwargs
+    ) -> requests.Response:
+        """
+        Make a request to the API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint
+            params: Query parameters
+            json: JSON body
+            **kwargs: Additional arguments to pass to requests
+            
+        Returns:
+            requests.Response: Response from the API
+        """
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        response = requests.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            timeout=self.timeout,
+            headers=self._headers,
+            **kwargs
+        )
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as e:
+            logger.error(f"HTTP error occurred: {e}")
+            logger.error(f"Response content: {response.text}")
+            raise e
+        return response