mphapi 1.9.1__tar.gz → 1.12.1__tar.gz

{mphapi-1.9.1 → mphapi-1.12.1}/PKG-INFO

@@ -1,12 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: mphapi
-Version: 1.9.1
+Version: 1.12.1
 Summary: A Python interface to the MyPriceHealth API
 Author: David Archibald
 Author-email: davidarchibald@myprice.health
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: pydantic (>=2.6.4,<3.0.0)
-Requires-Dist: pytest (>=8.4.1,<9.0.0)
+Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)

{mphapi-1.9.1 → mphapi-1.12.1}/mphapi/client.py

@@ -5,6 +5,7 @@ import requests
 from pydantic import BaseModel, StrictBool, TypeAdapter
 
 from .claim import Claim, RateSheet
+from .credentials import Credentials, get_credentials
 from .fields import camel_case_model_config, field_name
 from .response import Response, Responses
 
@@ -64,43 +65,89 @@ class PriceConfig(BaseModel):
     """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 this import not at the top of the file. This is
+# 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, url: str | None = None):
-        if url is None:
+    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.url = "https://api-test.myprice.health"
+                self.app_url = "https://app-test.myprice.health"
             else:
-                self.url = "https://api.myprice.health"
+                self.app_url = "https://app.myprice.health"
         else:
-            self.url = url
+            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](
         self,
-        path: str,
+        url: str,
         body: BaseModel,
         response_model: type[Model],
         method: str = "POST",
@@ -115,7 +162,7 @@ class Client:
         """
 
         response = self._do_request(
-            path,
+            url,
             body.model_dump(mode="json", by_alias=True, exclude_none=True),
             method,
             headers,
@@ -127,9 +174,44 @@ class Client:
             .result()
         )
 
+    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",
@@ -144,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
             ),
@@ -158,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:
@@ -167,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,
@@ -182,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,
@@ -199,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),
@@ -214,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,
@@ -257,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-1.12.1/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.eyJpc3MiOiJ0ZXN0IGlzc3VlciIsImVtYWlsIjoidGVzdC11c2VyQG15cHJpY2VoZWFsdGguY29tIiwic3ViIjoidGVzdCBzdWJqZWN0IiwiYXVkIjoidGVzdCBhdWRpZW5jZSIsImV4cCI6MCwiaWF0IjowLCJsb2dpbl9pZCI6IjEyMzQ1Njc4OTAiLCJyb2xlcyI6WyJBZG1pbiJdfQ.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

mphapi-1.12.1/mphapi/credentials.py

