getmeadow 0.1.0__tar.gz

getmeadow-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.3
+Name: getmeadow
+Version: 0.1.0
+Summary: Python client for the getmeadow api
+Author: Sebash
+Author-email: Sebash <sebash@mail.friendlyautomations.com>
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# GetMeadow
+
+[API Documentation](https://api-docs.getmeadow.com/introduction)
+
+## Installation
+
+```bash
+pip install getmeadow
+```
+
+A Python client for the Meadow API built on `httpx` and `pydantic`
+
+GetMeadow uses Pydantic for request and response validation and currently supports username/password authentication.
+Many client methods return a two-item tuple containing the HTTP status code and the response data:
+
+```python
+status_code, data = client.get_orders()
+```
+
+## Organizations
+Organization handling works similarly to the Meadow web application.
+API URLs are generated using the client instance's current organization ID. Calling `client.change_org_by_name` changes the active organization to the organization matching the provided name.
+Organization data is available through the roles attribute:
+
+Organization data can be found in the `roles` attribute 
+
+`client.roles['organizations']`
+
+Most API methods, such as get_orders() and create_user(), operate on the currently selected organization.
+```python
+    client = MeadowClient(
+        username=os.getenv("MEADOW_USERNAME"),
+        password=os.getenv("MEADOW_PASSWORD")
+    )
+
+    product_id = 12345
+    product_option_id = 678910
+    payment_type_id = 54321
+    patient_hash = '9mLifw'
+
+    order = {
+        "type": "in-store",
+        "status": "draft",
+        "lineItems": [{
+            "productId": product_id,
+            "productOptionId": product_option_id,
+            "quantity": 1
+        }],
+        "payments": [{
+            'paymentTypeId': payment_type_id,
+            'remaining': True,
+        }],
+        "patientHash": patient_hash
+    }
+    status_code, result = client.create_order(order)
+```

getmeadow-0.1.0/README.md

@@ -0,0 +1,56 @@
+# GetMeadow
+
+[API Documentation](https://api-docs.getmeadow.com/introduction)
+
+## Installation
+
+```bash
+pip install getmeadow
+```
+
+A Python client for the Meadow API built on `httpx` and `pydantic`
+
+GetMeadow uses Pydantic for request and response validation and currently supports username/password authentication.
+Many client methods return a two-item tuple containing the HTTP status code and the response data:
+
+```python
+status_code, data = client.get_orders()
+```
+
+## Organizations
+Organization handling works similarly to the Meadow web application.
+API URLs are generated using the client instance's current organization ID. Calling `client.change_org_by_name` changes the active organization to the organization matching the provided name.
+Organization data is available through the roles attribute:
+
+Organization data can be found in the `roles` attribute 
+
+`client.roles['organizations']`
+
+Most API methods, such as get_orders() and create_user(), operate on the currently selected organization.
+```python
+    client = MeadowClient(
+        username=os.getenv("MEADOW_USERNAME"),
+        password=os.getenv("MEADOW_PASSWORD")
+    )
+
+    product_id = 12345
+    product_option_id = 678910
+    payment_type_id = 54321
+    patient_hash = '9mLifw'
+
+    order = {
+        "type": "in-store",
+        "status": "draft",
+        "lineItems": [{
+            "productId": product_id,
+            "productOptionId": product_option_id,
+            "quantity": 1
+        }],
+        "payments": [{
+            'paymentTypeId': payment_type_id,
+            'remaining': True,
+        }],
+        "patientHash": patient_hash
+    }
+    status_code, result = client.create_order(order)
+```

getmeadow-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "getmeadow"
+version = "0.1.0"
+description = "Python client for the getmeadow api"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.28.1",
+    "pydantic>=2.13.4",
+]
+
+[[project.authors]]
+name = "Sebash"
+email = "sebash@mail.friendlyautomations.com"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=9.1.1"]

getmeadow-0.1.0/pyproject.toml.orig

@@ -0,0 +1,22 @@
+[project]
+name = "getmeadow"
+version = "0.1.0"
+description = "Python client for the getmeadow api"
+readme = "README.md"
+authors = [
+    { name = "Sebash", email = "sebash@mail.friendlyautomations.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.28.1",
+    "pydantic>=2.13.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

getmeadow-0.1.0/src/getmeadow/__init__.py

@@ -0,0 +1,5 @@
+from .client import MeadowClient
+from .endpoints import MeadowEndpoints, IamIntercomEndpoints
+from . import schemas
+
+__all__ = ['MeadowClient', 'MeadowEndpoints', 'IamIntercomEndpoints', 'schemas']

getmeadow-0.1.0/src/getmeadow/client.py

@@ -0,0 +1,664 @@
+import json
+from datetime import datetime
+import time
+from functools import wraps
+from http.client import RemoteDisconnected
+from typing import List, Optional, Literal
+from urllib.parse import quote
+import httpx
+
+
+from .endpoints import (
+    MeadowEndpoints, IamIntercomEndpoints
+)
+from .schemas import (
+    Order, NewUser, AWSDocumentRequest, MeadowNewDocument, Product,
+    Option, Reconciliation, UpdatePurchaseOrderLineItem,
+    ReceiveLineItem, CreatePurchaseOrderLineItem
+)
+from .exceptions import (
+    CreateUserException, CreateIDException, AuthenticationException, InvalidRequestException, ConnectionException,
+    ResponseParseException
+)
+
+
+
+def handle_disconnect(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        for attempt in range(5):
+            try:
+                return func(*args, **kwargs)
+
+            except httpx.TransportError as e:
+                print(f"HTTP error ({attempt + 1}/5): {e}")
+
+                if attempt < 4:
+                    time.sleep(0.25)
+
+        raise ConnectionException("Unable to maintain connection to API")
+
+    return wrapper
+
+
+
+class MeadowClient(httpx.Client):
+
+    def __init__(self, username=None, password=None, organization=None):
+        super().__init__()
+        if username and password:
+            self.username = username
+            self.password = password
+            status_code, login_res = self.login()
+            if status_code != 200:
+                raise AuthenticationException(str(login_res))
+            self.user_id = login_res["userId"]
+            self.application_id = login_res["applicationId"]
+            self.token = login_res["token"]
+            self.updated_at = login_res["updatedAt"]
+            self.created_at = login_res["createdAt"]
+            self.id = login_res["id"]
+            self.headers.update({"Authorization": f"token {self.token}"})
+            self.headers.update({"Accept": "application/vnd.meadow+json; version=1"})
+            # after login headers and tokens set
+            self.roles = self.get_roles()[1]
+            self.org_id = self.roles['organizations'][0]['id']
+        # elif api_key and client_key:
+        #     self.headers.update({"X-Consumer-Key":  api_key, "X-Client-Key": client_key})
+        else:
+            raise AuthenticationException("Username and password")
+
+        if organization:
+            self.change_org_by_name(organization)
+
+
+    @handle_disconnect
+    def post(self, *args, **kwargs) -> tuple[int, dict]:
+        s, r = MeadowClient._get_result_from_response(super().post(*args, **kwargs))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    @handle_disconnect
+    def get(self, *args, **kwargs) -> tuple[int, dict|list|bytes]:
+        return MeadowClient._get_result_from_response(super().get(*args, **kwargs))
+
+    @handle_disconnect
+    def put(self, *args, **kwargs) -> tuple[int, dict]:
+        s, r = MeadowClient._get_result_from_response(super().put(*args, **kwargs))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+
+    @handle_disconnect
+    def delete(self, *args, **kwargs) -> tuple[int, dict]:
+        s, r =  MeadowClient._get_result_from_response(super().put(*args, **kwargs))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    @staticmethod
+    def _get_result_from_response(response: httpx.Response) -> tuple[int, dict|bytes]:
+        try:
+            result_data = response.json()
+            if "data" in result_data:
+                result = result_data['data']
+            elif "error" in result_data:
+                result = result_data['error']
+            else:
+                result = result_data
+            return response.status_code, result
+        except:
+            return response.status_code, response.content
+
+
+
+    def login(self) -> tuple[int, dict]:
+        """
+        Logs the user in
+        :return: status code and response data
+        """
+        return self.put(
+            MeadowEndpoints.token,
+            json={"emailOrPhone": self.username, "password": self.password},
+        )
+
+    def create_brand(self, name: str) -> tuple[int, dict]:
+        """
+        creates a brand
+        :param name: name of the brand
+        :return: status code and response data
+        """
+        return self.post(MeadowEndpoints.brands.format(org_id=self.org_id), json={"name": name})
+
+    def get_users(self, starting_after_id=None, user_type="adult-use"):
+        params = {"type": user_type}
+        if starting_after_id is not None:
+            params['startingAfterId'] = starting_after_id
+        return self.get(MeadowEndpoints.users.format(org_id=self.org_id), params=params)
+
+
+    def get_brands(self) -> tuple[int, list]:
+        s, r = self.get(MeadowEndpoints.brands.format(org_id=self.org_id))
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_purchase_orders(self, starting_after: int | None = None)-> tuple[int, list]:
+        params = {}
+        if starting_after:
+            params['startingAfter'] = starting_after
+        s, r = self.get(MeadowEndpoints.purchase_orders.format(org_id=self.org_id), params=params)
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_purchase_order(self, po_id: int) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.purchase_order.format(org_id=self.org_id, po_id=po_id))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_product_categories(self) -> tuple[int, list]:
+        s, r = self.get(MeadowEndpoints.all_product_categories.format(org_id=self.org_id))
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_vendors(self) -> tuple[int, list]:
+        s, r = self.get(MeadowEndpoints.inventory_vendors.format(org_id=self.org_id))
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_vendor(self, vendor_id) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.inventory_vendor.format(org_id=self.org_id, vendor_id=vendor_id))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_compliance_transfer(self, compliance_transfer_id) -> tuple[int, dict]:
+        s, r =  self.get(MeadowEndpoints.compliance_transfer.format(org_id=self.org_id, compliance_transfer_id=compliance_transfer_id))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_compliance_transfers(self, package_status: str = "ready") -> tuple[int, list]:
+        params = {"packageStatus": package_status}
+        s, r = self.get(MeadowEndpoints.compliance_transfers.format(org_id=self.org_id), params=params)
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_packages(self, package_status="ready", include_product_data: bool = True) -> tuple[int, list]:
+        params = {"status": package_status, "includeProductData": include_product_data}
+        s, r = self.get(MeadowEndpoints.packages.format(org_id=self.org_id), params=params)
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_full(self) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.full.format(org_id=self.org_id))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_inventory_locations(self) -> tuple[int, list]:
+        s, r = self.get(MeadowEndpoints.inventory_locations.format(org_id=self.org_id))
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_my_user_data(self) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.me)
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_roles(self) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.roles)
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+    def get_pusher_auth(self, socket_id, channel_name="private-marketing-1493"):
+        return self.post(
+            MeadowEndpoints.pusher_auth,
+            data={
+                "channel_name": channel_name,
+                "socket_id": socket_id
+            }
+        )[1]['auth']
+
+    def get_iam_data(self) -> tuple[int, dict]:
+        _, user_data = self.get_my_user_data()
+        _, roles = self.get_roles()
+        return self.post(IamIntercomEndpoints.web_ping,
+                         data={
+                             "app_id": "",
+                             "platform": "web",
+                             "installation_type": "js-snippet",
+                             "internal": "{}",
+                             "is_intersection_booted": "false",
+                             "page_title": "Meadow",
+                             "user_active_company_id": "undefined",
+                             "user_data": json.dumps({
+                                 "email": user_data["email"],
+                                 "user_id": user_data["hashId"],
+                                 "user_hash": roles['intercomUserHash'],
+                                 "name": "Sebastian Campos"
+                             }),
+                             "source": "apiBoot",
+                             "sampling": "false",
+                             "referer": "https://admin.getmeadow.com/",
+                         })
+
+    def get_orders(
+            self,
+            status: Literal["draft", "new", "packed", "fulfilled", "canceled", "all"] = "new"
+    ) -> tuple[int, list]:
+
+        s, r = self.get(MeadowEndpoints.orders.format(org_id=self.org_id), params={"status": status})
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+    def get_order(self, order_id: int) -> tuple[int, dict]:
+        s, r = self.get(MeadowEndpoints.orders.format(org_id=self.org_id) + "/" + str(order_id))
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `dict` instance in response")
+        return s, r
+
+
+    def get_purchase_order_payments(self, po_id: int) -> tuple[int, list]:
+        s, r = self.get(MeadowEndpoints.purchase_order_payment.format(org_id=self.org_id, po_id=po_id))
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+
+    def update_order_status(self, order_id, status: Literal["new", "packed", "fulfilled"], is_admin=True) -> tuple[int, dict]:
+        payload = {}
+        if is_admin:
+            payload['isAdmin'] = is_admin
+        if status == "canceled":
+            raise InvalidRequestException("Invalid status Use client.cancel_order instead")
+        payload['status'] = status
+        return self.put(MeadowEndpoints.order.format(org_id=self.org_id, order_id=order_id), json=payload)
+
+
+    def create_product_category(self, name: str, cannabis_type: str) -> tuple[int, dict]:
+        return self.post(
+            MeadowEndpoints.product_categories.format(org_id=self.org_id),
+            json={"name": name, "cannabisType": cannabis_type},
+        )
+
+    def create_vendor(
+            self,
+            name,
+            seller_permit_number,
+            notes,
+            street1,
+            postal_code,
+            city,
+            state,
+            phone = "",
+            street2 = "",
+
+    )-> tuple[int, dict]:
+        payload = {
+            "name": name,
+            "sellerPermitNumber": seller_permit_number,
+            "notes": notes,
+            "phone": phone,
+            "street1": street1,
+            "postalCode": postal_code,
+            "city": city,
+            "state": state,
+        }
+        if street2:
+            payload['street2'] = street2
+        return self.post(MeadowEndpoints.vendors.format(org_id=self.org_id), json=payload)
+
+
+    def create_product(self, product: dict | Product) -> tuple[int, dict]:
+        if isinstance(product, dict):
+            product = Product(**product)
+        return self.post(MeadowEndpoints.products.format(org_id=self.org_id), json=product.model_dump(by_alias=True))
+
+    def create_purchase_order(
+            self,
+            inventory_vendor_id: int,
+            expected_at: str,
+            line_items: List[dict | CreatePurchaseOrderLineItem],
+            external_invoice_number: Optional[str] = None,
+            payment_terms_due_date: Optional[str] = None,
+            shipping_handling_fee: Optional[int] = 0,
+            shipping_handling_fee_excise: Optional[int] = 0
+    ) -> tuple[int, dict]:
+        line_items = [
+            CreatePurchaseOrderLineItem(**i).model_dump(by_alias=True) if isinstance(i, dict) else i.model_dump(by_alias=True)
+            for i in line_items
+        ]
+        payload = {
+            "inventoryVendorId": inventory_vendor_id,
+            "expectedAt": expected_at,
+            "paymentTermsDueDate": payment_terms_due_date,
+            "externalInvoiceNumber": external_invoice_number,
+            "shippingHandlingFee": shipping_handling_fee,
+            "shippingHandlingFeeExcise": shipping_handling_fee_excise,
+            "lineItems": line_items
+        }
+        return self.post(
+            MeadowEndpoints.purchase_orders.format(org_id=self.org_id), json=payload
+        )
+
+    def update_purchase_order(
+            self,
+            po_number: int,
+            inventory_vendor_id: int,
+            expected_at: str,
+            line_items: List[dict | UpdatePurchaseOrderLineItem],
+            payment_status: str = "unpaid",
+            payment_terms: Optional[str] = None,
+            external_invoice_number: Optional[str] = None,
+            payment_terms_due_date: Optional[str] = None,
+            shipping_handling_fee: Optional[int] = 0,
+            shipping_handling_fee_excise: Optional[int] = 0,
+            notes: Optional[str] = None,
+            status: str = "open"
+    ) -> tuple[int, dict]:
+        line_items = [
+            UpdatePurchaseOrderLineItem(**i).model_dump(by_alias=True) if isinstance(i, dict) else i.model_dump(by_alias=True)
+            for i in line_items
+        ]
+
+        payload = {
+            "inventoryVendorId": inventory_vendor_id,
+            "expectedAt": expected_at,
+            "paymentStatus": payment_status,
+            "paymentTerms": payment_terms,
+            "paymentTermsDueDate": payment_terms_due_date,
+            "notes": notes,
+            "externalInvoiceNumber": external_invoice_number,
+            "status": status,
+            "shippingHandlingFee": shipping_handling_fee,
+            "shippingHandlingFeeExcise": shipping_handling_fee_excise,
+            "lineItems": line_items
+        }
+        return self.put(
+            MeadowEndpoints.purchase_order.format(org_id=self.org_id, po_id=po_number), json=payload
+        )
+
+    def receive_line_items(self, inventory_location_id: int, po_id: int, line_items: List[ReceiveLineItem | dict]) -> tuple[int, dict]:
+        line_items = [
+            ReceiveLineItem(**i).model_dump(by_alias=True, exclude_none=True) if isinstance(i, dict) else i.model_dump(by_alias=True, exclude_none=True)
+            for i in line_items
+        ]
+        payload = {
+            "inventoryLocationId": inventory_location_id,
+            "lineItems": line_items
+        }
+
+        return self.post(
+            MeadowEndpoints.purchase_order_receive.format(org_id=self.org_id, po_id=po_id), json=payload
+        )
+
+    def update_purchase_order_status(self, po_id: int, status: str):
+        payload = {"status": status}
+        return self.put(MeadowEndpoints.purchase_order.format(org_id=self.org_id, po_id=po_id), json=payload)
+
+    def post_purchase_order_payment(self, po_id: int, amount: int, payment_type: str, payment_date: Optional[str] = None):
+        payload = {"paymentDate":payment_date,"amount":amount, "paymentType": payment_type}
+        return self.post(MeadowEndpoints.purchase_order_payment.format(org_id=self.org_id, po_id=po_id), json=payload)
+
+    def metrc_refresh(self) -> tuple[int, dict]:
+        return self.post(MeadowEndpoints.metrc_compliance_transfer_sync.format(org_id=self.org_id))
+
+
+    def change_org_by_name(self, name: str):
+        organizations = self.roles['organizations']
+        if new_org_context := next(filter(lambda o: o['name'] == name, organizations), None):
+            self.org_id = new_org_context['id']
+        else:
+            raise InvalidRequestException(f"Name: {name}, not found in {', '.join([i['name'] for i in organizations])}")
+
+    def get_reports(self, status="new") -> tuple[int, list]:
+        s, r =  self.get(MeadowEndpoints.reports.format(org_id=self.org_id), params={"status": status})
+        if not isinstance(r, list):
+            raise ResponseParseException("Expected a `list` from this endpoint")
+        return s, r
+
+    def download_report(self, report_id: int) -> bytes:
+        _, url = self.get(MeadowEndpoints.reports.format(org_id=self.org_id) + f"/{report_id}/url")
+        if not isinstance(url, bytes):
+            raise ResponseParseException("Expected a `str` from this endpoint")
+        r = httpx.get(url.decode())
+        return r.content
+
+    def get_user_data(self, user_id):
+        return self.get(MeadowEndpoints.users.format(org_id=self.org_id) + "/" + str(user_id))
+
+    def get_recent_user_addresses(self, user_id):
+        return self.get(MeadowEndpoints.recent_address.format(org_id=self.org_id, user_id=user_id))
+
+    def cancel_order(self, order_id, cancel_msg: str, adjust_shift: bool = False):
+        payload = {"cancelationReason": cancel_msg, "adjustShift": adjust_shift, "status": "canceled"}
+        return self.put(MeadowEndpoints.orders.format(org_id=self.org_id) + "/" + order_id, json=payload)
+
+    def create_order(self, meadow_order: Order | dict):
+        if isinstance(meadow_order, Order):
+            data = meadow_order.model_dump(by_alias=True, exclude_none=True)
+        else:
+            data = Order(**meadow_order).model_dump(by_alias=True, exclude_none=True)
+        return self.post(MeadowEndpoints.orders.format(org_id=self.org_id), json=data)
+
+    def create_user(self, meadow_user: dict | NewUser):
+        if isinstance(meadow_user, dict):
+            meadow_user = NewUser(**meadow_user)
+        status_code, result = self.post(MeadowEndpoints.users.format(org_id=self.org_id), json=meadow_user.model_dump(by_alias=True))
+        if status_code != 201:
+            print("Error creating order", result)
+            raise CreateUserException(f"{result}")
+        return result
+
+    def delete_document(self, document_id: int, user_id: int):
+        return self.delete(MeadowEndpoints.user_documents.format(org_id=self.org_id, user_id=user_id) + "/" + str(document_id))
+
+    def get_document(self, user_id, document_id) -> tuple[str, bytes]:
+        _, document = self.get(
+            MeadowEndpoints.user_documents.format(org_id=self.org_id, user_id=user_id) + f'/{document_id}',
+        )
+        if not isinstance(document, dict):
+            raise ResponseParseException("Expected a `dict` from this endpoint")
+        s3_url = document['signedUrl']
+        mime_type = document['mime']
+        doc_bytes = httpx.get(s3_url).content
+        return mime_type, doc_bytes
+
+    def upload_document(
+            self,
+            document: dict | AWSDocumentRequest,
+            document_type_id: int,
+            image: bytes,
+            user_id: int,
+            mime_type: str
+    ) -> tuple[int, dict]:
+        if isinstance(document, dict):
+            document = AWSDocumentRequest(**document).model_dump(by_alias=True, exclude_none=True)
+        else:
+            document = document.model_dump(by_alias=True, exclude_none=True)
+
+        _, signed_res = self.post(MeadowEndpoints.sign_s3.format(org_id=self.org_id), json=document)
+        url = signed_res['signedRequest']['url']
+        payload = signed_res['signedRequest']['fields']
+        files = {'file': ('test.jpg', image, mime_type)}
+        image_post_res = httpx.post(url, data=payload, files=files)
+        if image_post_res.status_code != 204:
+            raise CreateIDException(str(image_post_res.content.decode()))
+        meadow_doc = MeadowNewDocument(
+            documentTypeId=document_type_id,
+            path=signed_res['path'],
+            mime=mime_type
+        )
+        try_count = 0
+        while True:
+            try:
+                status_code, meadow_post = self.post(
+                    MeadowEndpoints.user_documents.format(org_id=self.org_id, user_id=user_id), json=meadow_doc.model_dump(by_alias=True),
+                )
+                if status_code != 201:
+                    raise CreateIDException(str(meadow_post))
+                return status_code, meadow_post
+            except (ConnectionAbortedError, RemoteDisconnected) as e:
+                time.sleep(3)
+                try_count += 1
+                if try_count >= 4:
+                    raise CreateIDException(str(e))
+
+
+    def delete_user(self, user_id):
+        current_timestamp = datetime.utcnow().strftime(
+            '%Y-%m-%dT%H:%M:%S.') + f"{int(datetime.utcnow().microsecond / 1000)}Z"
+        payload = {
+            "deletedAt": current_timestamp
+        }
+        return self.put(MeadowEndpoints.users.format(org_id=self.org_id) + f"/{user_id}", json=payload)
+
+    def search_users(self, query):
+        encoded_query = quote(query, safe="")
+        return self.get(MeadowEndpoints.user_search.format(org_id=self.org_id) + f"?query={encoded_query}")
+
+    def check_delivery_zone_address(self, address=None, lat_and_lng=None):
+        payload = {"address": address}
+        if lat_and_lng:
+            payload = {"latLng": lat_and_lng}
+        s, r = self.post(MeadowEndpoints.delivery_zone_addresses.format(org_id=self.org_id), json=payload)
+        return s, r
+
+    def post_pricing(
+            self,
+            patient_hash,
+            line_items: list[dict],
+            tax_exempt: bool,
+            delivery_zone_id: int | None,
+            order_type: str
+    ):
+        pricing = {
+            "adjustments": [],
+            "discounts": [],
+            "lineItems": line_items,
+            "patientHash": patient_hash,
+            "payments": [],
+            "allowEmpty": True,
+            "isAdmin": False,
+            "taxExempt": tax_exempt,
+            "deliveryZoneId": delivery_zone_id,
+            "type": order_type
+        }
+        return self.post(MeadowEndpoints.pricing.format(org_id=self.org_id), json=pricing)
+
+    @staticmethod
+    def check_inventory_options(inventory_id, line_item):
+        options = line_item['options']
+        for o in options:
+            for lc in o['locationInventory']:
+                if lc['inventoryLocationId'] == inventory_id and lc['maxQuantity'] > 0:
+                    return True
+        return False
+
+    @staticmethod
+    def set_inventory_stock_value(inventory_id, line_item):
+        options = line_item['options']
+        line_item['in_stock'] = False
+        for o in options:
+            for lc in o['locationInventory']:
+                if lc['inventoryLocationId'] == inventory_id and lc['maxQuantity'] > 0:
+                    line_item['in_stock'] = True
+        return line_item
+
+    def get_inventory(
+            self,
+            inventory_id = None,
+            include_archived: bool = True,
+            include_moving_average_cost_per_unit: bool = True,
+            include_threshold_status: bool = True,
+            include_compliance_item_names: bool = True,
+            filter_for_active: bool = True,
+            filter_for_in_stock: bool = False,
+            source="web-admin"
+    ) -> list[dict]:
+        payload = {
+            "includeArchived": "true" if include_archived else "false",
+            "includeMovingAverageCostPerUnit": "true" if include_moving_average_cost_per_unit else "false",
+            "includeThresholdStatus": "true" if include_threshold_status else "false",
+            "includeComplianceItemNames": "true" if include_compliance_item_names else "false",
+            "source": source
+        }
+        _, line_items = self.get(MeadowEndpoints.inventory.format(org_id=self.org_id), params=payload)
+        if not isinstance(line_items, list):
+            raise ResponseParseException("Expected `list` instance in response")
+        if filter_for_active:
+            line_items = list(filter(lambda l: l['isActive'], line_items))
+        if filter_for_in_stock and inventory_id:
+            line_items = list(filter(lambda l: MeadowClient.check_inventory_options(inventory_id, l), line_items))
+        if inventory_id:
+            line_items = [MeadowClient.set_inventory_stock_value(inventory_id, l) for l in line_items]
+        return line_items
+
+    def get_discounts(self):
+        return self.get(MeadowEndpoints.discounts.format(org_id=self.org_id))
+
+    def get_product(self, product_id):
+        return self.get(MeadowEndpoints.product.format(org_id=self.org_id, product_id=product_id))
+
+
+    def get_inventory_transactions(
+            self,
+            product_id: Optional[int] = None,
+            starting_after: Optional[str] = None,
+    ) -> tuple[int, dict]:
+        params = {}
+        if product_id:
+            params['productId'] = product_id
+        if starting_after:
+            params['startAfter'] = starting_after
+        s, r = self.get(MeadowEndpoints.inventory_transactions.format(org_id=self.org_id), params=params)
+        if not isinstance(r, dict):
+            raise ResponseParseException("Expected `list` instance in response")
+        return s, r
+
+
+    def delete_product(self, product_id):
+        current_timestamp = datetime.utcnow().strftime(
+            '%Y-%m-%dT%H:%M:%S.') + f"{int(datetime.utcnow().microsecond / 1000)}Z"
+        payload = {"deletedAt": current_timestamp}
+        return self.put(MeadowEndpoints.product.format(org_id=self.org_id, product_id=product_id), json=payload)
+
+    def update_product(self, product_id, product: dict | Product):
+        if isinstance(product, dict):
+            product = Product(**product)
+        return self.put(
+            MeadowEndpoints.product.format(org_id=self.org_id, product_id=product_id),
+            json=product.model_dump(by_alias=True, exclude_none=True)
+        )
+
+    def update_product_options(self, product_id, options: List[dict | Option], sales_price_unit = None):
+        options = [
+            Option(**o).model_dump(by_alias=True, exclude_none=True) if isinstance(o,dict) else o.model_dump(by_alias=True, exclude_none=True)
+            for o in options
+        ]
+        payload = {"options": options, "salesPriceUnit": sales_price_unit}
+        return self.put(
+            MeadowEndpoints.product_options.format(org_id=self.org_id, product_id=product_id),
+            json=payload
+        )
+
+    def create_reconciliation(self, reconciliation: dict | Reconciliation):
+        if isinstance(reconciliation, dict):
+            reconciliation = Reconciliation(**reconciliation)
+        return self.post(
+            MeadowEndpoints.reconciliations.format(org_id=self.org_id),
+            json=reconciliation.model_dump(by_alias=True)
+        )

