spyreapi 0.0.7__tar.gz → 0.0.8__tar.gz

{spyreapi-0.0.7/src/spyreapi.egg-info → spyreapi-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spyreapi
-Version: 0.0.7
+Version: 0.0.8
 Summary: A robust and extensible Python client for interacting with the [Spire Business Software API](https://developer.spiresystems.com/reference). This client provides an object-oriented interface to get, create, update, delete, query, filter, sort, and manage various Spire modules such as Sales Orders, Invoices, Inventory Items, and more.
 Author-email: Sanjid Sharaf <sanjidsharaf1@gmail.com>
 License-Expression: MIT

{spyreapi-0.0.7 → spyreapi-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spyreapi"
-version = "0.0.7"
+version = "0.0.8"
 authors = [
   { name="Sanjid Sharaf", email="sanjidsharaf1@gmail.com" },
 ]

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/Models/inventory_models.py

@@ -1,6 +1,6 @@
 from typing import List, Dict, Optional, Union
 from pydantic import BaseModel
-
+from .shared_models import Vendor
 
 
 class UPC(BaseModel):
@@ -16,12 +16,6 @@ class UPC(BaseModel):
     modifiedBy: Optional[str] = None
     links: Optional[Dict[str, str]] = None
 
-class Vendor(BaseModel):
-    id: Optional[int] = None
-    vendorNo: Optional[str] = None
-    name: Optional[str] = None
-
-
 class UnitOfMeasure(BaseModel):
     id: Optional[int] = None
     code: Optional[str] = None

spyreapi-0.0.8/src/spyre/Models/purchasing_models.py

@@ -0,0 +1,77 @@
+from typing import List, Optional, Dict, Any, Union
+from pydantic import BaseModel, model_validator
+from .shared_models import Vendor, Address, Currency, Contact
+
+class InventoryRef(BaseModel):
+    id: Optional[int] = None
+    whse: Optional[str] = None
+    partNo: Optional[str] = None
+    description: Optional[str] = None
+
+class PurchaseOrderItem(BaseModel):
+    id: Optional[int] = None
+    whse: Optional[str] = None
+    partNo: Optional[str] = None
+    sequence: Optional[int] = None
+    inventory: Optional[InventoryRef] = None
+    serials: Optional[Any] = None
+    description: Optional[str] = None
+    orderQty: Optional[str] = None
+    receiveQty: Optional[str] = None
+    receivedQty: Optional[str] = None
+    unitPrice: Optional[str] = None
+    freight: Optional[str] = None
+    purchaseMeasure: Optional[str] = None
+    taxFlags: Optional[List[bool]] = None
+    udf: Optional[Dict[str,Any]] = None
+    requiredDate: Optional[str] = None
+    referenceNo: Optional[str] = None
+    comment: Optional[str] = None
+
+class PurchaseOrder(BaseModel):
+    id: Optional[int] = None
+    number: Optional[str] = None
+    vendor: Optional[Vendor] = None
+    currency: Optional[Union[Currency, Dict[str, Any]]] = None
+    status: Optional[str] = None
+    Date: Optional[str] = None
+    requiredDate: Optional[str] = None
+    address: Optional[Address] = None
+    shippingAddress: Optional[Address] = None
+    vendorPO: Optional[str] = None
+    referenceNo: Optional[str] = None
+    fob: Optional[str] = None
+    incoterms: Optional[str] = None
+    incotermsPlace: Optional[str] = None
+    subtotal: Optional[str] = None
+    total: Optional[str] = None
+    deposit: Optional[str] = None
+    items: Optional[List[PurchaseOrderItem]] = None
+    udf: Optional[Dict[str,Any]] = None
+    createdBy: Optional[str] = None
+    modifiedBy: Optional[str] = None
+    created: Optional[str] = None
+    modified: Optional[str] = None
+    links: Optional[Dict[str,str]] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def clean_problematic_fields(cls, data: dict) -> dict:
+        if data.get("currency") == "":
+            data["currency"] = None
+
+        contact = data.get("contact")
+        if contact:
+            for field in ("phone", "fax"):
+                phone_data = contact.get(field)
+                if isinstance(phone_data, dict) and phone_data.get("number") is None:
+                    phone_data["number"] = ""
+        return data
+
+
+
+
+
+
+
+

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/Models/shared_models.py

@@ -122,4 +122,11 @@ class Note(BaseModel):
     createdBy: Optional[str] = None
     modified: Optional[str] = None
     modifiedBy: Optional[str] = None
-    links: Optional[Dict[str, str]] = None
+    links: Optional[Dict[str, str]] = None
+
+class Vendor(BaseModel):
+    id: Optional[int] = None
+    vendorNo: Optional[str] = None
+    code: Optional[str] = None
+    name: Optional[str] = None
+    

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/__init__.py

@@ -5,7 +5,10 @@ from .sales import OrdersClient, InvoiceClient, salesOrder, invoice
 from .customers import CustomerClient, customer
 from .Models.sales_models import SalesOrder, SalesOrderItem
 from .Models.inventory_models import InventoryItem, Vendor, UnitOfMeasure, Pricing, UPC
+from .Models.shared_models import Currency, Address
 from .Exceptions import CreateRequestError
+from .Models.purchasing_models import PurchaseOrderItem, PurchaseOrder, InventoryRef
+from .purchasing import purchaseOrder, PurchasingClient, PurchasingHistoryClient
 
 __all__ = [
     "SpireClient",
@@ -27,4 +30,12 @@ __all__ = [
     "CustomerClient",
     "customer",
     "CreateRequestError"
+    "PurchaseOrder",
+    "purchaseOrder"
+    "PurchaseOrderItem"
+    "PurchasingClient",
+    "PurchasingHistoryClient",
+    "InventoryRef",
+    "Currency",
+    "Address"
 ]

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/client.py

@@ -9,7 +9,7 @@ T = TypeVar('T', bound=BaseModel)
 class SpireClient():    
     """A lightweight to interact with the Spire API using requests sessions for connection reuse and authenticated calls."""
     
-    def __init__(self, host, company, username, password,):
+    def __init__(self, host, company, username, password, secure = True):
         """
         Initialize a SpireClient instance.
 
@@ -18,6 +18,7 @@ class SpireClient():
             company (str): Spire company.
             username (str): Spire user username.
             password (str): Spire user password.
+            secure (bool): HTTPS or HTTP connection
         """
         self.session = requests.Session()
         self.session.auth = (username, password)
@@ -25,8 +26,10 @@ class SpireClient():
             "accept": "application/json",
             "content-type": "application/json"
         })
-        self.base_url = f"https://{host}/api/v2/companies/{company}"
-
+        if secure:
+            self.base_url = f"https://{host}/api/v2/companies/{company}"
+        else:
+            self.base_url = f"http://{host}/api/v2/companies/{company}"
         try: 
             response = self.session.get(self.base_url)
             if response.text == 'No such company intertes':

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/inventory.py

@@ -260,7 +260,7 @@ class ItemsClient():
         Args:
             item_id (int): The ID of the inventory item.
             uom_id (int): The ID of the UOM to update.
-            uom (uom): A `uom` instance with updated field values.
+            uom_record (uom): A `uom` instance with updated field values.
 
         Returns:
             uom: The updated `uom` instance returned from the API.
@@ -364,7 +364,7 @@ class ItemsClient():
         Args:
             item_id (int): The ID of the inventory item.
             upc_id (int): The ID of the upc to update.
-            upc (upc): A `upc` instance with updated field values.
+            upc_record (upc): A `upc` instance with updated field values.
 
         Returns:
             upc: The updated `upc` instance returned from the API.
@@ -452,7 +452,7 @@ class item(APIResource[InventoryItem]):
         and returns the created UOM.
 
         Args:
-            uom (UnitOfMeasure): The UnitOfMeasure Pydantic model to be created.
+            uom_record (UnitOfMeasure): The UnitOfMeasure Pydantic model to be created.
 
         Returns:
             uom (uom): The newly created Unit of measure as a `uom` instance.
@@ -480,7 +480,7 @@ class item(APIResource[InventoryItem]):
         and returns the created UPC.
 
         Args:
-            uom_record (UPC): The UPC Pydantic model to be created.
+            upc_record (UPC): The UPC Pydantic model to be created.
 
         Returns:
             upc (upc): The newly created UPC as a `upc` instance.
@@ -619,7 +619,7 @@ class UpcClient():
 
         Args:
             upc_id (int): The ID of the upc to update.
-            upc (upc): A `upc` instance with updated field values.
+            upc_record (upc): A `upc` instance with updated field values.
 
         Returns:
             upc: The updated `upc` instance returned from the API.

spyreapi-0.0.8/src/spyre/purchasing.py

@@ -0,0 +1,363 @@
+from .client import APIResource, SpireClient
+from requests.exceptions import HTTPError, RequestException
+from .Exceptions import CreateRequestError
+from typing import Any, Optional, List, Dict
+from urllib.parse import urlparse
+from .utils import *
+import json
+
+from .Models.purchasing_models import PurchaseOrder
+
+class PurchasingClient:
+
+    def __init__(self, client: SpireClient):
+        self.client = client
+        self.endpoint = "purchasing/orders"
+
+    def get_purchase_order(self, id: int = None, PO_number: str = None) -> 'purchaseOrder':
+        """
+        Retrieve a purchase order by its ID or PO number.
+
+        Args:
+            id (int, optional): The ID of the purchase order to retrieve.
+            PO_number (str, optional): The purchase order number of the purchase order to retrieve.
+
+        Returns:
+            purchaseOrder: A `purchaseOrder` wrapper instance containing the retrieved data.
+
+        Raises:
+            ValueError: If neither id nor PO_number is provided, or if no matching order is found.
+        """
+        if id is not None:
+            response = self.client._get(f"/{self.endpoint}/{str(id)}")
+            return purchaseOrder.from_json(response, self.client)
+        elif PO_number is not None:
+            orders = self.query_purchase_order(query=PO_number)
+            for order in orders:
+                if getattr(order, "number", None) == PO_number:
+                    return self.get_purchase_order(order.id)
+            raise ValueError(f"No purchase order found for purchase order {PO_number}")
+        else:
+            raise ValueError("Either 'id' or 'PO_number' must be provided.")
+
+    def create_purchase_order(self, purchase_order: 'PurchaseOrder') -> 'purchaseOrder':
+        """
+        Create a new purchase order.
+
+        Sends a POST request to the purchase order endpoint.
+
+        Args:
+            purchase_order (dict): A PurchaseOrder instance containing the purchase order details.
+
+        Returns:
+            purchaseOrder: The create PurchaseOrder instance.
+
+        Raises:
+            CreateRequestError: If the creation fails or response is invalid.
+        """
+        if hasattr(purchase_order, "model_dump_json"):  # Pydantic v2
+            payload = json.loads(
+                purchase_order.model_dump_json(
+                    exclude_unset=True,
+                    exclude_none=True,
+                    by_alias=True,   # keep camelCase if you use aliases
+                )
+            )
+        else:  # Pydantic v1 fallback
+            payload = json.loads(
+                purchase_order.json(
+                    exclude_unset=True,
+                    exclude_none=True,
+                    by_alias=True,
+                )
+            )
+        response = self.client._post(f"/{self.endpoint}", json=payload)
+        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_purchase_order(id)
+        else:
+            error_message = response.get('content')
+            raise CreateRequestError(self.endpoint, status_code=response.get('status_code'), error_message=error_message)
+        
+    def update_purchase_order(self, id: int, purchase_order: 'purchaseOrder') -> 'purchaseOrder':
+        """
+        Update an existing purchase order by ID.
+
+        Sends a PUT request to the purchase order endpoint with the provided sales order data
+        to update the existing record. Returns a wrapped `purchaseOrder` object containing
+        the updated information.
+
+        Args:
+            id (int): The ID of the purchase order to update.
+            purchase_order (PurchaseOrder): A PurchaseOrder instance with the purchase order details.
+
+        Returns:
+            purchaseOrder: An instance of the purchaseOrder wrapper class initialized with the 
+                           updated data and client session.
+        """
+        if purchase_order.status == "I":
+            raise ValueError(f"Cannot update an issued purchase order for {purchase_order.number}")
+        else:
+            response = self.client._put(f"/{self.endpoint}/{str(id)}", json=purchase_order.model_dump(exclude_none=True, exclude_unset=True))
+        return purchaseOrder.from_json(response, self.client)
+
+    def delete_purchase_order(self, id: int) -> bool:
+        """
+        Delete a purchase order by its ID.
+
+        Sends a DELETE request to the purchase order endpoint to remove the specified
+        purchase order from the system.
+
+        Args:
+            id (int): The ID of the purchase order to delete.
+
+        Returns:
+            bool: True if the sales order was successfully deleted, False otherwise.
+        """
+        order = self.get_purchase_order(id)
+        if order.model.status in ("I", "R"):
+            raise ValueError(f"Cannot delete an issued or received purchase order for {order.number}")
+        else:
+            return self.client._delete(f"/{self.endpoint}/{str(id)}")
+
+    def query_purchase_order(
+            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["purchaseOrder"]:
+        """
+        Query purchase orders with optional full-text search, filtering, multi-field sorting, and pagination.
+
+        Args:
+            query (str, optional): Full-text search string.
+            sort (dict, optional): Dictionary of sorting rules (e.g., {"date": "desc", "number": "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): Any additional parameters to include in the query.
+        
+        Returns:
+            List[purchaseOrder]: List of wrapped purchase order resources.
+        """
+        return self.client._query(
+            endpoint=self.endpoint,
+            resource_cls=purchaseOrder,
+            query=query,
+            sort=sort,
+            filter=filter,
+            all=all,
+            limit=limit,
+            start=start,
+            **extra_params
+        )
+
+    def issue_purchase_order(self, id:int) -> 'purchaseOrder':
+        """
+        Issue a purchase order by its ID.
+
+        Sends a request to Spire to change the purchase order's status to
+        “Issued”. Issuing an order typically means it has been confirmed
+        and is ready to be sent to the vendor.
+
+        Args:
+            id (int): The ID of the purchaseOrder to issue.
+
+        Returns:
+            purchaseOrder: The updated purchase order object with the status set to "I" (Issued).
+
+        Raises:
+            CreateRequestError: If the request fails or the API returns an error status.
+        """
+        response = self.client._post(f"/{self.endpoint}/{str(id)}/issue")
+        if response.get("status_code") != 200:
+            raise CreateRequestError(f"Failed to issue purchase order: {id}: {response.text}")
+        return purchaseOrder.from_json(response, self.client)
+
+    def receive_purchase_order(self, id: int, receiveAll: bool = None) -> 'purchaseOrder':
+        """
+        Receive a purchase order by its ID.
+
+        This updates the order in Spire to reflect that items have been received. 
+        Typically, this should only be called on purchase orders with status "Issued".
+       
+        Args:
+            id (int): The ID of the purchaseOrder to receive.
+            receiveAll (bool, optional): An optional boolean to recieve all quantites on the purchase order.
+
+        Returns:
+            purchaseOrder: The updated purchase order object with the status set to "R" (Received).
+
+        Raises: CreateRequestError: If the request fails or the API returns an error status.
+        """
+        if receiveAll:
+            order = self.get_purchase_order(id)
+            for item in order.model.items:
+                item.receiveQty = item.orderQty
+            order.update()
+        response = self.client._post(f"/{self.endpoint}/{str(id)}/receive")
+        if response.get("status_code") != 200:
+            raise CreateRequestError(f"Failed to receive purchase order: {id}: {response.text}")
+        return purchaseOrder.from_json(response, self.client)
+
+class PurchasingHistoryClient:
+
+    def __init__(self, client: SpireClient):
+        self.client = client
+        self.endpoint = "purchasing/history"
+
+    def get_purchase_history_order(self, id: int = None, PO_number: str = None) -> 'purchaseOrder':
+        """
+        Retrieve an archived purchase order by its ID or PO number.
+
+        Args:
+            id (int, optional): The ID of the purchase order to retrieve.
+            PO_number (str, optional): The purchase order number of the purchase order to retrieve.
+
+        Returns:
+            purchaseOrder: A `purchaseOrder` wrapper instance containing the retrieved data.
+
+        Raises:
+            ValueError: If neither id nor PO_number is provieded, or if no matching purchase order is found.
+        """
+        if id is not None:
+            response = self.client._get(f"/{self.endpoint}/{str(id)}")
+            return purchaseOrder.from_json(response, self.client)
+        elif PO_number is not None:
+            orders = self.query_purchase_history_order(query=PO_number)
+            for order in orders:
+                if getattr(order, "number", None) == PO_number:
+                    return self.get_purchase_history_order(order.id)
+            raise ValueError(f"No purchase order found for purchase order {PO_number}")
+        else:
+            raise ValueError("Either 'id' or 'PO_number' must be provided.")
+
+    def query_purchase_history_order(
+            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["purchaseOrder"]:
+        """
+        Query archived purchase orders with optional full-text search, filtering, multi-field sorting, and pagination.
+
+        Args:
+            query (str, optional): Full-text search string.
+            sort (dict, optional): Dictionary of sorting rules (e.g., {"date": "desc", "number": "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): Any additional parameters to include in the query.
+        
+        Returns:
+            List[purchaseOrder]: List of wrapped purchase order resources.
+        """
+        return self.client._query(
+            endpoint=self.endpoint,
+            resource_cls=purchaseOrder,
+            query=query,
+            sort=sort,
+            filter=filter,
+            all=all,
+            limit=limit,
+            start=start,
+            **extra_params
+        )
+  
+class purchaseOrder(APIResource[PurchaseOrder]):
+    endpoint = "purchasing/orders"
+    Model = PurchaseOrder
+
+    def issue(self) -> 'purchaseOrder':
+        """
+        Issue this purchase order.
+
+        Sends a POST request to Spire to change the purchase order's status to
+        “I” (Issued). Issuing an order typically means it has been confirmed
+        and is ready to be sent to the vendor.
+
+        Returns:
+            purchaseOrder: The updated purchase order object with the status set to "I" (Issued).
+
+        Raise:
+            CreateRequestError: If the request fails or the API returns an error status.
+        """
+        response = self._client._post(f"/{self.endpoint}/{str(self.id)}/issue")
+        if response.get("status_code") != 200:
+            raise CreateRequestError(f"Failed to issue purchase order: {self.id}: {response.text}")
+        return purchaseOrder.from_json(response, self._client)
+
+    def delete(self) -> bool:
+        """
+        Cancels and deletes this purchase order.
+
+        Sends a DELETE request to the API to remove the purchase 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: "purchaseOrder" = None) -> 'purchaseOrder':
+        """
+        Update this sales order.
+
+        If no purchase order object is provided, updates the current instance on the server.
+        If a purchase order object is provided, updates the purchase order using the given data.
+
+        Args:
+            order (purchaseOrder, optional): An optional purchaseOrder instance to use for the update.
+
+        Returns: 
+            purchaseOrder: The updated purchaseOrder 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 purchaseOrder.from_json(response, self._client)
+    
+    def receive(self, receiveAll: bool = None) -> 'purchaseOrder':
+        """
+        Receive this purchase order.
+
+        Sends a POST request to Spire to change the purchase order's status to
+        "R" (Received). Receiving an order typically means the received quantites have been
+        entered and the order is ready to be invoiced.
+
+        Args:
+            receiveAll (bool, optional): An optional boolean to recieve all quantites on the purchase order.
+
+        Returns:
+            purchaseOrder: The updated purchase order object with the status set to "R" (Received).
+        
+        Raise: 
+            CreateRequestError: If the request fails or the API returns an error status.
+        """
+        if receiveAll:
+            for item in self.model.items:
+                item.receiveQty = item.orderQty
+            self.update()
+        response = self._client._post(f"/{self.endpoint}/{str(self.id)}/receive")
+        if response.get('status_code') != 200:
+            raise CreateRequestError(f"Failed to receive purchase order: {self.id}. (Check Order Quantites): {response.text}")
+        return purchaseOrder.from_json(response, self._client)
+      
+        
+        
+            
+    
+

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyre/spire.py

@@ -2,6 +2,7 @@ from .client import SpireClient
 from .sales import OrdersClient, InvoiceClient
 from .customers import CustomerClient
 from .inventory import InventoryClient
+from .purchasing import PurchasingClient, PurchasingHistoryClient
 
 class Spire:
     """
@@ -16,6 +17,8 @@ class Spire:
         invoices (InvoiceClient): Client for accessing invoices.
         customers (CustomerClient): Client for accessing customer records.
         inventory (InventoryClient): Client for accessing inventory items.
+        purchasing (PurchasingClient): Client for accessing purchasing records.
+        purchasingHistory (PurchasingHistoryClient): Client for accessing purchasing history records.
     """
     def __init__(self, host : str, company : str, username : str, password : str):
         """
@@ -32,5 +35,7 @@ class Spire:
         self.invoices = InvoiceClient(self.client)
         self.customers = CustomerClient(self.client)
         self.inventory = InventoryClient(self.client)
+        self.purchasing = PurchasingClient(self.client)
+        self.purchasingHistory = PurchasingHistoryClient(self.client)
 
 

{spyreapi-0.0.7 → spyreapi-0.0.8/src/spyreapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spyreapi
-Version: 0.0.7
+Version: 0.0.8
 Summary: A robust and extensible Python client for interacting with the [Spire Business Software API](https://developer.spiresystems.com/reference). This client provides an object-oriented interface to get, create, update, delete, query, filter, sort, and manage various Spire modules such as Sales Orders, Invoices, Inventory Items, and more.
 Author-email: Sanjid Sharaf <sanjidsharaf1@gmail.com>
 License-Expression: MIT

{spyreapi-0.0.7 → spyreapi-0.0.8}/src/spyreapi.egg-info/SOURCES.txt

@@ -8,12 +8,14 @@ src/spyre/client.py
 src/spyre/crm.py
 src/spyre/customers.py
 src/spyre/inventory.py
+src/spyre/purchasing.py
 src/spyre/sales.py
 src/spyre/spire.py
 src/spyre/utils.py
 src/spyre/Models/__init__.py
 src/spyre/Models/customers_models.py
 src/spyre/Models/inventory_models.py
+src/spyre/Models/purchasing_models.py
 src/spyre/Models/sales_models.py
 src/spyre/Models/shared_models.py
 src/spyreapi.egg-info/PKG-INFO