@@ -0,0 +1,256 @@
+import getpass
+import json
+import os
+import time
+from pathlib import Path
+
+import requests
+from pydantic import BaseModel, Field, RootModel
+
+from .fields import camel_case_model_config
+
+
+class RawCredentials(BaseModel):
+    model_config = camel_case_model_config
+
+    email: str
+    id_token: str
+    refresh_token: str
+    expires_at: float
+
+    def store(
+        self, api_key: str, referer: str, credentials_path: Path
+    ) -> "Credentials":
+        stored_credentials = StoredCredentials(
+            api_key=api_key,
+            referer=referer,
+            email=self.email,
+            id_token=self.id_token,
+            refresh_token=self.refresh_token,
+            expires_at=self.expires_at,
+        )
+
+        os.makedirs(os.path.dirname(credentials_path), exist_ok=True)
+
+        with credentials_path.open("w+") as f:
+            json.dump(
+                stored_credentials.model_dump(
+                    mode="json", by_alias=True, exclude_none=True
+                ),
+                f,
+            )
+
+        return Credentials(
+            referer=referer,
+            credentials_path=credentials_path,
+            api_key=api_key,
+            email=stored_credentials.email,
+            id_token=stored_credentials.id_token,
+            refresh_token=stored_credentials.refresh_token,
+            expires_at=stored_credentials.expires_at,
+        )
+
+
+class StoredCredentials(RawCredentials):
+    api_key: str
+    referer: str
+
+
+class Credentials(StoredCredentials):
+    credentials_path: Path = Field(..., exclude=True)
+
+    def refresh_if_needed(self) -> "Credentials | None":
+        # # There's more than 5 minutes until the credentials need refreshing. Don't bother.
+        if self.expires_at > time.time() + 5 * 60:
+            return None
+
+        new_credentials = refresh_token(self.api_key, self.referer, self.refresh_token)
+        return new_credentials.store(self.api_key, self.referer, self.credentials_path)
+
+
+class GoogleException(Exception):
+    def __init__(self, message: str):
+        self.message = message
+
+
+class GoogleError(BaseModel):
+    code: int
+    message: str
+    # errors omitted as unused
+
+
+class GoogleResponseError(BaseModel):
+    model_config = camel_case_model_config
+
+    error: GoogleError
+
+    def to_exception(self) -> GoogleException:
+        return GoogleException(self.error.message)
+
+
+class GoogleResponse[Result: BaseModel](RootModel[Result | GoogleResponseError]):
+    pass
+
+
+class SignInResult(BaseModel):
+    """
+    The result of signing in.
+    See https://docs.cloud.google.com/identity-platform/docs/reference/rest/v1/accounts/signInWithPassword
+    """
+
+    model_config = camel_case_model_config
+
+    email: str
+    """The email of the authenticated user. Always present in the response."""
+
+    id_token: str
+    """An Identity Platform ID token for the authenticated user."""
+
+    refresh_token: str
+    """An Identity Platform refresh token for the authenticated user."""
+
+    expires_in: int
+    """The number of seconds until the Identity Platform ID token expires."""
+
+
+class RefreshTokenResult(BaseModel):
+    """
+    The result of refreshing a refresh_token.
+    See https://cloud.google.com/identity-platform/docs/use-rest-api#section-refresh-token
+    """
+
+    # NOT camelCase
+
+    expires_in: int
+    """The number of seconds in which the ID token expires."""
+
+    token_type: str
+    """The type of the refresh token, always "Bearer"."""
+
+    refresh_token: str
+    """The Identity Platform refresh token provided in the request or a new refresh token."""
+
+    id_token: str
+    """An Identity Platform ID token."""
+
+    user_id: str
+    """The uid corresponding to the provided ID token."""
+
+    project_id: str
+    """Your Google Cloud project ID."""
+
+
+def get_credentials(api_key: str, referer: str) -> Credentials:
+    credentials_path = get_credentials_path()
+
+    credentials = get_stored_credentials(credentials_path)
+    if credentials is not None:
+        try:
+            credentials.refresh_if_needed()
+        except GoogleException as e:
+            # `INVALID_ID_TOKEN` means the user must login again.
+            if e.message != "INVALID_ID_TOKEN":
+                raise e
+
+        return credentials
+
+    email = input("Email: ")
+    login_credentials: RawCredentials | None = None
+
+    while True:
+        try:
+            password = getpass.getpass("Password: ")
+            login_credentials = sign_in(api_key, email, password)
+            break
+        except GoogleException as e:
+            if e.message == "INVALID_PASSWORD":
+                continue
+
+            raise e
+
+    return login_credentials.store(api_key, referer, credentials_path)
+
+
+def get_credentials_path() -> Path:
+    home = Path.home()
+    return home.joinpath(".mph", "credentials.json")
+
+
+def get_stored_credentials(credentials_path: Path) -> Credentials | None:
+    try:
+        with credentials_path.open() as f:
+            credentials_json = json.load(f)
+            stored_credentials = StoredCredentials.model_validate(credentials_json)
+    except FileNotFoundError:
+        return None
+
+    credentials = Credentials(
+        email=stored_credentials.email,
+        id_token=stored_credentials.id_token,
+        refresh_token=stored_credentials.refresh_token,
+        expires_at=stored_credentials.expires_at,
+        api_key=stored_credentials.api_key,
+        referer=stored_credentials.referer,
+        credentials_path=credentials_path,
+    )
+
+    return credentials
+
+
+def refresh_token(api_key: str, referer: str, refresh_token: str) -> RawCredentials:
+    response = requests.post(
+        "https://securetoken.googleapis.com/v1/token",
+        data={"grant_type": "refresh_token", "refresh_token": refresh_token},
+        params={
+            "key": api_key,
+        },
+        headers={
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Referer": referer,
+        },
+    )
+
+    result = (
+        GoogleResponse[RefreshTokenResult].model_validate_json(response.content).root
+    )
+
+    if isinstance(result, GoogleResponseError):
+        raise result.to_exception()
+
+    return RawCredentials(
+        email="",
+        id_token=result.id_token,
+        refresh_token=result.refresh_token,
+        expires_at=time.time() + result.expires_in,
+    )
+
+
+def sign_in(api_key: str, email: str, password: str) -> RawCredentials:
+    response = requests.post(
+        "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword",
+        json={
+            "email": email,
+            "password": password,
+            "returnSecureToken": "true",
+        },
+        params={
+            "key": api_key,
+        },
+        headers={"Referer": "http://myprice.health"},
+    )
+
+    result = GoogleResponse[SignInResult].model_validate_json(response.content).root
+
+    if isinstance(result, GoogleResponseError):
+        raise result.to_exception()
+
+    sign_in_result = result
+
+    credentials = RawCredentials(
+        email=sign_in_result.email,
+        id_token=sign_in_result.id_token,
+        refresh_token=sign_in_result.refresh_token,
+        expires_at=time.time() + sign_in_result.expires_in,
+    )
+
+    return credentials