getmeadow-0.1.0/src/getmeadow/endpoints.py

@@ -0,0 +1,44 @@
+class MeadowEndpoints:
+    token = "https://admin.getmeadow.com/api/users/tokens"
+    orders = "https://api.getmeadow.com/organizations/{org_id}/orders"
+    order = "https://api.getmeadow.com/organizations/{org_id}/orders/{order_id}"
+    pusher_auth = "https://api.getmeadow.com/pusher/auth"
+    me = "https://api.getmeadow.com/users/me"
+    roles = "https://api.getmeadow.com/users/me/roles"
+    reports = "https://api.getmeadow.com/organizations/{org_id}/reports"
+    inventory_locations = "https://api.getmeadow.com/organizations/{org_id}/inventory-locations"
+    inventory_vendors = "https://api.getmeadow.com/organizations/{org_id}/inventory-vendors"
+    inventory_vendor = "https://api.getmeadow.com/organizations/{org_id}/inventory-vendors/{vendor_id}"
+    inventory = "https://daffodil.getmeadow.com/organizations/{org_id}/products/all"
+    discounts = "https://api.getmeadow.com/organizations/{org_id}/discounts"
+    delivery_zone_addresses = "https://api.getmeadow.com/organizations/{org_id}/delivery-zones/addresses"
+    users = "https://api.getmeadow.com/organizations/{org_id}/users"
+    inventory_transactions = " https://api.getmeadow.com/organizations/{org_id}/inventory-transactions"
+    user_search = users + "/search"
+    full = "https://api.getmeadow.com/organizations/{org_id}/full"
+    user_documents = "https://api.getmeadow.com/organizations/{org_id}/users/{user_id}/documents"
+    recent_address = "https://api.getmeadow.com/organizations/{org_id}/users/{user_id}/addresses/recent"
+    pricing = "https://api.getmeadow.com/organizations/{org_id}/pricing"
+    create_customer = "https://admin.getmeadow.com/customers/create"
+    sign_s3 = "https://api.getmeadow.com/organizations/{org_id}/general/sign-s3"
+    prod_document = "https://s3.us-west-2.amazonaws.com/meadow-documents-production"
+    brands = "https://api.getmeadow.com/organizations/{org_id}/brands"
+    products = "https://api.getmeadow.com/organizations/{org_id}/products"
+    product = "https://api.getmeadow.com/organizations/{org_id}/products/{product_id}"
+    product_options = "https://api.getmeadow.com/organizations/{org_id}/products/{product_id}/options"
+    product_categories = "https://api.getmeadow.com/organizations/{org_id}/product-categories"
+    all_product_categories = product_categories + "/all"
+    purchase_orders = "https://api.getmeadow.com/organizations/{org_id}/purchase-orders"
+    purchase_order = "https://api.getmeadow.com/organizations/{org_id}/purchase-orders/{po_id}"
+    purchase_order_payment = "https://api.getmeadow.com/organizations/{org_id}/purchase-orders/{po_id}/payments"
+    purchase_order_receive = "https://api.getmeadow.com/organizations/{org_id}/purchase-orders/{po_id}/receive"
+    reconciliations = "https://api.getmeadow.com/organizations/{org_id}/reconciliations"
+    vendors = "https://api.getmeadow.com/organizations/{org_id}/inventory-vendors"
+    metrc_compliance_transfer_sync = "https://api.getmeadow.com/organizations/{org_id}/compliance-transfers/sync"
+    compliance_transfers = "https://api.getmeadow.com/organizations/{org_id}/compliance-transfers"
+    compliance_transfer = "https://api.getmeadow.com/organizations/{org_id}/compliance-transfers/{compliance_transfer_id}"
+    packages = "https://api.getmeadow.com/organizations/{org_id}/packages"
+
+
+class IamIntercomEndpoints:
+    web_ping = "https://api-iam.intercom.io/messenger/web/ping"

