phc-ingestion 0.10.3__tar.gz → 0.10.5__tar.gz

{phc-ingestion-0.10.3 → phc-ingestion-0.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phc-ingestion
-Version: 0.10.3
+Version: 0.10.5
 Summary: Functions for LifeOmic PHC genomic ingestions
 License: MIT
 Author-email: LifeOmic Development <development@lifeomic.com>

phc-ingestion-0.10.5/ingestion/nebula/constants.py

@@ -0,0 +1,7 @@
+NEBULA_TEST_TYPE = "WGS-30x"
+DATASET_SYSTEM = "http://lifeomic.com/fhir/dataset"
+NEBULA_KIT_ID_SYSTEM = "http://lifeomic.com/fhir/nebula-kit-id"
+BODY_SITE_SYSTEM = "http://lifeomic.com/fhir/sequence-body-site"
+NEBULA_BODY_SITE = "Buccal Swab"
+INDICATION_SYSTEM = "http://lifeomic.com/fhir/sequence-indication"
+NEBULA_INDICATION = "Genetic Health Screening"

phc-ingestion-0.10.5/ingestion/nebula/manifest_assembler.py

@@ -0,0 +1,181 @@
+from typing import Optional, TypedDict, Any
+from datetime import datetime
+from ingestion.shared_util.lambda_client import LambdaClient
+from ingestion.nebula.constants import (
+    DATASET_SYSTEM,
+    NEBULA_KIT_ID_SYSTEM,
+    BODY_SITE_SYSTEM,
+    INDICATION_SYSTEM,
+    NEBULA_BODY_SITE,
+    NEBULA_INDICATION,
+)
+
+
+class HumanName(TypedDict):
+    use: str
+    given: list[str]
+    family: str
+
+
+class Identifier(TypedDict):
+    system: str
+    value: str
+
+
+class Reference(TypedDict):
+    reference: str | None
+
+
+class Resource(TypedDict):
+    id: str | None
+    identifier: list[Identifier] | None
+
+
+class Patient(Resource):
+    name: list[HumanName] | None
+    gender: str | None
+    birthDate: str | None
+    managingOrganization: Reference | None
+    generalPractitioner: Reference | None
+
+
+class Organization(Resource):
+    name: str | None
+
+
+class Practitioner(Resource):
+    name: list[HumanName] | None
+
+
+class ManifestAssembler:
+    def __init__(self, ingestion_id: str, account_id: str, project_id: str, kit_id: str):
+        self.ingestion_id = ingestion_id
+        self.account_id = account_id
+        self.project_id = project_id
+        self.kit_id = kit_id
+        self.client = LambdaClient(
+            "patient-service",
+            {
+                "Content-Type": "application/json",
+                "LifeOmic-Account": self.account_id,
+                "LifeOmic-Correlation-Id": self.ingestion_id,
+            },
+        )
+
+    def __fetch_patient_by_kit_id(self) -> Optional[Patient]:
+        path = f"/{self.account_id}/dstu3/Patient"
+        params = {
+            "_tag": f"{DATASET_SYSTEM}|{self.project_id}",
+            "identifier": f"{NEBULA_KIT_ID_SYSTEM}|{self.kit_id}",
+        }
+
+        response = self.client.invoke(path, "get", None, params)
+        entries = response.get("entry", [])
+        patient = entries[0]["resource"] if len(entries) > 0 else None
+
+        return patient
+
+    def __fetch_resource_by_type_and_reference(
+        self,
+        resource_type: str,
+        reference: Reference | None,
+    ) -> Any:
+        if not reference:
+            return None
+
+        resource_id = self.__extract_id_from_reference(reference)
+        path = f"/{self.account_id}/dstu3/{resource_type}/{resource_id}"
+
+        try:
+            return self.client.invoke(path, "get")
+        except RuntimeError:
+            return None
+
+    def __extract_identifier_from_resource(self, resource: Resource | None) -> str:
+        if not resource:
+            return ""
+
+        identifiers = resource.get("identifier", [])
+        return identifiers[0].get("value", "") if identifiers else ""
+
+    def __extract_id_from_reference(self, reference: Reference) -> str:
+        if not reference or not reference.get("reference"):
+            return ""
+
+        ref_string = reference.get("reference")
+        if not ref_string:
+            return ""
+
+        parts = ref_string.split("/")
+        return parts[1] if len(parts) > 1 else parts[0]
+
+    def __parse_human_name(self, human_name: list[HumanName] | None):
+        if not human_name or len(human_name) == 0:
+            return None
+
+        last_name = human_name[0].get("family", "")
+        first_name = human_name[0].get("given", [])[0]
+
+        return {
+            "lastName": last_name,
+            "firstName": first_name,
+            "fullName": f"{first_name} {last_name}",
+        }
+
+    def create_manifest(self) -> dict[str, Any]:
+        patient = self.__fetch_patient_by_kit_id()
+
+        if not patient:
+            raise RuntimeError(f"Patient with kit id {self.kit_id} not found")
+        patient_birth_date = patient.get("birthDate")
+        if not patient_birth_date:
+            raise RuntimeError("Patient birth date is a required to create a manifest")
+
+        organization: Organization | None = self.__fetch_resource_by_type_and_reference(
+            "Organization", patient.get("managingOrganization")
+        )
+
+        general_practitioner: Practitioner | None = self.__fetch_resource_by_type_and_reference(
+            "Practitioner", patient.get("generalPractitioner")
+        )
+
+        patient_info = self.__parse_human_name(patient["name"])
+        practitioner_info = self.__parse_human_name(
+            general_practitioner.get("name") if general_practitioner else None
+        )
+
+        return {
+            "name": "Nebula",
+            "indexedDate": datetime.now().strftime("%Y-%m-%d"),
+            "reference": "GRCh38",
+            "patientId": patient.get("id"),
+            "mrn": patient.get("id"),
+            "bodySite": NEBULA_BODY_SITE,
+            "bodySiteDisplay": NEBULA_BODY_SITE,
+            "bodySiteSystem": BODY_SITE_SYSTEM,
+            "indicationSystem": INDICATION_SYSTEM,
+            "indication": NEBULA_INDICATION,
+            "indicationDisplay": NEBULA_INDICATION,
+            "patientInfo": {
+                "lastName": patient_info.get("lastName"),
+                "dob": datetime.fromisoformat(patient_birth_date).strftime("%Y-%m-%d"),
+                "firstName": patient_info.get("firstName"),
+                "gender": patient["gender"],
+            },
+            **(
+                {
+                    "medFacilName": organization.get("name"),
+                    "medFacilID": self.__extract_identifier_from_resource(organization),
+                }
+                if organization
+                else {}
+            ),
+            **(
+                {
+                    "orderingMDName": practitioner_info.get("fullName"),
+                    "orderingMDNPI": self.__extract_identifier_from_resource(general_practitioner),
+                }
+                if general_practitioner
+                else {}
+            ),
+        }

{phc-ingestion-0.10.3 → phc-ingestion-0.10.5}/ingestion/nebula/process.py

@@ -1,18 +1,21 @@
 import os
 
+from ingestion.nebula.constants import NEBULA_TEST_TYPE
 from ingestion.vcf_standardization.standardize import standardize_vcf
 from lifeomic_logging import scoped_logger
+from ingestion.nebula.manifest_assembler import ManifestAssembler
 
 
-def process(vcf_file, out_path, file_name, source_file_id):
+def process(vcf_file, out_path, file_name, source_file_id, ingestion_id, account_id, project_id):
 
     with scoped_logger(__name__) as log:
         log.info(
             f"Beginning Nebula ingestion for vcf_file: {vcf_file}, file_name: {file_name}, out_path: {out_path}, source_file_id: {source_file_id}"
         )
 
-        manifest = {}
         case_id = file_name
+        manifest_assembler = ManifestAssembler(ingestion_id, account_id, project_id, case_id)
+        manifest = manifest_assembler.create_manifest()
         base_vcf_file = os.path.basename(vcf_file)
         vcf_out = base_vcf_file.replace(".vcf", ".modified.vcf")
         vcf_final = base_vcf_file.replace(".vcf", ".modified.nrm.filtered.vcf")
@@ -28,7 +31,7 @@ def process(vcf_file, out_path, file_name, source_file_id):
         )
 
         # Add to manifest
