mphapi 0.5.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

mphapi/claim.py

@@ -60,6 +60,9 @@ class Provider(BaseModel):
     npi: str
     """National Provider Identifier of the provider (from NM109, required)"""
 
+    ccn: Optional[str] = None
+    """CMS Certification Number (optional)"""
+
     provider_tax_id: Annotated[Optional[str], field_name("providerTaxID")] = None
     """City of the provider (from N401, highly recommended)"""
 
@@ -195,8 +198,6 @@ class Service(BaseModel):
     procedure_code: Optional[str] = None
     """Procedure code (from SV101_02 / SV202_02)"""
 
-    hipps_code: Optional[str] = None
-
     procedure_modifiers: Optional[list[str]] = None
     """Procedure modifiers (from SV101_03, 4, 5, 6 / SV202_03, 4, 5, 6)"""
 
@@ -334,12 +335,6 @@ class RateSheetService(BaseModel):
     procedure_modifiers: Optional[list[str]] = None
     """Procedure modifiers (from SV101_03, 4, 5, 6 / SV202_03, 4, 5, 6)"""
 
-    billed_amount: Optional[float] = None
-    """Billed charge for the service (from SV102 / SV203)"""
-
-    allowed_amount: Optional[float] = None
-    """Plan allowed amount for the service (non-EDI)"""
-
 
 class RateSheet(BaseModel):
     npi: str
@@ -375,14 +370,5 @@ class RateSheet(BaseModel):
     drg: Optional[str] = None
     """Diagnosis Related Group for inpatient services (from HI DR)"""
 
-    billed_amount: Optional[float] = None
-    """Billed amount from provider (from CLM02)"""
-
-    allowed_amount: Optional[float] = None
-    """Amount allowed by the plan for payment. Both member and plan responsibility (non-EDI)"""
-
-    paid_amount: Optional[float] = None
-    """Amount paid by the plan for the claim (non-EDI)"""
-
     services: Optional[list[RateSheetService]] = None
     """One or more services provided to the patient (from LX loop)"""

mphapi/client.py

@@ -1,11 +1,12 @@
 import urllib.parse
-from typing import Any, Mapping, Sequence
+from typing import Annotated, Any, Mapping, Optional, Sequence
 
 import requests
 from pydantic import BaseModel, StrictBool, TypeAdapter
 
 from .claim import Claim, RateSheet
-from .pricing import Pricing
+from .credentials import Credentials, get_credentials
+from .fields import camel_case_model_config, field_name
 from .response import Response, Responses
 
 Header = Mapping[str, str | bytes | None]
@@ -14,71 +15,139 @@ Header = Mapping[str, str | bytes | None]
 class PriceConfig(BaseModel):
     """PriceConfig is used to configure the behavior of the pricing API"""
 
-    price_zero_billed: StrictBool
+    model_config = camel_case_model_config
+
+    contract_ruleset: Optional[str] = None
+    """set to the name of the ruleset to use for contract pricing"""
+
+    price_zero_billed: Optional[StrictBool] = False
     """set to true to price claims with zero billed amounts (default is false)"""
 
-    is_commercial: StrictBool
-    """set to true to use commercial code crosswalks"""
+    is_commercial: Optional[StrictBool] = False
+    """set to true to crosswalk codes from commercial codes Medicare won't pay for to substitute codes they do pay for (e.g. 99201 to G0463)"""
 
-    disable_cost_based_reimbursement: StrictBool
-    """by default, the API will use cost-based reimbursement for MAC priced line-items. This is the best estimate we have for this proprietary pricing"""
+    disable_cost_based_reimbursement: Optional[StrictBool] = False
+    """set to true to disable cost-based reimbursement for line items paid as a percent of cost"""
 
-    use_commercial_synthetic_for_not_allowed: StrictBool
+    use_commercial_synthetic_for_not_allowed: Optional[StrictBool] = False
     """set to true to use a synthetic Medicare price for line-items that are not allowed by Medicare"""
 
-    use_drg_from_grouper: StrictBool
+    use_drg_from_grouper: Annotated[
+        Optional[StrictBool], field_name("useDRGFromGrouper")
+    ] = False
     """set to true to always use the DRG from the inpatient grouper"""
 
-    use_best_drg_price: StrictBool
+    use_best_drg_price: Annotated[StrictBool, field_name("useBestDRGPrice")]
     """set to true to use the best DRG price between the price on the claim and the price from the grouper"""
 
-    override_threshold: float
+    override_threshold: Optional[float] = 0
     """set to a value greater than 0 to allow the pricer flexibility to override NCCI edits and other overridable errors and return a price"""
 