getmeadow-0.1.0/src/getmeadow/exceptions.py

@@ -0,0 +1,28 @@
+class CustomerNotFoundException(Exception):
+    pass
+
+
+class CreateOrderException(Exception):
+    pass
+
+
+class CreateUserException(Exception):
+    pass
+
+
+class CreateIDException(Exception):
+    pass
+
+
+class AuthenticationException(Exception):
+    pass
+
+class InvalidRequestException(Exception):
+    pass
+
+class ConnectionException(Exception):
+    pass
+
+
+class ResponseParseException(Exception):
+    pass

getmeadow-0.1.0/src/getmeadow/schemas.py

@@ -0,0 +1,184 @@
+from typing import List, Optional, Any, Dict, Literal
+from pydantic import BaseModel, Field
+
+
+class AWSDocumentRequest(BaseModel):
+    type: str
+    file_name: str = Field(..., alias="fileName")
+    file_type: str = Field(..., alias="fileType")
+
+
+class MeadowNewDocument(BaseModel):
+    document_type_id: int = Field(..., alias="documentTypeId")
+    path: str
+    mime: str
+
+
+class NewUser(BaseModel):
+    first_name: str = Field(..., alias="firstName")
+    last_name: str = Field(..., alias="lastName")
+    email: Optional[str]
+    phone: str
+
+
+class Payment(BaseModel):
+    payment_type_id: int = Field(..., alias="paymentTypeId")
+    remaining: bool = True
+
+
+class LineItem(BaseModel):
+    product_id: int = Field(..., alias="productId")
+    product_option_id: int = Field(..., alias="productOptionId")
+    quantity: Optional[int] = None
+    remove_discount_ids: List[Any] = Field(default_factory=list, alias="removeDiscountIds")
+    add_discount_ids: List[int] = Field(default_factory=list, alias="addDiscountIds")
+    custom_discounts: List[Any] = Field(default_factory=list, alias="customDiscounts")
+
+
+class Address(BaseModel):
+    street1: str
+    street2: Optional[str] = None
+    city: str
+    state: str
+    postal_code: str = Field(..., alias="postalCode")
+    county: Optional[str]
+
+
+class Order(BaseModel):
+    type: Literal["delivery", "in-store"]
+    payments: List[Payment]
+    adjustments: List[Any] = []
+    add_discount_ids: List[Any] = Field(default_factory=list, alias="addDiscountIds")
+    discount_codes: List[Any] = Field(default_factory=list, alias="discountCodes")
+    discount_limits: Dict[Any, Any] = Field(default_factory=dict, alias="discountLimits")
+    remove_discount_ids: List[Any] = Field(default_factory=list, alias="removeDiscountIds")
+    remove_discount_instances: Dict[Any, Any] = Field(default_factory=dict, alias="removeDiscountInstances")
+    admin_notes: Optional[str] = Field(None, alias="adminNotes")
+
+    #discounts: List[Any] = []
+    delivery_zone_id: Optional[int] = Field(None, alias="deliveryZoneId")
+    line_items: List[LineItem] = Field(..., alias="lineItems")
+    patient_hash: str = Field(..., alias="patientHash")
+    status: Optional[str]
+    source: str = 'web-admin'
+    is_admin: bool = Field(True, alias="isAdmin")
+    tax_exempt: bool = Field(False, alias="taxExempt")
+    inventory_location_id: Any = Field(None, alias="inventoryLocationId")
+    address: Optional[Address] = None
+
+class Option(BaseModel):
+    amount: int | float = 1
+    content: Optional[str] = None
+    name: str = ''
+    weedmaps_v2_verified_variant: Optional[Any] = Field(None, alias="weedmapsV2VerifiedVariant")
+    price: int | float
+    sales_price: Optional[Any] = Field(..., alias="salesPrice")
+    id: Optional[Any] = None
+
+class Product(BaseModel):
+    name: str
+    strain_type: str = Field(..., alias="strainType")
+    category: str
+    weedmaps_category_id: Optional[int] = Field(default=None, alias='weedmapsCategoryId')
+    sub_categories: List[Any] = Field(default_factory=list, alias="subCategories")
+    tags: List[Any] = Field(default_factory=list, alias="tags")
+    compounds: Optional[Dict[Any, Any]] = Field(default_factory=dict, alias="compounds")
+    unit: str
+    brand_id: Optional[int] = Field(None, alias="brandId")
+    sales_price_unit: Optional[Any] = Field(None, alias='salesPriceUnit')
+    description: str = ''
+    is_active: bool = Field(..., alias="isActive")
+    is_featured: bool = Field(..., alias="isFeatured")
+    options: Optional[List[Option]] = Field(default_factory=list, alias="options")
+    pricing_tier_id: Optional[Any] = Field(None, alias='pricingTierId')
+    pricing_type: Optional[str] = Field(None, alias="pricingType")
+    photos: Optional[List[Any]] = Field(default_factory=list, alias="photos")
+    auto_import_compounds: Optional[Any] = Field(None, alias="autoImportCompounds")
+
+
+class ReconciliationLineItem(BaseModel):
+    amount: int
+    operation: str
+    package_id: Optional[Any] = Field(None, alias="packageId")
+    product_id: int = Field(..., alias="productId")
+    product_option_id: int = Field(..., alias="productOptionId")
+
+class Reconciliation(BaseModel):
+    inventory_location_id: int = Field(..., alias="inventoryLocationId")
+    line_items: List[ReconciliationLineItem] = Field(default_factory=list, alias="lineItems")
+    notes: str
+    compliance_notes: str = Field(..., alias="complianceNotes")
+    compliance_reason: str = Field(..., alias="complianceReason")
+
+class PurchaseOrder(BaseModel):
+    id: Optional[int]
+    organization_id: int
+    user_id: int = Field(..., alias="userId")
+    total_amount: str = Field(..., alias="totalAmount")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+    inventory_vendor_id: int = Field(..., alias="inventoryVendorId")
+    notes: Optional[Any] = None
+    subtotal: int
+    expected_at: str = Field(..., alias="expectedAt")
+    status: str
+    payment_status: str = Field(..., alias="paymentStatus")
+    payment_terms: Optional[Any] = Field(None, alias="paymentTerms")
+    payment_terms_due_date: Optional[Any] = Field(None, alias="paymentTermsDueDate")
+    total_amount_received: str = Field(..., alias="totalAmountReceived")
+    final_total: int = Field(..., alias="finalTotal")
+    ca_excise_total: int = Field(..., alias="caExciseTotal")
+    amount_paid: int = Field(..., alias="amountPaid")
+    amount_outstanding: int = Field(..., alias="amountOutstanding")
+    external_invoice_number: str = Field(..., alias="externalInvoiceNumber")
+    external_invoice_file_path: Optional[str] = Field(None, alias="externalInvoiceFilePath")
+    shipping_handling_fee: int = Field(..., alias="shippingHandlingFee")
+    shipping_handling_fee_excise: int = Field(..., alias="shippingHandlingFeeExcise")
+    api_consumer_id: Optional[Any] = Field(None, alias="apiConsumerId")
+    is_overdue: bool = Field(..., alias="isOverdue")
+    inventory_vendor: Optional[Any] = Field(None, alias="inventoryVendor")
+    line_items: List[LineItem] = Field(default_factory=list, alias="lineItems")
+
+
+class ReceiveLineItem(BaseModel):
+    amount: int
+    purchase_order_line_item_id: int = Field(..., alias="purchaseOrderLineItemId")
+    package_id: Optional[int] = Field(..., alias="packageId")
+    expirationDate: Optional[str] = Field(..., alias="expirationDate")
+    multiplier: Optional[str] = Field(..., alias="multiplier")
+    thcPercent: Optional[str] = Field(..., alias="thcPercent")
+    thcMg: Optional[str] = Field(None, alias="thcMg")
+    cbdPercent: Optional[str] = Field(None, alias="cbdPercent")
+    cbdMg: Optional[str] = Field(None, alias="cbdMg")
+    producerName: str = Field(..., alias="producerName")
+    producerLicense: str = Field(..., alias="producerLicense")
+    harvestDate: str = Field(..., alias="harvestDate")
+    harvestFacilityName: str = Field(..., alias="harvestFacilityName")
+    itemStrain: Optional[str] = Field(..., alias="itemStrain")
+    labName: Optional[str] = Field(None, alias="labName")
+    labDate: Optional[str] = Field(None, alias="labDate")
+
+
+
+
+class CreatePurchaseOrderLineItem(BaseModel):
+    product_id: int = Field(..., alias="productId")
+    product_option_id: int = Field(..., alias="productOptionId")
+    amount: int
+    cost_per_unit: str = Field(..., alias="costPerUnit")
+    ca_excise_per_unit: int = Field(0, alias="caExcisePerUnit")
+    ca_excise_override: Optional[bool] = Field(False, alias="caExciseOverride")
+    tmp_id: Optional[str] = Field(None, alias="tmpId")
+    compliance_item_name: Optional[str] = Field(None, alias="complianceItemName")
+
+
+class UpdatePurchaseOrderLineItem(BaseModel):
+    id: Optional[int] = Field(None, alias="id")
+    product_id: int = Field(..., alias="productId")
+    product_option_id: int = Field(..., alias="productOptionId")
+    amount: int
+    cost_per_unit: str = Field(..., alias="costPerUnit")
+    ca_excise_per_unit: int = Field(0, alias="caExcisePerUnit")
+    ca_excise_override: Optional[bool] = Field(False, alias="caExciseOverride")
+    tmp_id: Optional[str] = Field(None, alias="tmpId")
+    compliance_item_name: Optional[str] = Field(None, alias="complianceItemName")