carestack 0.1.0__tar.gz

carestack-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: carestack
+Version: 0.1.0
+Summary: SDK for EHR Services
+Author-email: achalahealth <venkatesh.dakarapu@achalasolutions.com>
+Project-URL: Homepage, https://github.com/achalahealth/ehrsdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic[email]>=2.0.0
+Requires-Dist: typing_extensions
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: cryptography>=3.0
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: setuptools>=64; extra == "dev"
+Requires-Dist: wheel; extra == "dev"

carestack-0.1.0/carestack/ai/ai_dto.py

@@ -0,0 +1,8 @@
+from typing import Optional, List, Any
+from pydantic import BaseModel
+
+
+class ProcessDSDto(BaseModel):
+    case_type: str
+    files: List[str]
+    public_key: Optional[str] = None

carestack-0.1.0/carestack/ai/ai_service.py

@@ -0,0 +1,92 @@
+import logging
+from typing import Any, Type, Optional, List, Dict, TypeVar
+
+from pydantic import BaseModel, ValidationError
+
+from carestack.base.base_service import BaseService, GetJsonFromTextResponse
+from carestack.base.base_types import ClientConfig
+from carestack.base.errors import EhrApiError
+from .ai_dto import ProcessDSDto
+from .ai_utils import AiUtilities
+
+_DTO_T = TypeVar("_DTO_T", bound=BaseModel)
+
+
+class AiService(BaseService):
+    """
+    Service for AI-related operations, such as generating discharge summaries.
+    """
+
+    def __init__(self, config: ClientConfig):
+        super().__init__(config)
+        self.logger = logging.getLogger(__name__)
+        self.utilities = AiUtilities()
+
+    async def _validate_data(
+        self, dto_type: Type[_DTO_T], request_data: Dict[str, Any]
+    ) -> _DTO_T:
+        """
+        Validates dictionary data against a Pydantic model and returns the validated instance.
+        """
+        try:
+            validated_instance: _DTO_T = dto_type(**request_data)
+            return validated_instance
+        except ValidationError as err:
+            self.logger.error(
+                f"Pydantic validation failed: {err.errors()}", exc_info=True
+            )
+            raise EhrApiError(f"Validation failed: {err.errors()}", 400) from err
+
+    async def generate_discharge_summary(self, process_ds_data: Dict[str, Any]) -> str:
+        """
+        Generates a discharge summary based on the provided data.
+
+        Args:
+            process_ds_data: A dictionary containing data conforming to ProcessDSDto.
+                             Expected keys: 'files' (List[Any]), 'public_key' (Optional[str]).
+
+        Returns:
+            A string representing the generated discharge summary.
+
+        Raises:
+            EhrApiError: If validation fails, the API call returns an error, or an unexpected error occurs.
+        """
+        self.logger.info(
+            f"Starting generation of discharge summary with data: {process_ds_data}"
+        )
+        try:
+            process_ds_dto: ProcessDSDto = await self._validate_data(
+                ProcessDSDto, process_ds_data
+            )
+
+            encrypted_data = await self.utilities.encryption(process_ds_dto.files)
+
+            payload = {
+                "caseType": process_ds_dto.case_type,
+                "encryptedData": encrypted_data,
+            }
+
+            api_response: GetJsonFromTextResponse = await self.post(
+                "/demo/generate-discharge-summary",
+                payload,
+                response_model=GetJsonFromTextResponse,
+            )
+
+            return api_response.response
+
+        except EhrApiError as e:
+            self.logger.error(
+                f"EHR API Error during discharge summary generation: {e.message}",
+                exc_info=True,
+            )
+            raise
+        except Exception as error:
+            error_message = str(error)
+            self.logger.error(
+                f"Unexpected error in generate_discharge_summary: {error_message}",
+                exc_info=True,
+            )
+            raise EhrApiError(
+                f"An unexpected error occurred while generating discharge summary: {error_message}",
+                500,
+            ) from error

carestack-0.1.0/carestack/ai/ai_utils.py