-        manifest["testType"] = "WGS-30x"
+        manifest["testType"] = NEBULA_TEST_TYPE
         manifest["reportID"] = case_id
         manifest["sourceFileId"] = source_file_id
         manifest["resources"] = [{"fileName": f".lifeomic/vcf-ingest/{case_id}/{base_vcf_file}"}]

phc-ingestion-0.10.5/ingestion/shared_util/lambda_client.py

@@ -0,0 +1,81 @@
+import boto3
+from mypy_boto3_lambda.type_defs import InvocationResponseTypeDef
+import json
+from typing import Optional, Any, cast
+from urllib3.util.url import parse_url
+
+
+class LambdaHandler:
+    ACCEPTABLE_STATUS_CODES = [200, 201, 204]
+
+    def __init__(self) -> None:
+        return
+
+    def invoke(
+        self,
+        url: str,
+        header: dict,
+        method: str,
+        body: Optional[dict] = None,
+        query_params: Optional[dict] = None,
+    ) -> Any:
+        parsed_url = parse_url(url)
+        payload = {
+            "headers": header,
+            "path": parsed_url.path,
+            "httpMethod": method.upper(),
+            "body": body,
+            "queryStringParameters": query_params,
+        }
+
+        client = boto3.client("lambda")
+        try:
+            raw_response = client.invoke(
+                FunctionName=cast(str, parsed_url.netloc),
+                InvocationType="RequestResponse",
+                Payload=json.dumps(payload),
+            )
+            return self.parse_response(raw_response)
+
+        except RuntimeError as e:
+            raise RuntimeError(f"Error invoking lambda for payload {str(payload)}") from e
+
+    def parse_response(self, response: InvocationResponseTypeDef) -> Any:
+        raw_payload = response["Payload"].read() if "Payload" in response else None
+        invocation_status_code = response.get("StatusCode", None)
+        if invocation_status_code not in self.ACCEPTABLE_STATUS_CODES:
+            raise RuntimeError(
+                f"Error invoking lambda. Invocation status code: {invocation_status_code}. Response: {str(raw_payload)}"
+            )
+
+        payload = json.loads(raw_payload)
+        lambda_status_code = payload.get("statusCode", None)
+        if lambda_status_code not in self.ACCEPTABLE_STATUS_CODES:
+            raise RuntimeError(
+                f"Error invoking lambda. Lambda status code: {lambda_status_code}. Response: {str(payload)}"
+            )
+
+        return json.loads(payload.get("body", "{}"))
+
+
+class LambdaClient:
+    def __init__(self, host: str, default_header: dict):
+        self.host = host
+        self.default_header = default_header
+        self.handler = LambdaHandler()
+
+    def invoke(
+        self,
+        path: str,
+        method: str,
+        body: Optional[dict] = None,
+        query_params: Optional[dict] = None,
+    ):
+        if path.startswith("/"):
+            path = path[1:]
+        endpoint = f"{self.host}/{path}"
+        try:
+            return self.handler.invoke(endpoint, self.default_header, method, body, query_params)
+
+        except RuntimeError as e:
+            raise RuntimeError(f"Error invoking API. Request error: {str(e)}") from e

{phc-ingestion-0.10.3 → phc-ingestion-0.10.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "phc-ingestion"
-version = "0.10.3"
+version = "0.10.5"
 description = "Functions for LifeOmic PHC genomic ingestions"
 authors = [
     { name = "LifeOmic Development", email = "development@lifeomic.com" },
@@ -15,6 +15,9 @@ dependencies = [
     "schema>=0.7.5",
     "packaging>=23.1",
     "numpy>=2.1.2",
+    "boto3>=1.28.34",
+    "urllib3>=1.26.16",
+    "mypy-boto3-lambda>=1.28.19",
 ]
 requires-python = ">=3.11"
 readme = "PYPI.md"