-    include_edits: StrictBool
+    include_edits: Optional[StrictBool] = False
     """set to true to include edit details in the response"""
 
-    continue_on_edit_fail: StrictBool
+    continue_on_edit_fail: Optional[StrictBool] = False
     """set to true to continue to price the claim even if there are edit failures"""
 
-    continue_on_provider_match_fail: StrictBool
+    continue_on_provider_match_fail: Optional[StrictBool] = False
     """set to true to continue with a average provider for the geographic area if the provider cannot be matched"""
 
-    disable_machine_learning_estimates: StrictBool
+    disable_machine_learning_estimates: Optional[StrictBool] = False
     """set to true to disable machine learning estimates (applies to estimates only)"""
 
+    assume_impossible_anesthesia_units_are_minutes: Optional[StrictBool] = False
+    """set to true to divide impossible anesthesia units by 15 (max of 96 anesthesia units per day) (default is false)"""
+
+    fallback_to_max_anesthesia_units_per_day: Optional[StrictBool] = False
+    """set to true to fallback to the maximum anesthesia units per day (default is false which will error if there are more than 96 anesthesia units per day)"""
+
+    allow_partial_results: Optional[StrictBool] = False
+    """set to true to return partially repriced claims. This can be useful to get pricing on non-erroring line items, but should be used with caution"""
+
+
+# It may be a bit jarring to see these imports not at the top of the file. This is
+# intentional as `.pricing` depends on `PriceConfig`.
+from .pricing import ClaimStatus  # noqa: E402
+from .pricing import Pricing  # noqa: E402
+
 
 class Client:
-    url: str
+    api_url: str
     headers: Header
 
-    def __init__(self, apiKey: str, isTest: bool = False):
-        if isTest:
-            self.url = "https://api-test.myprice.health"
+    def __init__(
+        self,
+        apiKey: str,
+        isTest: bool = False,
+        api_url: str | None = None,
+        app_url: str | None = None,
+        app_api_key: str | None = None,
+        app_referer: str | None = None,
+        app_credentials: Credentials | None = None,
+    ):
+        if api_url is None:
+            if isTest:
+                self.api_url = "https://api-test.myprice.health"
+            else:
+                self.api_url = "https://api.myprice.health"
+        else:
+            self.api_url = api_url
+
+        if app_url is None:
+            if isTest:
+                self.app_url = "https://app-test.myprice.health"
+            else:
+                self.app_url = "https://app.myprice.health"
         else:
-            self.url = "https://api.myprice.health"
+            self.app_url = app_url
+
+        if (app_url is None) != (app_api_key is None) or (app_api_key is None) != (
+            app_referer is None
+        ):
+            raise Exception(
+                "app_url, app_api_key, and app_referer must be set in tandem"
+            )
+
+        self.app_api_key = app_api_key
+        self.app_credentials = app_credentials
+        self.app_referer = app_referer
+
+        if (
+            self.app_credentials is None
+            and app_api_key is not None
+            and app_referer is not None
+        ):
+            self.app_credentials = get_credentials(app_api_key, app_referer)
 
         self.headers = {"x-api-key": apiKey}
 
+    def _get_id_token(self) -> str:
+        if self.app_credentials is None:
+            raise Exception("App credentials must be set to run this!")
+
+        refreshed = self.app_credentials.refresh_if_needed()
+        if refreshed is not None:
+            self.app_credentials = refreshed
+
+        return self.app_credentials.id_token
+
     def _do_request(
         self,
-        path: str,
+        url: str,
         json: Any | None,
         method: str = "POST",
         headers: Header = {},
     ) -> requests.Response:
         return requests.request(
             method,
-            urllib.parse.urljoin(self.url, path),
+            url,
             json=json,
             headers={**self.headers, **headers},
         )
 