@@ -0,0 +1,135 @@
+import logging
+from typing import List
+import json
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.backends import default_backend
+from jose import jwe, jwk
+from jose.constants import ALGORITHMS
+
+
+class AiUtilities:
+    """
+    A utility class for AI service specific operations like encryption/decryption.
+    """
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+    async def load_public_key_from_x509_certificate(self, certificate_pem: str) -> dict:
+        """
+        Loads an RSA public key from a PEM-encoded X.509 certificate and returns it as a JWK.
+        """
+        try:
+            cert = x509.load_pem_x509_certificate(
+                certificate_pem.encode("utf-8"), default_backend()
+            )
+            public_key = cert.public_key()
+
+            if not isinstance(public_key, rsa.RSAPublicKey):
+                raise ValueError("The certificate does not contain an RSA public key.")
+
+            public_pem = public_key.public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
+            )
+            jwk_object = jwk.construct(
+                public_pem.decode("utf-8"),  # public_pem is bytes, decode to string
+                algorithm=ALGORITHMS.RSA_OAEP_256,  # Specify the algorithm context
+            )
+            jwk_dict = jwk_object.to_dict()
+            return jwk_dict
+        except Exception as e:
+            self.logger.error(
+                f"Error loading public key from certificate: {e}", exc_info=True
+            )
+            raise RuntimeError(
+                f"Failed to load public key from certificate: {e}"
+            ) from e
+
+    async def encryption(self, files: List[str]) -> str:
+        """
+        Encrypts a list of file identifiers using JWE with an RSA public key.
+        """
+        try:
+            certificate_pem = (
+                "-----BEGIN CERTIFICATE-----\r\n"
+                "MIID6TCCAtECFCuFhek8z9Xvm+QpVXdvsVrC+/qSMA0GCSqGSIb3DQEBCwUAMIGw\r\n"
+                "MQswCQYDVQQGEwJJTjESMBAGA1UECAwJVGVsYW5nYW5hMRIwEAYDVQQHDAlIeWRl\r\n"
+                "cmFiYWQxJzAlBgNVBAoMHkFjaGFsYSBIZWFsdGggU2VydmljZXMgUHZ0IEx0ZDER\r\n"
+                "MA8GA1UECwwIU29mdHdhcmUxDzANBgNVBAMMBkFjaGFsYTEsMCoGCSqGSIb3DQEJ\r\n"
+                "ARYdamFnYW4udHVtdWxhQGFjaGFsYWhlYWx0aC5jb20wHhcNMjQxMTEzMTUzNzU0\r\n"
+                "WhcNMjQxMjEzMTUzNzU0WjCBsDELMAkGA1UEBhMCSU4xEjAQBgNVBAgMCVRlbGFu\r\n"
+                "Z2FuYTESMBAGA1UEBwwJSHlkZXJhYmFkMScwJQYDVQQKDB5BY2hhbGEgSGVhbHRo\r\n"
+                "IFNlcnZpY2VzIFB2dCBMdGQxETAPBgNVBAsMCFNvZnR3YXJlMQ8wDQYDVQQDDAZB\r\n"
+                "Y2hhbGExLDAqBgkqhkiG9w0BCQEWHWphZ2FuLnR1bXVsYUBhY2hhbGFoZWFsdGgu\r\n"
+                "Y29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAty+ydbqnP0gBp39y\r\n"
+                "xaFpdLHB9e+wQipf0j+IWW7dlKH1kDwdWLLzdb384vGTB6+Z31144xy+aku0I0e6\r\n"
+                "dCubNxKQFj3YFRZBgvlQo/YLRDulHkuJ35CzLdGTLk69Mmn0UAiz+ivaapfmqol+\r\n"
+                "U/51l1k7HLWGHAOeVHYLGUcxQTYaYzPecNRH7yn/OTweOZ6vzrQD4g2qzHmzYScP\r\n"
+                "+tiOsTg6Ri6bG72084eqXs5bUixClmsYpDq6Eoq5n9uPj+Q5tt98S3JSx1sGpRg2\r\n"
+                "KmdbV/xoQ39zMWSkIT8O2tuf5KdfLRvWtm+Q7Af1aQG2U4QedubS/rTCnjIq2AL9\r\n"
+                "eAWluQIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQA+GdQdGxGDzeAUkfy1iNWx2Wtr\r\n"
+                "oMGqpGSgeg5J8dzWcXdwH2Avxh7I9C4yletnuFeKQlCK5GHPvJ2GQCjQ7LEb01BU\r\n"
+                "NSJILwfCFMMkjw5COXVXAhp3fr894816YhGW/3+3L3TasKuEG96+bke4rN0yD0v+\r\n"
+                "braTqG+fY+hEwwls59jPBrhx97PDoI4RzKPbquAOCcxadJ3gelX0JibOmo9MZLtn\r\n"
+                "FhLPTZf8wWJLTdiUiuuiI2YS9/CyN3+pPzznMOEfPDK+593slPwCimubtYb+o/UT\r\n"
+                "88tKxqbPGNMWL4CUX9xPTLft8oBkC1OA8oF6kIV0LlJ6LarfhmrWg5BzQqKF\r\n"
+                "-----END CERTIFICATE-----\r\n"
+            )
+
+            # Load the public key as a JWK from the certificate
+            public_jwk = await self.load_public_key_from_x509_certificate(
+                certificate_pem
+            )
+
+            payload_bytes = json.dumps({"files": files}).encode("utf-8")
+
+            encrypted_payload = jwe.encrypt(
+                plaintext=payload_bytes,
+                key=public_jwk,  # Use the JWK dictionary
+                algorithm=ALGORITHMS.RSA_OAEP_256,
+                encryption=ALGORITHMS.A256GCM,
+                # 'zip', 'cty', 'kid' could be passed here if needed and supported
+            )
+            self.logger.debug("Encryption successful.")
+            return encrypted_payload.decode("utf-8")
+
+        except Exception as error:
+            self.logger.error(f"Failed to encrypt data: {error}", exc_info=True)
+            raise RuntimeError(f"Failed to encrypt data: {error}") from error
+
+    # async def decrypt_payload(self, encrypted_data: str, private_key_pem: str) -> Any:
+    #     """
+    #     Decrypts JWE encrypted data using a PEM-encoded RSA private key.
+    #     """
+    #     try:
+    #         private_key = serialization.load_pem_private_key(
+    #             private_key_pem.encode("utf-8"),
+    #             password=None,
+    #             backend=default_backend(),
+    #         )
+    #         if not isinstance(private_key, rsa.RSAPrivateKey):
+    #             raise ValueError("The provided key is not a valid RSA private key.")
+
+    #         # Construct a JWK from the private key for python-jose
+    #         # While python-jose might sometimes work with cryptography objects directly
+    #         # for decryption, using jwk.construct is more robust.
+    #         private_key_pem_bytes = private_key.private_bytes(
+    #             encoding=serialization.Encoding.PEM,
+    #             format=serialization.PrivateFormat.PKCS8,
+    #             encryption_algorithm=serialization.NoEncryption(),
+    #         )
+    #         key_jwk = jwk.construct(
+    #             private_key_pem_bytes.decode("utf-8"),
+    #             algorithm=ALGORITHMS.RSA_OAEP_256,
+    #         )
+    #         decrypted_payload_bytes = jwe.decrypt(
+    #             encrypted_data.encode("utf-8"), key_jwk
+    #         )
+    #         self.logger.debug("Decryption successful.")
+    #         return json.loads(decrypted_payload_bytes.decode("utf-8"))
+    #     except Exception as error:
+    #         self.logger.error(f"Failed to decrypt data: {error}", exc_info=True)
+    #         raise RuntimeError(f"Failed to decrypt data: {error}") from error