mphapi-1.12.1/mphapi/date.py

@@ -0,0 +1,125 @@
+from abc import abstractmethod
+from datetime import datetime as dt
+from datetime import tzinfo
+from typing import Any, ClassVar, Self, SupportsIndex
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+class AbstractDateTime:
+    format: ClassVar[str]
+    secondary_formats: ClassVar[list[str]] = []
+    datetime: dt
+
+    @classmethod
+    @abstractmethod
+    def from_datetime(cls, datetime: dt) -> Self:
+        pass
+
+    def __str__(self):
+        return self.datetime.strftime(self.format)
+
+    # Based off of this: https://docs.pydantic.dev/2.1/usage/types/custom/#handling-third-party-types
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        def to_datetime_cls(value: str) -> Self:
+            datetime: dt | None = None
+
+            if len(cls.secondary_formats) == 0:
+                datetime = dt.strptime(value, cls.format)
+            else:
+                formats = [cls.format, *cls.secondary_formats]
+                for format in formats:
+                    try:
+                        datetime = dt.strptime(value, format)
+                    except ValueError:
+                        continue
+
+                if datetime is None:
+                    raise ValueError(
+                        f"Could not parse date {repr(value)} with format {repr(cls.format)} or {repr(cls.secondary_formats)}"
+                    )
+
+            return cls.from_datetime(datetime)
+
+        from_str = core_schema.chain_schema(
+            [
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(to_datetime_cls),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=from_str,
+            python_schema=core_schema.union_schema(
+                [
+                    core_schema.is_instance_schema(cls),
+                    from_str,
+                ]
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda date: str(date)
+            ),
+        )
+
+
+class Date(AbstractDateTime):
+    """Date is a custom type for representing dates in the format YYYYMMDD"""
+
+    format = "%Y%m%d"
+
+    year: int
+    month: int
+    day: int
+
+    def __init__(self, year: int, month: int, day: int):
+        self.year = year
+        self.month = month
+        self.day = day
+        self.datetime = dt(year, month, day)
+
+    @classmethod
+    def from_datetime(cls, datetime: dt):
+        return cls(datetime.year, datetime.month, datetime.day)
+
+
+class DateTime(AbstractDateTime):
+    """DateTime is a custom type for representing dates"""
+
+    # `%f` is padded to 6 characters but should be 9 overall.
+    format = "%Y-%m-%d %H:%M:%S.000%f%z"
+
+    # Same constructor as datetime has.
+    def __init__(
+        self,
+        year: SupportsIndex,
+        month: SupportsIndex,
+        day: SupportsIndex,
+        hour: SupportsIndex = 0,
+        minute: SupportsIndex = 0,
+        second: SupportsIndex = 0,
+        microsecond: SupportsIndex = 0,
+        tzinfo: tzinfo | None = None,
+        *,
+        fold: int = 0,
+    ):
+        self.datetime = dt(
+            year, month, day, hour, minute, second, microsecond, tzinfo, fold=fold
+        )
+
+    @classmethod
+    def from_datetime(cls, datetime: dt):
+        return cls(
+            datetime.year,
+            datetime.month,
+            datetime.day,
+            datetime.hour,
+            datetime.minute,
+            datetime.second,
+            datetime.microsecond,
+            datetime.tzinfo,
+            fold=datetime.fold,
+        )

mphapi-1.12.1/mphapi/env.py

@@ -0,0 +1,24 @@
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+def load_env():
+    path = Path(__file__)
+    root_dir = None
+    env_file = None
+    for parent in path.parents:
+        root_dir = parent
+        env_file = root_dir.joinpath(".env")
+        if env_file.exists():
+            break
+
+    if root_dir is None:
+        print("No .env file found", file=sys.stderr)
+        return
+
+    print(f"Using .env from {repr(str(root_dir))}.")
+
+    load_dotenv(root_dir.joinpath(".env"))
+    load_dotenv(root_dir.joinpath(".env.local"))

{mphapi-1.9.1 → mphapi-1.12.1}/mphapi/pricing.py

@@ -4,6 +4,7 @@ from typing import Annotated, Optional
 from pydantic import BaseModel, Field
 
 from .client import PriceConfig
+from .date import DateTime
 from .fields import camel_case_model_config, field_name
 from .response import ResponseError
 
@@ -73,6 +74,7 @@ class MedicareSource(str, Enum):
     ManualPricing = "Manual Pricing"
     SNF = "SNF PPS"
     Synthetic = "Synthetic Medicare"
+    DMEFS = "DMEFS"
 
 
 class InpatientPriceDetail(BaseModel):
@@ -420,3 +422,137 @@ class Pricing(BaseModel):
 
     edit_error: Optional[ResponseError] = None
     """An error that occurred during some step of the pricing process"""
+
+
+class Step(str, Enum):
+    new = "New"
+    received = "Received"
+    pending = "Pending"
+    held = "Held"
+    error = "Error"
+    input_validated = "Input Validated"
+    provider_matched = "Provider Matched"
+    edit_complete = "Edit Complete"
+    medicare_priced = "Medicare Priced"
+    primary_allowed_priced = "Primary Allowed Priced"
+    network_allowed_priced = "Network Allowed Priced"
+    out_of_network = "Out of Network"
+    request_more_info = "Request More Info"
+    priced = "Priced"
+    returned = "Returned"
+
+
+class Status(str, Enum):
+    pending_claim_input_validation = "Claim Input Validation"
+    pending_claim_edit_review = "Claim Edit Review"
+    pending_provider_matching = "Provider Matching"
+    pending_medicare_review = "Medicare Review"
+    pending_medicare_calculation = "Medicare Calculation"
+    pending_primary_allowed_review = "Primary Allowed Review"
+    pending_network_allowed_review = "Network Allowed Review"
+    pending_primary_allowed_determination = "Primary Allowed Determination"
+    pending_network_allowed_determination = "Network Allowed Determination"
+
+
+class StepAndStatus(BaseModel):
+    model_config = camel_case_model_config
+
+    step: Step
+    status: Optional[Status] = None
+
+
+class ClaimStatus(StepAndStatus):
+    model_config = camel_case_model_config
+
+    updated_by: Optional[str] = None
+    updated_at: Optional[DateTime] = None
+    pricing: Optional[Pricing] = None
+    error: Optional[ResponseError] = None
+
+
+status_new = StepAndStatus(step=Step.new)
+"""created by TPA. We use the transaction date as a proxy for this date"""
+
+status_received = StepAndStatus(step=Step.received)
+"""received and ready for processing. This is modified date of the file we get from SFTP"""
+
+status_held = StepAndStatus(step=Step.held)
+"""held for various reasons"""
+
+status_error = StepAndStatus(step=Step.error)
+"""claim encountered an error during processing"""
+
+status_input_validated = StepAndStatus(step=Step.input_validated)
+"""claim input has been validated"""
+
+status_provider_matched = StepAndStatus(step=Step.provider_matched)
+"""providers in the claim have been matched to the provider system of record"""
+
+status_edit_complete = StepAndStatus(step=Step.edit_complete)
+"""claim has been edited and is ready for pricing"""
+
+status_medicare_priced = StepAndStatus(step=Step.medicare_priced)
+"""claim has been priced according to Medicare"""
+
+status_primary_allowed_priced = StepAndStatus(step=Step.primary_allowed_priced)
+"""claim has been priced according to the primary allowed amount (e.g. contract, RBP, etc.)"""
+
+status_network_allowed_priced = StepAndStatus(step=Step.network_allowed_priced)
+"""claim has been priced according to the allowed amount of the network"""
+
+status_out_of_network = StepAndStatus(step=Step.out_of_network)
+"""is out of network"""
+
+status_request_more_info = StepAndStatus(step=Step.request_more_info)
+"""return claim to trading partner for more information to enable correct processing"""
+
+status_priced = StepAndStatus(step=Step.priced)
+"""done pricing"""
+
+status_returned = StepAndStatus(step=Step.returned)
+"""returned to TPA"""
+
+status_pending_claim_input_validation = StepAndStatus(
+    step=Step.pending, status=Status.pending_claim_input_validation
+)
+"""waiting for claim input validation"""
+
+status_pending_claim_edit_review = StepAndStatus(
+    step=Step.pending, status=Status.pending_claim_edit_review
+)
+"""waiting for claim edit review"""
+
+status_pending_provider_matching = StepAndStatus(
+    step=Step.pending, status=Status.pending_provider_matching
+)
+"""waiting for provider matching"""
+
+status_pending_medicare_review = StepAndStatus(
+    step=Step.pending, status=Status.pending_medicare_review
+)
+"""waiting for Medicare amount review"""
+
+status_pending_medicare_calculation = StepAndStatus(
+    step=Step.pending, status=Status.pending_medicare_calculation
+)
+"""waiting for Medicare amount calculation"""
+
+status_pending_primary_allowed_review = StepAndStatus(
+    step=Step.pending, status=Status.pending_primary_allowed_review
+)
+"""waiting for primary allowed amount review"""
+
+status_pending_network_allowed_review = StepAndStatus(
+    step=Step.pending, status=Status.pending_network_allowed_review
+)
+"""waiting for network allowed amount review"""
+
+status_pending_primary_allowed_determination = StepAndStatus(
+    step=Step.pending, status=Status.pending_primary_allowed_determination
+)
+"""waiting for the primary allowed amount (e.g. contract, RBP rate, etc.) to be determined"""
+
+status_pending_network_allowed_determination = StepAndStatus(
+    step=Step.pending, status=Status.pending_network_allowed_determination
+)
+"""waiting for allowed amount from the network"""

{mphapi-1.9.1 → mphapi-1.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mphapi"
-version = "1.9.1"
+version = "1.12.1"
 description = "A Python interface to the MyPriceHealth API"
 authors = ["David Archibald <davidarchibald@myprice.health>"]
 
@@ -8,10 +8,16 @@ authors = ["David Archibald <davidarchibald@myprice.health>"]
 python = "^3.12"
 pydantic = "^2.6.4"
 requests = "^2.31.0"
-pytest = "^8.4.1"
+python-dotenv = "^1.1.1"
 
 [tool.poetry.group.dev.dependencies]
+pytest = "^8.4.1"
 pytest-snapshot = "^0.9.0"
+coverage = "^7.10.4"
+black = "^25.1.0"
+isort = "^6.0.1"
+flake8 = "^7.3.0"
+pyright = "^1.1.403"
 
 [build-system]
 requires = ["poetry-core"]

mphapi-1.9.1/mphapi/client_test.py

@@ -1,38 +0,0 @@
-import json
-import os
-
-# This import annoys Pylance for some reason.
-from pytest_snapshot.plugin import Snapshot  # type: ignore
-
-from . import Claim, Client, PriceConfig
-
-
-def test_client(snapshot: Snapshot):
-    api_key = os.getenv("API_KEY")
-    if api_key is None:
-        raise EnvironmentError("API_KEY must be set")
-
-    api_url = os.getenv("API_URL")
-
-    client = Client(api_key, url=api_url)
-
-    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")

mphapi-1.9.1/mphapi/date.py

@@ -1,51 +0,0 @@
-from datetime import datetime
-from typing import Any
-
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-
-
-class Date:
-    """Date is a custom type for representing dates in the format YYYYMMDD"""
-
-    year: int
-    month: int
-    day: int
-
-    def __init__(self, year: int, month: int, day: int):
-        self.year = year
-        self.month = month
-        self.day = day
-
-    def __str__(self):
-        return f"{self.year}{self.month:02d}{self.day:02d}"
-
-    # Based off of this: https://docs.pydantic.dev/2.1/usage/types/custom/#handling-third-party-types
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls, source_type: Any, handler: GetCoreSchemaHandler
-    ) -> CoreSchema:
-        def to_date(value: str) -> Date:
-            time = datetime.strptime(value, "%Y%m%d")
-
-            return Date(time.year, time.month, time.day)
-
-        from_str = core_schema.chain_schema(
-            [
-                core_schema.str_schema(),
-                core_schema.no_info_plain_validator_function(to_date),
-            ]
-        )
-
-        return core_schema.json_or_python_schema(
-            json_schema=from_str,
-            python_schema=core_schema.union_schema(
-                [
-                    core_schema.is_instance_schema(Date),
-                    from_str,
-                ]
-            ),
-            serialization=core_schema.plain_serializer_function_ser_schema(
-                lambda date: str(date)
-            ),
-        )