Feature/additional resources templates

healthchain/data_generator/base_generators.py

@@ -3,7 +3,7 @@
 import random
 import string
 
-from healthchain.fhir_resources.base_resources import (
+from healthchain.fhir_resources.primitive_resources import (
     booleanModel,
     canonicalModel,
     codeModel,
@@ -58,21 +58,21 @@ def generate():
 
 
 @register_generator
-class booleanGenerator(BaseGenerator):
+class BooleanGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return booleanModel(random.choice(["true", "false"]))
 
 
 @register_generator
-class canonicalGenerator(BaseGenerator):
+class CanonicalGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return canonicalModel(f"https://example/{faker.uri_path()}")
 
 
 @register_generator
-class codeGenerator(BaseGenerator):
+class CodeGenerator(BaseGenerator):
     # TODO: Codes can technically have whitespace but here I've left it out for simplicity
     @staticmethod
     def generate():
@@ -82,98 +82,98 @@ def generate():
 
 
 @register_generator
-class dateGenerator(BaseGenerator):
+class DateGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return dateModel(faker.date())
 
 
 @register_generator
-class dateTimeGenerator(BaseGenerator):
+class DateTimeGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return dateTimeModel(faker.date_time().isoformat())
 
 
 @register_generator
-class decimalGenerator(BaseGenerator):
+class DecimalGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return decimalModel(faker.random_number())
 
 
 @register_generator
-class idGenerator(BaseGenerator):
+class IdGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return idModel(faker.uuid4())
 
 
 @register_generator
-class instantGenerator(BaseGenerator):
+class InstantGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return instantModel(faker.date_time().isoformat())
 
 
 @register_generator
-class integerGenerator(BaseGenerator):
+class IntegerGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return integerModel(faker.random_int())
 
 
 @register_generator
-class markdownGenerator(BaseGenerator):
+class MarkdownGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return markdownModel(faker.text())
 
 
 @register_generator
-class positiveIntGenerator(BaseGenerator):
+class PositiveIntGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return positiveIntModel(faker.random_int(min=1))
 
 
 @register_generator
-class stringGenerator(BaseGenerator):
+class StringGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return stringModel(faker.word())
 
 
 @register_generator
-class timeGenerator(BaseGenerator):
+class TimeGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return timeModel(faker.time())
 
 
 @register_generator
-class unsignedIntGenerator(BaseGenerator):
+class UnsignedIntGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return unsignedIntModel(faker.random_int(min=0))
 
 
 @register_generator
-class uriGenerator(BaseGenerator):
+class UriGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return uriModel(f"https://example/{faker.uri_path()}")
 
 
 @register_generator
-class urlGenerator(BaseGenerator):
+class UrlGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return urlModel(f"https://example/{faker.uri_path()}")
 
 
 @register_generator
-class uuidGenerator(BaseGenerator):
+class UuidGenerator(BaseGenerator):
     @staticmethod
     def generate():
         return uuidModel(faker.uuid4())

healthchain/data_generator/condition_generators.py

@@ -0,0 +1,159 @@
+from healthchain.data_generator.base_generators import (
+    BaseGenerator,
+    generator_registry,
+    register_generator,
+)
+from healthchain.fhir_resources.general_purpose_resources import (
+    CodeableConceptModel,
+    CodingModel,
+    ReferenceModel,
+)
+from healthchain.fhir_resources.condition_resources import (
+    ConditionModel,
+    Condition_StageModel,
+    Condition_ParticipantModel,
+)
+from typing import Optional
+from faker import Faker
+
+
+faker = Faker()
+
+
+@register_generator
+class ClinicalStatusGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://terminology.hl7.org/CodeSystem/condition-clinical",
+                    code=faker.random_element(
+                        elements=("active", "recurrence", "inactive", "resolved")
+                    ),
+                )
+            ]
+        )
+
+
+@register_generator
+class VerificationStatusGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://terminology.hl7.org/CodeSystem/condition-ver-status",
+                    code=faker.random_element(elements=("provisional", "confirmed")),
+                )
+            ]
+        )
+
+
+@register_generator
+class CategoryGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://snomed.info/sct",
+                    code=faker.random_element(
+                        elements=("55607006", "404684003")
+                    ),  # Snomed Codes -> probably want to overwrite with template
+                )
+            ]
+        )
+
+
+@register_generator
+class ConditionStageGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return Condition_StageModel(
+            summary=generator_registry.get("CodeableConceptGenerator").generate(),
+            assessment=generator_registry.get("ReferenceGenerator").generate(),
+            type=generator_registry.get("CodeableConceptGenerator").generate(),
+        )
+
+
+@register_generator
+class SeverityGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://snomed.info/sct",
+                    code=faker.random_element(
+                        elements=("24484000", "6736007", "255604002")
+                    ),
+                    # TODO: Add display values for the codes
+                )
+            ]
+        )
+
+
+@register_generator
+class SnomedCodeGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://snomed.info/sct",
+                    code=faker.random_element(elements=("386661006")),
+                    display=faker.random_element(elements=("Fever")),
+                )
+            ]
+        )
+
+
+@register_generator
+class BodySiteGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return CodeableConceptModel(
+            coding=[
+                CodingModel(
+                    system="http://snomed.info/sct",
+                    code=faker.random_element(elements=("38266002")),
+                    display=faker.random_element(elements=("Entire body as a whole")),
+                )
+            ]
+        )
+
+
+@register_generator
+class ConditionParticipantGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return Condition_ParticipantModel(
+            type=generator_registry.get("CodeableConceptGenerator").generate(),
+            individual=generator_registry.get("ReferenceGenerator").generate(),
+        )
+
+
+@register_generator
+class ConditionModelGenerator(BaseGenerator):
+    @staticmethod
+    def generate(subject_reference: Optional[str], encounter_reference: Optional[str]):
+        subject_reference = subject_reference or "Patient/123"
+        encounter_reference = encounter_reference or "Encounter/123"
+        return ConditionModel(
+            id=generator_registry.get("IdGenerator").generate(),
+            clinicalStatus=generator_registry.get("ClinicalStatusGenerator").generate(),
+            verificationStatus=generator_registry.get(
+                "VerificationStatusGenerator"
+            ).generate(),
+            category=[generator_registry.get("CategoryGenerator").generate()],
+            severity=generator_registry.get("SeverityGenerator").generate(),
+            code=generator_registry.get("SnomedCodeGenerator").generate(),
+            bodySite=[generator_registry.get("BodySiteGenerator").generate()],
+            subject=ReferenceModel(reference=subject_reference),
+            encounter=ReferenceModel(reference=encounter_reference),
+            onsetDateTime=generator_registry.get(
+                "DateGenerator"
+            ).generate(),  ## Are there more plausible dates to use?
+            recordedDate=generator_registry.get("DateGenerator").generate(),
+        )