carestack-0.1.0/carestack/base/base_service.py

@@ -0,0 +1,298 @@
+"""This module provides functionalities related to BaseService."""
+
+import json
+import logging
+from abc import ABC
+import os
+from types import TracebackType
+from typing import Any, Optional, Type, TypeVar
+import httpx
+import os
+import httpx
+from abc import ABC
+from typing import Optional, Dict
+
+from pydantic import BaseModel, RootModel
+from carestack.base.base_types import ClientConfig
+from carestack.base.errors import EhrApiError, ValidationError
+from carestack.document_linking.encounter_dto.target_dto.update_visit_records_dto import (
+    UpdateVisitRecordsResponse,
+)
+
+
+class GetJsonFromTextResponse(BaseModel):
+    response: str
+
+
+logger = logging.getLogger(__name__)
+
+ResT = TypeVar("ResT", bound=BaseModel)  # Response type
+
+
+class BaseService(ABC):
+    """Base Service for handling API requests with error management and resource handling."""
+
+    def __init__(
+        self,
+        config: "ClientConfig",
+        timeout: Optional[int] = 6000000,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        """
+        Initializes the BaseService with API configuration.
+
+        Args:
+            config (ClientConfig): Configuration containing API URL and authentication details.
+            timeout (Optional[int]): Timeout for requests (default: 6000000 milliseconds).
+            headers (Optional[Dict[str, str]]): Additional headers to include in the request.
+        """
+        self.config = config
+        self.timeout = timeout
+
+        # Use values directly from the ClientConfig object
+        if not self.config.api_key:
+            raise ValueError("API_KEY is missing in ClientConfig.")
+        if not self.config.api_url:
+            raise ValueError("API_URL is missing in ClientConfig.")
+        if (
+            not self.config.hprid_auth
+        ):  # Assuming hprid_auth is a required part of ClientConfig
+            raise ValueError("x_hpr_id (hprid_auth) is missing in ClientConfig.")
+
+        # Default headers
+        default_headers = {
+            "Authorization": f"Bearer {self.config.api_key}",
+            "Content-Type": "application/json",
+            "x-hprid-auth": self.config.hprid_auth,
+        }
+
+        # Merge user-provided headers, allowing overrides
+        self.headers = {**default_headers, **(headers or {})}
+        self.client = httpx.AsyncClient(
+            base_url=self.config.api_url,
+            headers=self.headers,
+            timeout=self.timeout,
+        )
+
+    @classmethod
+    def from_config(
+        cls,
+        config: ClientConfig,
+        timeout: Optional[int] = 10,
+    ) -> "BaseService":
+        """Factory method to create a BaseService instance from configuration."""
+        return cls(config, timeout)
+
+    async def __handle_error(self, response: httpx.Response) -> None:
+        """Handles API errors by raising EhrApiError with meaningful messages."""
+        if response.status_code >= 400:
+            try:
+                if response.text:
+                    try:
+                        error_data = response.json()
+                        error_message = error_data.get(
+                            "message",
+                            f"""Unknown error. Response: {
+                                response.text}""",
+                        )
+                    except json.JSONDecodeError:
+                        error_message = f"""Invalid JSON response: {
+                            response.text}"""
+                else:
+                    error_message = f"""Empty response body with status code {
+                        response.status_code}"""
+                logger.exception(
+                    "API Error: Status Code: %s, Message: %s",
+                    response.status_code,
+                    error_message,
+                )
+                raise EhrApiError(error_message, response.status_code)
+            except json.JSONDecodeError as e:
+                logger.exception(
+                    "API Error: Status Code: %s, Raw Response: %s",
+                    response.status_code,
+                    response.text,
+                )
+                raise EhrApiError(
+                    f"An unexpected error occurred: {e}", response.status_code
+                ) from e
+
+    async def __make_request(
+        self,
+        method: str,
+        endpoint: str,
+        response_model: Optional[Type[ResT]],
+        data: Optional[dict[str, Any]] = None,
+        params: Optional[dict[str, Any]] = None,
+    ) -> ResT:
+        """
+        Makes an API request with dynamic HTTP method.
+
+        Args:
+            method (str): HTTP method (GET, POST, PUT, DELETE).
+            endpoint (str): API endpoint.
+            data (Optional[dict[str, Any]]): JSON payload for POST/PUT requests.
+            params (Optional[dict[str, Any]]): Query parameters for GET requests.
+
+        Returns:
+            dict[str, Any]: JSON response from the API.
+
+        Raises:
+            EhrApiError: If the API request fails.
+        """
+
+        response_text: Optional[str] = None
+        if data:
+            # Be careful logging sensitive data in production
+            logger.debug(f"Request data: {data}")
+        try:
+            logger.info(f"Making request: {method} {endpoint}")
+            if data:
+                logger.debug(f"Request data: {data}")  # Consider masking sensitive data
+
+            response = await self.client.request(
+                method, endpoint, json=data, params=params
+            )
+
+            # Read the response body as text FIRST
+            response_text_bytes = await response.aread()
+            response_text = response_text_bytes.decode("utf-8", errors="replace")
+
+            logger.info(
+                f"Received response status: {response.status_code} for {method} {endpoint}"
+            )
+            logger.debug(f"Raw response text: {response_text}")
+
+            await self.__handle_error(response)
+            response_data = response.json()
+
+            if response_model is GetJsonFromTextResponse:
+                logger.debug("Handling GetJsonFromTextResponse from raw string")
+                # Directly instantiate with the raw string response
+                try:
+                    # Pydantic will validate if 'response_text' is a string
+                    return GetJsonFromTextResponse(response=response_text)  # type: ignore
+                except ValidationError as e:
+                    logger.error(
+                        f"Pydantic validation failed for GetJsonFromTextResponse: {e}. Raw text: {response_text}"
+                    )
+                    raise EhrApiError(
+                        f"Validation failed for GetJsonFromTextResponse: {e}",
+                        response.status_code,
+                    ) from e
+
+            # --- If not GetJsonFromTextResponse, THEN try parsing as JSON ---
+            try:
+                # Handle empty body explicitly after error check and GetJsonFromTextResponse check
+                if not response_text.strip():
+                    logger.warning(
+                        f"Empty response body received for {method} {endpoint} (expected JSON)"
+                    )
+                    # Raising an error is usually appropriate if JSON was expected
+                    raise ValueError(
+                        "Received empty response body when expecting JSON data."
+                    )
+
+                response_data = json.loads(response_text)
+                logger.debug(f"Parsed response data type: {type(response_data)}")
+
+            except json.JSONDecodeError as json_err:
+                # This error occurs if response_text is not valid JSON
+                error_msg = f"Failed to decode JSON response for {method} {endpoint}. Status: {response.status_code}. Error: {json_err}. Response text: {response_text}"
+                logger.error(error_msg)
+                raise EhrApiError(error_msg, response.status_code) from json_err
+            except ValueError as val_err:  # Catch the empty body error
+                logger.error(
+                    f"ValueError after parsing attempt: {val_err}. Raw text: {response_text}"
+                )
+                raise EhrApiError(
+                    f"Data processing error: {val_err}", response.status_code
+                ) from val_err
+
+            if response_model is UpdateVisitRecordsResponse and isinstance(
+                response_data, bool
+            ):
+                # Manually create the response object
+                # Cast is safe here because we checked the type and model
+                return UpdateVisitRecordsResponse(success=response_data)  # type: ignore
+
+            # Handle RootModel
+            elif response_model and issubclass(response_model, RootModel):
+                # For RootModel, pass the data directly
+                return response_model(response_data)
+
+            elif response_model and isinstance(response_data, dict):
+                # For standard BaseModel, unpack the dictionary
+                return response_model(**response_data)
+            else:
+
+                # Handle unexpected case: Model is not RootModel, but data isn't a dict
+                error_msg = (
+                    f"Cannot instantiate {response_model.__name__ if response_model else 'unknown'}: "
+                    f"Expected a dictionary response for this model, but received type {type(response_data)}"
+                )
+                logger.error(error_msg)
+                raise TypeError(error_msg)
+
+        except EhrApiError as e:
+            raise e
+        # except json.JSONDecodeError as e:
+        #     raise EhrApiError(f"{response.text}", response.status_code) from e
+        # except Exception as e:
+        #     logger.exception("Unexpected error during %s request: %s", method, e)
+        #     raise EhrApiError(
+        #         f"Unexpected error during {method} request: {e}", response.status_code
+        #     ) from e
+
+    async def get(
+        self,
+        endpoint: str,
+        response_model: Type[ResT],
+        query_params: Optional[dict[str, Any]] = None,
+    ) -> ResT:
+        """Makes a GET request."""
+        response_data = await self.__make_request(
+            "GET", endpoint, response_model=response_model, params=query_params
+        )
+        return response_data
+
+    async def post(
+        self, endpoint: str, data: dict[str, Any], response_model: Type[ResT]
+    ) -> ResT:
+        response_data: ResT = await self.__make_request(
+            "POST", endpoint, response_model=response_model, data=data
+        )
+        return response_data
+
+    async def put(
+        self, endpoint: str, data: dict[str, Any], response_model: Type[ResT]
+    ) -> ResT:
+        """Makes a PUT request."""
+        return await self.__make_request(
+            "PUT", endpoint, response_model=response_model, data=data
+        )
+
+    async def delete(
+        self, endpoint: str, response_model: Optional[Type[ResT]] = None
+    ) -> Optional[ResT]:
+        """Makes a DELETE request."""
+        return await self.__make_request(
+            "DELETE", endpoint, response_model=response_model
+        )
+
+    async def close(self) -> None:
+        """Closes the HTTP client session."""
+        await self.client.aclose()
+
+    async def __aenter__(self) -> "BaseService":
+        """Enables async context manager support."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        """Closes session on exit."""
+        await self.close()

carestack-0.1.0/carestack/base/base_types.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+
+class ClientConfig:
+    def __init__(self, api_key: str, api_url: str, x_hpr_id) -> None:
+        self.api_key = api_key
+        self.api_url = api_url
+        self.hprid_auth = x_hpr_id
+
+
+class ApiResponse:
+    def __init__(self, data: Any, status: int, message: str) -> None:
+        self.data = data
+        self.status = status
+        self.message = message

carestack-0.1.0/carestack/base/errors.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+
+class EhrApiError(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        code: Optional[str] = None,
+    ) -> None:
+        self.message = message
+        self.code = code
+        self.status_code = status_code
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f"{self.message}"
+
+
+class AuthenticationError(EhrApiError):
+    def __init__(self, message: str = "Authentication failed") -> None:
+        super().__init__(message, 401)
+        self.name = "AuthenticationError"
+
+
+class ValidationError(EhrApiError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message, 400)
+        self.name = "ValidationError"