pybrightree 0.1.0__tar.gz

pybrightree-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: pybrightree
+Version: 0.1.0
+Summary: Python SOAP wrapper for Brightree
+Author: Nick
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: zeep>=4.3.1
+
+# pybrightree
+
+`pybrightree` is a Python SOAP wrapper for Brightree.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+The package installs as `pybrightree` and is imported as `brightree`.
+
+## Usage
+
+```python
+from brightree import Brightree
+
+bt = Brightree("username", "password")
+note = bt.Patient().PatientNoteFetchByKey(141508)
+```
+
+The package preserves the PHP wrapper's service accessor and SOAP method names so existing examples map cleanly.
+
+Examples are available in [examples/basic_usage.py](/Users/nicholascheek/code/Brightree-python/examples/basic_usage.py) and [examples/custom_config.py](/Users/nicholascheek/code/Brightree-python/examples/custom_config.py).

pybrightree-0.1.0/README.md

@@ -0,0 +1,24 @@
+# pybrightree
+
+`pybrightree` is a Python SOAP wrapper for Brightree.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+The package installs as `pybrightree` and is imported as `brightree`.
+
+## Usage
+
+```python
+from brightree import Brightree
+
+bt = Brightree("username", "password")
+note = bt.Patient().PatientNoteFetchByKey(141508)
+```
+
+The package preserves the PHP wrapper's service accessor and SOAP method names so existing examples map cleanly.
+
+Examples are available in [examples/basic_usage.py](/Users/nicholascheek/code/Brightree-python/examples/basic_usage.py) and [examples/custom_config.py](/Users/nicholascheek/code/Brightree-python/examples/custom_config.py).