healthchain/data_generator/encounter_generator.py

@@ -1,5 +1,8 @@
 from healthchain.fhir_resources.encounter_resources import EncounterModel
-from healthchain.fhir_resources.base_resources import CodingModel, CodeableConceptModel
+from healthchain.fhir_resources.general_purpose_resources import (
+    CodingModel,
+    CodeableConceptModel,
+)
 from healthchain.data_generator.base_generators import (
     BaseGenerator,
     generator_registry,
@@ -70,7 +73,7 @@ def generate(patient_reference: Optional[str]):
             patient_reference = "Patient/123"
         return EncounterModel(
             resourceType="Encounter",
-            id=generator_registry.get("idGenerator").generate(),
+            id=generator_registry.get("IdGenerator").generate(),
             text={
                 "status": "generated",
                 "div": '<div xmlns="http://www.w3.org/1999/xhtml">Encounter with patient @example</div>',

healthchain/data_generator/medication_administration_generators.py

@@ -0,0 +1,45 @@
+from healthchain.fhir_resources.medication_administration_resources import (
+    MedicationAdministrationModel,
+    MedicationAdministration_DosageModel,
+)
+from healthchain.fhir_resources.general_purpose_resources import ReferenceModel
+from healthchain.data_generator.base_generators import (
+    BaseGenerator,
+    generator_registry,
+    register_generator,
+)
+from faker import Faker
+
+
+faker = Faker()
+
+
+@register_generator
+class MedicationAdministrationDosageGenerator(BaseGenerator):
+    @staticmethod
+    def generate():
+        return MedicationAdministration_DosageModel(
+            text=faker.random_element(
+                elements=(
+                    "Take 1 tablet by mouth once daily",
+                    "Take 2 tablets by mouth once daily",
+                )
+            ),
+        )
+
+
+@register_generator
+class MedicationAdministrationGenerator(BaseGenerator):
+    @staticmethod
+    def generate(subject_reference: str, encounter_reference: str):
+        return MedicationAdministrationModel(
+            id=generator_registry.get("IdGenerator").generate(),
+            status=generator_registry.get("EventStatusGenerator").generate(),
+            medication=generator_registry.get("MedicationGenerator").generate(),
+            subject=ReferenceModel(reference=subject_reference),
+            encounter=ReferenceModel(reference=encounter_reference),
+            authoredOn=generator_registry.get("DateGenerator").generate(),
+            dosage=generator_registry.get(
+                "MedicationAdministrationDosageGenerator"
+            ).generate(),
+        )