-    def _receive_response[
-        Model: BaseModel
-    ](
+    def _receive_response[Model: BaseModel](
         self,
-        path: str,
+        url: str,
         body: BaseModel,
         response_model: type[Model],
         method: str = "POST",
@@ -93,7 +162,7 @@ class Client:
         """
 
         response = self._do_request(
-            path,
+            url,
             body.model_dump(mode="json", by_alias=True, exclude_none=True),
             method,
             headers,
@@ -105,11 +174,44 @@ class Client:
             .result()
         )
 
-    def _receive_responses[
-        Model: BaseModel
-    ](
+    def _receive_api_response[Model: BaseModel](
+        self,
+        url: str,
+        body: BaseModel,
+        response_model: type[Model],
+        method: str = "POST",
+        headers: Header = {},
+    ) -> Model:
+        return self._receive_response(
+            urllib.parse.urljoin(self.api_url, url),
+            body,
+            response_model,
+            method,
+            headers,
+        )
+
+    def _receive_app_response[Model: BaseModel](
+        self,
+        url: str,
+        body: BaseModel,
+        response_model: type[Model],
+        method: str = "POST",
+        headers: Header = {},
+    ) -> Model:
+        id_token = self._get_id_token()
+
+        # TODO: Handle refreshing revoked credentials. It's unclear what the error will be unfortunately.
+        return self._receive_response(
+            urllib.parse.urljoin(self.app_url, url),
+            body,
+            response_model,
+            method,
+            {"Authorization": f"Bearer {id_token}", **headers},
+        )
+
+    def _receive_responses[Model: BaseModel](
         self,
-        path: str,
+        url: str,
         body: Sequence[BaseModel],
         response_model: type[Model],
         method: str = "POST",
@@ -124,7 +226,7 @@ class Client:
         """
 
         response = self._do_request(
-            path,
+            url,
             TypeAdapter(type(body)).dump_python(
                 body, mode="json", by_alias=True, exclude_none=True
             ),
@@ -138,6 +240,41 @@ class Client:
             .results()
         )
 
+    def _receive_api_responses[Model: BaseModel](
+        self,
+        url: str,
+        body: Sequence[BaseModel],
+        response_model: type[Model],
+        method: str = "POST",
+        headers: Header = {},
+    ) -> list[Model]:
+        return self._receive_responses(
+            urllib.parse.urljoin(self.api_url, url),
+            body,
+            response_model,
+            method,
+            headers,
+        )
+
+    def _receive_app_responses[Model: BaseModel](
+        self,
+        url: str,
+        body: Sequence[BaseModel],
+        response_model: type[Model],
+        method: str = "POST",
+        headers: Header = {},
+    ) -> list[Model]:
+        id_token = self._get_id_token()
+
+        # TODO: Handle refreshing revoked credentials. It's unclear what the error will be unfortunately.
+        return self._receive_responses(
+            urllib.parse.urljoin(self.app_url, url),
+            body,
+            response_model,
+            method,
+            {"Authorization": f"Bearer {id_token}", **headers},
+        )
+
     def estimate_rate_sheet(self, *inputs: RateSheet) -> list[Pricing]:
         """
         Raises:
@@ -147,7 +284,7 @@ class Client:
                 The error returned when the api returns an error.
         """
 
-        return self._receive_responses(
+        return self._receive_api_responses(
             "/v1/medicare/estimate/rate-sheet",
             inputs,
             Pricing,
@@ -162,7 +299,7 @@ class Client:
                 The error returned when the api returns an error.
         """
 
-        return self._receive_responses(
+        return self._receive_api_responses(
             "/v1/medicare/estimate/claims",
             inputs,
             Pricing,
@@ -179,7 +316,7 @@ class Client:
         """
 
         return self._receive_response(
-            "/v1/medicare/price/claim",
+            urllib.parse.urljoin(self.api_url, "/v1/medicare/price/claim"),
             input,
             Pricing,
             headers=self._get_price_headers(config),
@@ -194,7 +331,7 @@ class Client:
                 The error returned when the api returns an error.
         """
 
-        return self._receive_responses(
+        return self._receive_api_responses(
             "/v1/medicare/price/claims",
             input,
             Pricing,
@@ -215,7 +352,7 @@ class Client:
         if config.use_commercial_synthetic_for_not_allowed:
             headers["use-commercial-synthetic-for-not-allowed"] = "true"
 
-        if config.override_threshold > 0:
+        if config.override_threshold is not None and config.override_threshold > 0:
             headers["override-threshold"] = str(config.override_threshold)
 
         if config.include_edits:
@@ -237,3 +374,10 @@ class Client:
             headers["disable-machine-learning-estimates"] = "true"
 
         return headers
+
+    def insert_claim_status(self, claim_id: str, claim_status: ClaimStatus) -> None:
+        self._receive_app_response(
+            f"/v1/claim/{claim_id}/status",
+            claim_status,
+            BaseModel,
+        )

mphapi/client_test.py

@@ -0,0 +1,114 @@
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+# This import annoys Pylance for some reason.
+from pytest_snapshot.plugin import Snapshot  # type: ignore
+
+from .client import Claim, Client, PriceConfig
+from .credentials import Credentials, sign_in
+from .env import load_env
+from .pricing import ClaimStatus, PricedService, Pricing, status_new
+from .response import ResponseError
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests():
+    load_env()
+
+
+def test_client(snapshot: Snapshot):
+    api_key = os.getenv("MPH_API_KEY")
+    if api_key is None:
+        raise EnvironmentError("MPH_API_KEY must be set")
+
+    api_url = os.getenv("API_URL")
+    app_url = os.getenv("APP_URL")
+    app_api_key = os.getenv("FIREBASE_API_KEY")
+    if app_api_key is None:
+        raise Exception("FIREBASE_API_KEY must be set")
+
+    app_referer = os.getenv("FIREBASE_REFERER")
+    if app_referer is None:
+        raise Exception("FIREBASE_REFERER must be set")
+
+    app_credentials = Credentials(
+        api_key=app_api_key,
+        referer=app_referer,
+        credentials_path=Path("fake-credentials-path"),
+        email="test-user@mypricehealth.com",
+        # An id token with some minimal user info.
+        # Will not work if tested against a service that expects a real id token.
+        id_token="eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImFhYSI6dHJ1ZX0.eyJpc3MiOiJ0ZXN0IGlzc3VlciIsImVtYWlsIjoidGVzdC11c2VyQG15cHJpY2VoZWFsdGguY29tIiwic3ViIjoidGVzdCBzdWJqZWN0IiwiYXVkIjoidGVzdCBhdWRpZW5jZSIsImV4cCI6MCwiaWF0IjowLCJpZCI6IjEyMzQ1Njc4OTAiLCJyb2xlcyI6WyJBZG1pbiJdfQ.iCx0YI9L9qo7KCkIq1w58C0mBdiCDhikPZsM3Mx78j11Ln3WxWpAnm0IomIRfrDVU1JczW8OjSj5os7igp9fYufZwObLV5N5eDd9LmYtXs2EcO8EFHcM7HeHx6lnkT1GxX-4J_946WbIdHYnpLyoXLZF_MZNfEwsN1UBG6YdaRcwfhF9vJHt6YM7-IoOcHvdLiEWv06Y9eC0v--_R_x8GwjSrE0Z9EyZw3hMz94QZ5VgUf8e89NexeVGIoD4pUOHuYmNIx1ca_UTIOg81exhhnh4g190jUSer5582YJc5Hx7gts3DyizRmAK8Glcwhnc7WKvZDQaSjtbHzIARnUKtw",
+        refresh_token="fake-refresh-token",
+        expires_at=sys.float_info.max,
+    )
+
+    client = Client(
+        api_key,
+        api_url=api_url,
+        app_url=app_url,
+        app_api_key=app_api_key,
+        app_referer=app_referer,
+        app_credentials=app_credentials,
+    )
+
+    config = PriceConfig(
+        is_commercial=True,
+        disable_cost_based_reimbursement=False,
+        use_commercial_synthetic_for_not_allowed=True,
+        use_drg_from_grouper=False,
+        use_best_drg_price=True,
+        override_threshold=300,
+        include_edits=True,
+    )
+
+    tests = ["hcfa", "inpatient", "outpatient"]
+
+    for test in tests:
+        with open(f"testdata/{test}.json", "r") as f:
+            data = json.load(f)
+
+            claim = Claim.model_validate(data)
+            pricing = client.price(config, claim)
+
+            snapshot.assert_match(pricing.model_dump_json(indent=4), f"{test}.json")
+
+    try:
+        client.insert_claim_status(
+            "123",
+            ClaimStatus(
+                step=status_new.step,
+                status=status_new.status,
+                pricing=Pricing(services=[PricedService(line_number="6789")]),
+            ),
+        )
+    except ResponseError as response_error:
+        # The claim and line item won't exist in the database
+        assert (
+            response_error.detail
+            == "expected to insert 1 line item repricing rows but inserted 0"
+        )
+
+        pass
+
+
+def test_signin():
+    app_api_key = os.getenv("FIREBASE_API_KEY")
+    if app_api_key is None:
+        raise Exception("FIREBASE_API_KEY must be set")
+
+    test_user = os.getenv("FIREBASE_TEST_USER")
+    if test_user is None:
+        pytest.skip("Skipping because FIREBASE_TEST_USER is not set")
+
+    test_password = os.getenv("FIREBASE_TEST_PASSWORD")
+    if test_password is None:
+        pytest.skip("Skipping because FIREBASE_TEST_PASSWORD is not set")
+
+    credentials = sign_in(app_api_key, test_user, test_password)
+
+    assert credentials.email == test_user