pybrightree-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pybrightree"
+version = "0.1.0"
+description = "Python SOAP wrapper for Brightree"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Nick" }
+]
+dependencies = [
+  "zeep>=4.3.1"
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pybrightree-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pybrightree-0.1.0/src/brightree/__init__.py

@@ -0,0 +1,4 @@
+from .client import Brightree
+from .exceptions import BrightreeException
+
+__all__ = ["Brightree", "BrightreeException"]

pybrightree-0.1.0/src/brightree/client.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from .config import DEFAULT_SERVICES
+from .helpers import ArrayHelper
+from .services import (
+    CustomField,
+    Doctor,
+    Document,
+    Documentation,
+    Insurance,
+    Inventory,
+    Invoice,
+    Patient,
+    Pickup,
+    Pricing,
+    Reference,
+    SalesOrder,
+    Security,
+)
+
+
+class Brightree(ArrayHelper):
+    def __init__(self, username: str, password: str, config: dict | None = None, client_factory=None) -> None:
+        super().__init__()
+        merged_config = {"service": dict(DEFAULT_SERVICES)}
+        if config:
+            merged_config.update({key: value for key, value in config.items() if key != "service"})
+            if "service" in config:
+                merged_config["service"].update(config["service"])
+
+        self.info = {
+            "username": username,
+            "password": password,
+            "config": merged_config,
+        }
+        self._client_factory = client_factory
+
+    def _service(self, cls):
+        return cls(self.info, client_factory=self._client_factory)
+
+    def Patient(self):
+        return self._service(Patient)
+
+    def Doctor(self):
+        return self._service(Doctor)
+
+    def Document(self):
+        return self._service(Document)
+
+    def Documentation(self):
+        return self._service(Documentation)
+
+    def CustomField(self):
+        return self._service(CustomField)
+
+    def Insurance(self):
+        return self._service(Insurance)
+
+    def Inventory(self):
+        return self._service(Inventory)
+
+    def Pickup(self):
+        return self._service(Pickup)
+
+    def Reference(self):
+        return self._service(Reference)
+
+    def SalesOrder(self):
+        return self._service(SalesOrder)
+
+    def Pricing(self):
+        return self._service(Pricing)
+
+    def Security(self):
+        return self._service(Security)
+
+    def Invoice(self):
+        return self._service(Invoice)

pybrightree-0.1.0/src/brightree/config.py

@@ -0,0 +1,15 @@
+DEFAULT_SERVICES = {
+    "document": "https://webservices.brightree.net/v0100-2108/DocumentationService/DocumentManagementService.svc",
+    "patient": "https://webservices.brightree.net/v0100-2101/OrderEntryService/patientservice.svc",
+    "documentation": "https://webservices.brightree.net/v0100-2004/DocumentationService/DocumentationService.svc",
+    "custom": "https://webservices.brightree.net/v0100-1610/CustomFieldService/CustomFieldService.svc",
+    "insurance": "https://webservices.brightree.net/v0100-2310/OrderEntryService/InsuranceService.svc",
+    "reference": "https://webservices.brightree.net/v0100-2049/ReferenceDataService/ReferenceDataService.svc",
+    "doctor": "https://webservices.brightree.net/v0100-2406/DoctorService/DoctorService.svc",
+    "inventory": "https://webservices.brightree.net/v0100-2309/InventoryService/InventoryService.svc",
+    "pickup": "https://webservices.brightree.net/v0100-2007/OrderEntryService/PickupExchangeService.svc",
+    "salesorder": "https://webservices.brightree.net/v0100-2408/OrderEntryService/SalesOrderService.svc",
+    "invoice": "https://webservices.brightree.net/v0100-2409/InvoiceService/InvoiceService.svc",
+    "security": "https://webservices.brightree.net/v0100-2407/SecurityService/UserSecurityService.svc",
+    "pricing": "https://webservices.brightree.net/v0100-1908/InventoryService/PricingService.svc",
+}

pybrightree-0.1.0/src/brightree/exceptions.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+
+class BrightreeException(Exception):
+    def __init__(
+        self,
+        message: str,
+        code: int = 0,
+        *,
+        error_data=None,
+        request_data=None,
+        previous: Exception | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.error_data = error_data
+        self.request_data = request_data
+        self.previous = previous
+
+    @classmethod
+    def from_soap_fault(cls, fault: Exception, request_data=None) -> "BrightreeException":
+        message = getattr(fault, "message", str(fault))
+        code = getattr(fault, "code", 0) or 0
+        detail = getattr(fault, "detail", None)
+        return cls(message, code, error_data=detail, request_data=request_data, previous=fault)
+
+    @classmethod
+    def from_api_response(cls, response, request_data=None) -> "BrightreeException":
+        message = "API Error"
+        code = 0
+        error = getattr(response, "Error", None)
+        if error is not None:
+            message = getattr(error, "Message", message)
+            code = getattr(error, "Code", code) or 0
+        return cls(message, code, error_data=response, request_data=request_data)
+
+    @classmethod
+    def config_error(cls, message: str) -> "BrightreeException":
+        return cls(f"Configuration Error: {message}", 1000)
+
+    @classmethod
+    def auth_error(cls, message: str = "Authentication failed") -> "BrightreeException":
+        return cls(f"Authentication Error: {message}", 1001)
+
+    @classmethod
+    def param_error(cls, method: str, param: str) -> "BrightreeException":
+        return cls(f"Parameter Error: Required parameter '{param}' missing for method '{method}'", 1002)

pybrightree-0.1.0/src/brightree/helpers.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+
+class ArrayHelper:
+    def __init__(self) -> None:
+        self._search = {}
+        self._sort = {}
+        self._pages = {"page": 1}
+        self._page_size = {"pageSize": 10}
+
+    def search(self, search: dict) -> "ArrayHelper":
+        self._search = search
+        return self
+
+    def sort(self, sort: dict | None = None) -> "ArrayHelper":
+        self._sort = sort or {"SortParams": []}
+        return self
+
+    def pageSize(self, page_size: int = 10) -> "ArrayHelper":
+        self._page_size = {"pageSize": page_size}
+        return self
+
+    def page_size(self, page_size: int = 10) -> "ArrayHelper":
+        return self.pageSize(page_size)
+
+    def pages(self, pages: int = 1) -> "ArrayHelper":
+        self._pages = {"page": pages}
+        return self
+
+    def page(self, page_number: int = 1) -> "ArrayHelper":
+        return self.pages(page_number)
+
+    def build(self) -> dict:
+        if not self._sort:
+            self._sort = {"SortParams": []}
+        return {**self._search, **self._sort, **self._pages, **self._page_size}

pybrightree-0.1.0/src/brightree/services/__init__.py

@@ -0,0 +1,29 @@
+from .custom_field import CustomField
+from .doctor import Doctor
+from .document import Document
+from .documentation import Documentation
+from .insurance import Insurance
+from .inventory import Inventory
+from .invoice import Invoice
+from .patient import Patient
+from .pickup import Pickup
+from .pricing import Pricing
+from .reference import Reference
+from .sales_order import SalesOrder
+from .security import Security
+
+__all__ = [
+    "CustomField",
+    "Doctor",
+    "Document",
+    "Documentation",
+    "Insurance",
+    "Inventory",
+    "Invoice",
+    "Patient",
+    "Pickup",
+    "Pricing",
+    "Reference",
+    "SalesOrder",
+    "Security",
+]

pybrightree-0.1.0/src/brightree/services/base.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from ..config import DEFAULT_SERVICES
+from ..exceptions import BrightreeException
+from ..soap import ZeepSoapClient
+
+
+class BaseService:
+    service_name: str | None = None
+    methods: dict[str, bool] = {}
+    special_methods: dict[str, tuple[str, ...]] = {}
+
+    def __init__(self, info: dict[str, Any], client_factory=None) -> None:
+        self.info = info
+        self._client_factory = client_factory or ZeepSoapClient
+
+        service_name = self.get_service_name()
+        services = info.get("config", {}).get("service", {})
+        location = services.get(service_name)
+        if not location:
+            raise BrightreeException.config_error(f"{service_name.capitalize()} service URL not configured")
+
+        username = info.get("username", "")
+        password = info.get("password", "")
+        if not username or not password:
+            raise BrightreeException.auth_error("Authentication credentials not provided")
+
+        self.wsdl = f"{location}?singleWsdl"
+        self.location = location
+        self.username = username
+        self.password = password
+
+    def get_service_name(self) -> str:
+        if self.service_name:
+            return self.service_name
+        return self.__class__.__name__.lower()
+
+    def _create_client(self):
+        return self._client_factory(
+            wsdl=self.wsdl,
+            username=self.username,
+            password=self.password,
+            location=self.location,
+        )
+
+    def _api_call(self, method: str, params: dict[str, Any]) -> Any:
+        try:
+            client = self._create_client()
+            return client.call(method, params)
+        except BrightreeException:
+            raise
+        except Exception as exc:
+            raise BrightreeException.from_soap_fault(exc, {"method": method, "params": params}) from exc
+
+    @staticmethod
+    def _is_iterable(value: Any) -> bool:
+        return isinstance(value, Mapping) or (
+            isinstance(value, Iterable) and not isinstance(value, (str, bytes, bytearray))
+        )
+
+    @staticmethod
+    def _ensure_iterable(method: str, query: Any) -> None:
+        if not BaseService._is_iterable(query):
+            raise BrightreeException(f"Method {method} requires an iterable parameter", 1002)
+
+    def _call_with_query(self, method: str, query: Any) -> Any:
+        self._ensure_iterable(method, query)
+        return self._api_call(method, dict(query))
+
+    def _call_with_special(self, method: str, param_names: tuple[str, ...], *args: Any) -> Any:
+        params = {}
+        for index, param_name in enumerate(param_names):
+            if index >= len(args):
+                raise BrightreeException.param_error(method, param_name)
+            params[param_name] = args[index]
+        return self._api_call(method, params)
+
+    def __getattr__(self, name: str):
+        if name in self.methods:
+            if self.methods[name]:
+                return lambda query=None, _name=name: self._call_with_query(_name, query)
+            return lambda _name=name: self._api_call(_name, {})
+
+        if name in self.special_methods:
+            return lambda *args, _name=name: self._call_with_special(_name, self.special_methods[_name], *args)
+
+        raise AttributeError(name)
+
+
+def default_config() -> dict[str, dict[str, str]]:
+    return {"service": dict(DEFAULT_SERVICES)}

pybrightree-0.1.0/src/brightree/services/custom_field.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from .base import BaseService
+
+
+class CustomField(BaseService):
+    service_name = "custom"
+    methods = {
+        "CustomFieldValueSaveMultiple": True,
+    }
+    special_methods = {
+        "CustomFieldFetchAllByCategory": ("category", "includeInactive"),
+        "CustomFieldValueFetchAllByBrightreeID": ("brightreeID", "category"),
+    }
+
+    def CustomFieldFetchAllByCategory(self, category: str, includeInactive: int = 0):
+        return self._api_call(
+            "CustomFieldFetchAllByCategory",
+            {"category": category, "includeInactive": includeInactive},
+        )
+
+    def CustomFieldValueFetchAllByBrightreeID(self, brightree_id: int, category: str):
+        return self._api_call(
+            "CustomFieldValueFetchAllByBrightreeID",
+            {"brightreeID": brightree_id, "category": category},
+        )
+
+    def CustomFieldValueSaveMultiple(self, query):
+        return self._call_with_query("CustomFieldValueSaveMultiple", query)

pybrightree-0.1.0/src/brightree/services/doctor.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from .base import BaseService
+
+
+class Doctor(BaseService):
+    methods = {
+        "DoctorCreate": True,
+        "DoctorNoteCreate": True,
+        "DoctorNoteUpdate": True,
+        "DoctorSearch": True,
+        "DoctorUpdate": True,
+        "DoctorGroupFetchAll": False,
+        "FacilityFetchAll": False,
+        "FacilityGroupFetchAll": False,
+        "MarketingRepFetchAll": False,
+    }
+    special_methods = {
+        "AddDoctorReferralContact": ("DoctorBrightreeID", "ReferralContactBrightreeID"),
+        "DoctorFetchByBrightreeID": ("BrightreeID",),
+        "DoctorFetchByExternalID": ("ExternalID",),
+        "DoctorNoteFetchByKey": ("brightreeID",),
+        "DoctorNoteFetchByDoctor": ("brightreeID",),
+        "DoctorReferralContactsFetchByDoctorKey": ("DoctorBrightreeID",),
+        "RemoveDoctorReferralContact": ("DoctorBrightreeID", "ReferralContactBrightreeID"),
+    }
+
+    def AddDoctorReferralContact(self, doctor_brightree_id: int, referral_contact_brightree_id: int):
+        return self._api_call(
+            "AddDoctorReferralContact",
+            {
+                "DoctorBrightreeID": doctor_brightree_id,
+                "ReferralContactBrightreeID": referral_contact_brightree_id,
+            },
+        )
+
+    def DoctorCreate(self, query):
+        return self._call_with_query("DoctorCreate", query)
+
+    def DoctorFetchByBrightreeID(self, brightree_id: int):
+        return self._api_call("DoctorFetchByBrightreeID", {"BrightreeID": brightree_id})
+
+    def RemoveDoctorReferralContact(self, doctor_brightree_id: int, referral_contact_brightree_id: int):
+        return self._api_call(
+            "RemoveDoctorReferralContact",
+            {
+                "DoctorBrightreeID": doctor_brightree_id,
+                "ReferralContactBrightreeID": referral_contact_brightree_id,
+            },
+        )

pybrightree-0.1.0/src/brightree/services/document.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from ..exceptions import BrightreeException
+from .base import BaseService
+
+
+class Document(BaseService):
+    methods = {
+        "DocumentTypesFetchAll": False,
+        "DocumentBatchCreate": True,
+        "DocumentBatchSearch": True,
+        "DocumentPropertyUpdate": True,
+        "DocumentReviewUpdate": True,
+        "DocumentSearch": True,
+        "GenerateDocumentID": True,
+        "StoreDocument": True,
+    }
+    special_methods = {
+        "FetchDocumentContent": ("documentKey",),
+    }
+
+    def FetchDocumentContent(self, key: int = 12345):
+        if key <= 0:
+            raise BrightreeException(f"Invalid document key: {key}", 1003)
+        return self._api_call("FetchDocumentContent", {"documentKey": key})

pybrightree-0.1.0/src/brightree/services/documentation.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from ..exceptions import BrightreeException
+from .base import BaseService
+
+
+class Documentation(BaseService):
+    methods = {
+        "CMNCreateFromPatient": True,
+        "CMNDetailCreate": True,
+        "CMNDetailDelete": True,
+        "CMNDetailUpdate": True,
+        "CMNFetchByBrightreeID": True,
+        "CMNFetchByExternalID": True,
+        "CMNFetchByPatientBrightreeID": True,
+        "CMNFetchBySalesOrderBrightreeID": True,
+        "CMNFrequencyUpdate": True,
+        "CMNLog": True,
+        "CMNPreview": True,
+        "CMNPrint": True,
+        "CMNQuestionAnswerConfiguration": True,
+        "CMNReasonFetchAll": True,
+        "CMNRenew": True,
+        "CMNRevise": True,
+        "CMNSearch": True,
+        "CMNTaskCreate": True,
+        "CMNTaskUpdate": True,
+        "CMNUpdate": True,
+        "PARAddPurchaseLimit": True,
+        "PARCreateFromPatient": True,
+        "PARDelete": True,
+        "PARFetchByBrightreeID": True,
+        "PARFetchByExternalID": True,
+        "PARFetchByPatientBrightreeID": True,
+        "PARFetchBySalesOrderBrightreeID": True,
+        "PARFetchBySalesOrderTemplateBrightreeID": True,
+        "PARLog": True,
+        "PARRenew": True,
+        "PARSearch": True,
+        "PARTaskCreate": True,
+        "PARTaskUpdate": True,
+        "PARUpdate": True,
+        "PARUpdatePurchaseLimit": True,
+        "SalesOrderItemLinkCMN": True,
+        "SalesOrderItemLinkNewCMN": True,
+        "SalesOrderItemLinkToNewPAR": True,
+        "SalesOrderItemLinkToPAR": True,
+        "SalesOrderItemsLinkCMN": True,
+        "SalesOrderItemsLinkNewCMN": True,
+        "SalesOrderItemsLinkToNewPAR": True,
+        "SalesOrderItemsLinkToPAR": True,
+        "SalesOrderItemsUnlinkCMN": True,
+        "SalesOrderItemsUnlinkPAR": True,
+        "SalesOrderItemUnlinkCMN": True,
+        "SalesOrderItemUnlinkPAR": True,
+        "SalesOrderTemplateItemLinkToPAR": True,
+        "SalesOrderTemplateItemsLinkToPAR": True,
+        "SalesOrderTemplateItemsUnlinkPAR": True,
+        "SalesOrderTemplateItemUnlinkPAR": True,
+        "SetParticipantComplianceDate": True,
+        "PARTaskReasonFetchAll": False,
+    }
+    special_methods = {
+        "CMNFrequencyFetchbyBrightreeID": ("BrightreeID",),
+        "PARTaskFetchByPARBrightreeID": ("BrightreeID",),
+    }
+
+    def CMNFrequencyFetchbyBrightreeID(self, brightree_id: int):
+        if brightree_id <= 0:
+            raise BrightreeException(f"Invalid Brightree ID: {brightree_id}", 1003)
+        return self._api_call("CMNFrequencyFetchbyBrightreeID", {"BrightreeID": brightree_id})
+
+    def PARTaskFetchByPARBrightreeID(self, par_brightree_id: int):
+        if par_brightree_id <= 0:
+            raise BrightreeException(f"Invalid PAR Brightree ID: {par_brightree_id}", 1003)
+        return self._api_call("PARTaskFetchByPARBrightreeID", {"BrightreeID": par_brightree_id})
+
+    def PARTaskReasonFetchAll(self):
+        return self._api_call("PARTaskReasonFetchAll", {})