spyreapi 0.0.1__py3-none-any.whl

spyre/inventory.py

@@ -0,0 +1,344 @@
+from Models.inventory_models import *
+import utils
+from client import *
+from urllib.parse import urlparse 
+from Exceptions import *
+from typing import Any
+from typing import TYPE_CHECKING
+
+""""
+TODO    Get Upc
+        Create UPC
+        Query UPC
+        Delete UPC
+        Update UPC
+
+        Sell Prices
+
+        Counts
+        Adjustements
+
+"""
+
+class InventoryClient():
+    
+    def __init__(self, client : SpireClient):
+        self.client = client
+        self.endpoint = 'inventory'
+        self.items = ItemsClient(client=client)
+        self.upcs = UpcClient(client=client)
+    
+    def __getattr__(self, name):
+       
+        if hasattr(self.items, name):
+            return getattr(self.items, name)
+       
+        if hasattr(self.upcs, name):
+            return getattr(self.upcs, name)
+        raise AttributeError(f"'InventoryClient' object has no attribute '{name}'")
+
+class ItemsClient():
+
+    def __init__(self, client : SpireClient):
+        self.client = client
+        self.endpoint = 'inventory/items'
+
+    def get_item(self, id) -> "item":
+        """
+        Retrieve a inventory item by its ID.
+
+        Sends a GET request to the Spire API to fetch a inentory item data for the
+        specified ID. Wraps the result in a `item` instance, which
+        retains a reference to the client for further actions.
+
+        Args:
+            id (int): The ID of the sales order to retrieve.
+
+        Returns:
+            salesOrder: A `item` wrapper instance containing the retrieved
+            data and a reference to the client session.
+        """
+        response = self.client._get(f"/{self.endpoint}/{str(id)}")
+        return item.from_json(response, self.client)
+    
+    def create_item(self, item : 'InventoryItem') -> 'item':
+        """
+        Create a new Inventory Item in SPire.
+
+        Sends a POST request to the Inventory/Items endpoint .
+
+        Args:
+            item (dict): A InventoryItem instace containing the sales order details.
+
+        Returns:
+            item: The created InventoryItem instance.
+
+        Raises:
+            CreateRequestError: If the creation fails or response is invalid.
+        """
+
+        response =  self.client._post(f"/{self.endpoint}", json=item.model_dump(exclude_unset=True, exclude_none=True))
+        if response.get('status_code') == 201:
+            location = response.get('headers').get('location')
+            parsed_url = urlparse(location)
+            path_segments = parsed_url.path.rstrip("/").split("/")
+            id = path_segments[-1]
+            return self.get_item(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+
+    
+    def update_item(self, id: int, inventory_item : 'InventoryItem') -> 'item':
+        """
+        Update an existing Inventory Item by ID.
+
+        Sends a PUT request to the Inventory/Items endpoint with the provided data
+        to update the existing record. Returns a wrapped `item` object containing
+        the updated information.
+
+        Args:
+            id (int): The ID of the item to update.
+            item (InventoryItem): A InventoryItem instance with the sales order details.
+
+        Returns:
+            item: An instance of the item wrapper class initialized with 
+                        the updated data and client session.
+        """
+        response = self.client._put(f"/{self.endpoint}/{str(id)}", json=inventory_item.model_dump(exclude_none=True, exclude_unset=True))
+        return item.from_json(response, self.client)
+    
+    def delete_item(self, id: int) -> bool:
+        """
+        Delete a inventory_item by its ID.
+
+        Sends a DELETE request to the endpoint to remove the specified
+        inventory item from the system.
+
+        Args:
+            id (int): The ID of the inventory item to delete.
+
+        Returns:
+            bool: True if the item was successfully deleted, False otherwise.
+        """
+        return self.client._delete(f"/{self.endpoint}/{str(id)}")
+    
+
+    def query_inventory_items(
+        self,
+        *,
+        query: Optional[str] = None,
+        sort: Optional[Dict[str, str]] = None,
+        filter: Optional[Dict[str, Any]] = None,
+        all: bool = False,
+        limit: int = 1000,
+        start: int = 0,
+        **extra_params
+    ) -> List["item"]:
+        """
+        Query inventory items with optional full-text search, filtering, multi-field sorting, and pagination.
+
+        Args:
+            q (str, optional): Full-text search string.
+            sort (dict, optional): Dictionary of sorting rules (e.g., {"orderDate": "desc", "orderNo": "asc"}).
+            filter (dict, optional): Dictionary of filters to apply (will be JSON-encoded and URL-safe).
+            all (bool, optional): If True, retrieves all pages of results.
+            limit (int, optional): Number of results per page (max 1000).
+            start (int, optional): Starting offset for pagination.
+            **extra_params: Any additional parameters to include in the query.
+
+        Returns:
+            List[item]: List of wrapped sales order resources.
+        """
+        return self.client._query(
+            endpoint=self.endpoint,
+            resource_cls=item,
+            query=query,
+            sort=sort,
+            filter=filter,
+            all=all,
+            limit=limit,
+            start=start,
+            **extra_params
+        )
+    
+    def get_item_uoms(self, id : int) -> List["uom"]:
+        
+        uoms = []
+        response = self.client._get(f"{self.endpoint}/{str(id)}/uoms")
+        items = response.get('records')
+        for item in items:
+            uoms.append(uom.from_json(json_data=item, client = self.client, item_id = id))
+
+        return uoms
+
+    def get_uom(self, item_id :int , uom_id : int) -> "uom":
+
+        response = self.client._get(f"/{self.endpoint}/{str(item_id)}/uoms/{str(uom_id)}")
+        return uom.from_json(response, self.client)
+    
+
+    def create_item_uom(self, id: int, uom : UnitOfMeasure) -> List["uom"]:
+        
+        response =  self.client._post(f"/{self.endpoint}/{str(id)}/uoms", json=uom.model_dump(exclude_unset=True, exclude_none=True))
+        if response.get('status_code') == 201:
+            location = response.get('headers').get('location')
+            parsed_url = urlparse(location)
+            path_segments = parsed_url.path.rstrip("/").split("/")
+            id = path_segments[-1]
+            return self.get_uom(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+
+    def delete_uom(self, item_id : int, uom_id :int) -> bool:
+
+        return self.client._delete(f"/{self.endpoint}/{str(item_id)}/uoms/{str(uom_id)}")
+    
+    def update_item_uom(self, item_id: int, uom_id : int, uom :'uom') -> 'uom':
+
+        response = self.client._put(f"/{self.endpoint}/{str(item_id)}/{str(uom_id)}", json=uom.model_dump(exclude_none=True, exclude_unset=True))
+        return uom.from_json(response, self.client)
+    
+
+    def get_item_upcs(self, id : int) -> List["upc"]:
+        
+        upcs = []
+        response = self.client._get(f"{self.endpoint}/{str(id)}/upcs")
+        items = response.get('records')
+        for item in items:
+            upcs.append(upc.from_json(json_data=item, client = self.client, item_id = id))
+
+        return upcs
+    
+
+        # def get_uom(self, item_id :int , uom_id : int) -> "uom":
+
+        # response = self.client._get(f"/{self.endpoint}/{str(item_id)}/uoms/{str(uom_id)}")
+        # return uom.from_json(response, self.client)
+
+class item(APIResource[InventoryItem]):
+    
+    endpoint =  'inventory/items'
+    Model = InventoryItem
+
+    """
+    #TODO Check Upload, Add Uom & UPC, Add Price Matrix Record, Setting Sell & Buy UOM
+
+    """
+
+    def delete(self):
+        """
+        Cancels or deletes the item.
+
+        Sends a DELETE request to the API to remove the inventory item with the current ID.
+
+        Returns:
+            bool: True if the order was successfully deleted (HTTP 204 or 200), False otherwise.
+        """
+        
+        return self._client._delete(f"/{self.endpoint}/{str(self.id)}")
+    
+    def update(self, inventory_item: "item" = None) -> 'item':
+        """
+        Update the inventory item.
+
+        If no item object is provided, updates the current instance on the server.
+        If an item object is provided, updates the item using the given data.
+
+        Args:
+            inventory_item (item, optional): An optional item instance to use for the update.
+
+        Returns:
+            item: The updated item object reflecting the new status.
+        """
+        data = inventory_item.model_dump(exclude_unset=True, exclude_none=True) if inventory_item else self.model_dump(exclude_unset=True, exclude_none=True)
+        response = self._client._put(f"/{self.endpoint}/{str(self.id)}", json=data)
+        return item.from_json(response, self._client)    
+    
+    def get_uoms(self) -> List["uom"]:
+        
+        uoms = []
+        response = self._client._get(f"{self.endpoint}/{self.id}/uoms")
+        items = response.get('records')
+        for item in items:
+            uoms.append(uom.from_json(json_data=item, client = self._client, item_id = self.id))
+
+        return uoms
+    
+
+    def add_uom(self, uom : UnitOfMeasure) -> List["uom"]:
+        
+        response =  self.client._post(f"/{self.endpoint}/{str(self.id)}/uoms", json=uom.model_dump(exclude_unset=True, exclude_none=True))
+        if response.get('status_code') == 201:
+            location = response.get('headers').get('location')
+            parsed_url = urlparse(location)
+            path_segments = parsed_url.path.rstrip("/").split("/")
+            id = path_segments[-1]
+            return self.get_uom(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+
+    
+class uom(APIResource[UnitOfMeasure]):
+    Model = UnitOfMeasure
+    _endpoint = ''  # Will be dynamically set in __init__
+
+
+    def __init__(self, model, client, item_id=None):
+        if item_id is None:
+            raise ValueError("item_id must be provided")
+        super().__init__(model, client)
+        uom_id = model.id
+        self._endpoint = f'inventory/items/{item_id}/uoms/{str(uom_id)}'
+        self._item_id = item_id
+
+    def delete(self):
+        """
+        Cancels or deletes the uom.
+
+        Sends a DELETE request to the API to remove the uom with the current ID.
+
+        Returns:
+            bool: True if the uom was successfully deleted (HTTP 204 or 200), False otherwise.
+        """
+        
+        return self._client._delete(f"/{self._endpoint}")
+    
+    def update(self, _uom: "uom" = None) -> 'uom':
+        """
+        Update the uom.
+
+        If no uom object is provided, updates the current instance on the server.
+        If an uom object is provided, updates the item using the given data.
+
+        Args:
+            uom (uom, optional): An optional uom instance to use for the update.
+
+        Returns:
+            uom: The updated uom object reflecting the new status.
+        """
+        data = _uom.model_dump(exclude_unset=True, exclude_none=True) if _uom else self.model_dump(exclude_unset=True, exclude_none=True)
+        response = self._client._put(f"/{self._endpoint}", json=data)
+        return uom.from_json(response, self._client, item_id = self._item_id)    
+
+class UpcClient():
+
+    def __init__(self, client : SpireClient):
+        self.endpoint = 'inventory/upcs'
+
+
+
+
+class upc(APIResource[UPC]):
+    _endpoint = ''         
+    Model = ''
+
+    def __init__(self, model, client, item_id=None):
+        if item_id is None:
+            raise ValueError("item_id must be provided")
+        super().__init__(model, client)
+        upc_id = model.id
+        self._endpoint = f'inventory/items/{item_id}/upcs/{str(upc_id)}'
+        self._item_id = item_id

spyre/sales.py

@@ -0,0 +1,313 @@
+from client import APIResource
+from Models.sales_models import *
+import utils
+from client import SpireClient
+from urllib.parse import urlparse 
+from Exceptions import *
+from typing import Any
+
+class OrdersClient():
+
+    def __init__(self, client: SpireClient):
+        self.client = client
+        self.endpoint = "sales/orders"
+    
+    def get_sales_order(self,  id: int, ) -> "salesOrder":
+        """
+        Retrieve a sales order by its ID.
+
+        Sends a GET request to the Spire API to fetch sales order data for the
+        specified ID. Wraps the result in a `salesOrder` instance, which
+        retains a reference to the client for further actions.
+
+        Args:
+            id (int): The ID of the sales order to retrieve.
+
+        Returns:
+            salesOrder: A `salesOrder` wrapper instance containing the retrieved
+            data and a reference to the client session.
+        """
+        response = self.client._get(f"/{self.endpoint}/{str(id)}")
+        return salesOrder.from_json(response, self.client)
+
+    def create_sales_order(self, sales_order : 'SalesOrder') -> 'salesOrder':
+        """
+        Create a new sales order.
+
+        Sends a POST request to the sales order endpoint .
+
+        Args:
+            sales_order (dict): A SalesOrder instace containing the sales order details.
+
+        Returns:
+            salesOrder: The created SalesOrder instance.
+
+        Raises:
+            CreateRequestError: If the creation fails or response is invalid.
+        """
+
+        response =  self.client._post(f"/{self.endpoint}", json=sales_order.model_dump(exclude_unset=True, exclude_none=True))
+        if response.get('status_code') == 201:
+            location = response.get('headers').get('location')
+            parsed_url = urlparse(location)
+            path_segments = parsed_url.path.rstrip("/").split("/")
+            id = path_segments[-1]
+            return self.get_sales_order(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+
+    def update_sales_order(self, id: int, sales_order : 'SalesOrder') -> 'salesOrder':
+        """
+        Update an existing sales order by ID.
+
+        Sends a PUT request to the sales order endpoint with the provided sales order data
+        to update the existing record. Returns a wrapped `salesOrder` object containing
+        the updated information.
+
+        Args:
+            id (int): The ID of the sales order to update.
+            sales_order (SaleOrder): A SalesOrder instance with the sales order details.
+
+        Returns:
+            salesOrder: An instance of the salesOrder wrapper class initialized with 
+                        the updated data and client session.
+        """
+        response = self.client._put(f"/{self.endpoint}/{str(id)}", json=sales_order.model_dump(exclude_none=True, exclude_unset=True))
+        return salesOrder.from_json(response, self.client)
+
+    def delete_sales_order(self, id: int) -> bool:
+        """
+        Delete a sales order by its ID.
+
+        Sends a DELETE request to the sales order endpoint to remove the specified
+        sales order from the system.
+
+        Args:
+            id (int): The ID of the sales order to delete.
+
+        Returns:
+            bool: True if the sales order was successfully deleted, False otherwise.
+        """
+        return self.client._delete(f"/{self.endpoint}/{str(id)}")
+
+    def query_sales_orders(
+        self,
+        *,
+        query: Optional[str] = None,
+        sort: Optional[Dict[str, str]] = None,
+        filter: Optional[Dict[str, Any]] = None,
+        all: bool = False,
+        limit: int = 1000,
+        start: int = 0,
+        **extra_params
+    ) -> List["salesOrder"]:
+        """
+        Query sales orders with optional full-text search, filtering, multi-field sorting, and pagination.
+
+        Args:
+            q (str, optional): Full-text search string.
+            sort (dict, optional): Dictionary of sorting rules (e.g., {"orderDate": "desc", "orderNo": "asc"}).
+            filter (dict, optional): Dictionary of filters to apply (will be JSON-encoded and URL-safe).
+            all (bool, optional): If True, retrieves all pages of results.
+            limit (int, optional): Number of results per page (max 1000).
+            start (int, optional): Starting offset for pagination.
+            **extra_params: Any additional parameters to include in the query.
+
+        Returns:
+            List[salesOrder]: List of wrapped sales order resources.
+        """
+        return self.client._query(
+            endpoint=self.endpoint,
+            resource_cls=salesOrder,
+            query=query,
+            sort=sort,
+            filter=filter,
+            all=all,
+            limit=limit,
+            start=start,
+            **extra_params
+        )
+    
+    
+class InvoiceClient():
+    
+    def __init__(self, client : SpireClient):
+        self.client = client
+        self.endpoint = "sales/invoices"
+
+    def get_invoice(self, id: int) -> 'invoice':
+        """
+        Retrieve a sales invoice by its ID.
+
+        Sends a GET request to the invoices endpoint to fetch the invoice data.
+
+        Args:
+            id (int): The ID of the invoice to retrieve.
+
+        Returns:
+            invoice: An invoice instance created from the response data.
+        """
+        response = self.client._get(f"/{self.endpoint}/{id}")
+        return invoice.from_json(response, self.client)
+
+    def update_invoice(self, id: int, invoice : Invoice) -> 'invoice':
+        """
+        Update an existing invoice by ID.
+
+        Sends a PUT request with updated invoice data to the invoices endpoint.
+
+        Args:
+            id (int): The ID of the invoice to update.
+            invoice (Invoice): The Invoice model instance containing updated data.
+
+        Returns:
+            invoice: The updated invoice instance created from the response data.
+        """
+        response = self.client._put(f"/{self.endpoint}/{id}", json=invoice.model_dump(exclude_none=True, exclude_unset=True))
+        return invoice.from_json(response, self.client)
+    
+    def query_invoices(
+        self,
+        *,
+        query: Optional[str] = None,
+        sort: Optional[Dict[str, str]] = None,
+        filter: Optional[Dict[str, Any]] = None,
+        all: bool = False,
+        limit: int = 1000,
+        start: int = 0,
+        **extra_params
+    ) -> List["salesOrder"]:
+        """
+        Query invoices with optional full-text search, filtering, multi-field sorting, and pagination.
+
+        Args:
+            q (str, optional): Full-text search string.
+            sort (dict, optional): Dictionary of sorting rules (e.g., {"orderDate": "desc", "orderNo": "asc"}).
+            filter (dict, optional): Dictionary of filters to apply (will be JSON-encoded and URL-safe).
+            all (bool, optional): If True, retrieves all pages of results.
+            limit (int, optional): Number of results per page (max 1000).
+            start (int, optional): Starting offset for pagination.
+            **extra_params: Any additional parameters to include in the query.
+
+        Returns:
+            List[invoice]: List of wrapped invoice resources.
+        """
+        return self.client._query(
+            endpoint=self.endpoint,
+            resource_cls=invoice,
+            query=query,
+            sort=sort,
+            filter=filter,
+            all=all,
+            limit=limit,
+            start=start,
+            **extra_params
+        )
+
+
+class salesOrder(APIResource[SalesOrder]):
+    endpoint = "sales/orders/"
+    Model = SalesOrder 
+
+    def invoice(self):
+        """
+        Invoice the current sales order.
+
+        Sends a POST request to create an invoice for this sales order.
+        Note that quotes (salesOrder with type "Q") cannot be invoiced.
+
+        Returns:
+            invoice: The created invoice object if successful.
+            dict: The full response if invoicing failed.
+ 
+        """
+        response = self._client._post(f"/{self.endpoint}/{str(self.id)}/invoice")
+        if response.get('status_code') == 201:
+            location = response.get('headers').get('location')
+            parsed_url = urlparse(location)
+            path_segments = parsed_url.path.rstrip("/").split("/")
+            id = path_segments[-1]
+            return InvoiceClient(client=self._client).get_invoice(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+    
+    def process(self) -> 'salesOrder':
+        """
+        Set the status of the salesOrder to 'Processed' (status = 'P').
+
+        Sends a PUT request to update the status field of this Sales Oder.
+
+        Returns:
+            salesOrder: The updated salesOrder object reflecting the new status.
+        """
+        response = self._client._put(
+            f"/{self.endpoint}/{str(self.id)}",
+            json={"status": "P"}    
+        )
+        return salesOrder.from_json(response, self._client)
+    
+    def delete(self):
+        """
+        Cancels or deletes the sales order.
+
+        Sends a DELETE request to the API to remove the sales order with the current ID.
+
+        Returns:
+            bool: True if the order was successfully deleted (HTTP 204 or 200), False otherwise.
+        """
+        
+        return self._client._delete(f"/{self.endpoint}/{str(self.id)}")
+    
+    def update(self, order: "salesOrder" = None) -> 'salesOrder':
+        """
+        Update the sales order.
+
+        If no order object is provided, updates the current instance on the server.
+        If an order object is provided, updates the sales order using the given data.
+
+        Args:
+            order (salesOrder, optional): An optional salesOrder instance to use for the update.
+
+        Returns:
+            salesOrder: The updated salesOrder object reflecting the new status.
+        """
+        data = order.model_dump(exclude_unset=True, exclude_none=True) if order else self.model_dump(exclude_unset=True, exclude_none=True)
+        response = self._client._put(f"/{self.endpoint}/{str(self.id)}", json=data)
+        return salesOrder.from_json(response, self._client)    
+
+class invoice(APIResource[Invoice]):
+    endpoint = "sales/invoices/"
+    Model = Invoice
+
+    def reverse(self):
+        """
+        Convert this invoice into a sales order.
+
+        This method uses the internal model of the invoice to create a new sales order
+        using the `create_sales_order_from_invoice` utility function. It then submits the
+        order through the OrdersClient.
+
+        Returns:
+            salesOrder: The created sales order instance returned by the API.
+        """
+        order_converted = utils.create_sales_order_from_invoice(self._model)
+        return OrdersClient(self._client).create_sales_order(order_converted)
+
+    def update(self , invoice_: "Invoice" = None) -> 'invoice':
+        """
+        Update this invoice.
+
+        Sends a PUT request with updated invoice data to the invoices endpoint.
+        If no order object is provided, updates the current instance on the server.
+
+        Args:
+            invoice (Invoice): The Invoice model instance containing updated data.
+
+        Returns:
+            invoice: The updated invoice instance created from the response data.
+        """
+        data = invoice_.model_dump(exclude_unset=True, exclude_none=True) if invoice_ else self.model_dump(exclude_unset=True, exclude_none=True)
+        response = self._client._put(f"/{self.endpoint}/{str(self.id)}", json=data)
+        return invoice.from_json(response, self._client)   

spyre/spire.py

@@ -0,0 +1,14 @@
+from client import SpireClient
+from sales import *
+from customers import *
+from inventory import InventoryClient
+
+class Spire:
+    def __init__(self, company : str, username : str, password : str):
+        self.client = SpireClient(company, username, password)
+        self.orders = OrdersClient(self.client)
+        self.invoices = InvoiceClient(self.client)
+        self.customers = CustomerClient(self.client)
+        self.inventory = InventoryClient(self.client)
+
+