endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/administration/person/patient/patient.py

@@ -1,11 +1,13 @@
-from ..person import Person
-from django.db import models
-from faker import Faker
+import logging
 import random
-from datetime import datetime
+from datetime import date, datetime
 from typing import TYPE_CHECKING, List, Optional  # Added List
-import logging
+
+from django.db import models
 from django.utils import timezone  # Add this import
+from faker import Faker
+
+from ..person import Person
 
 # Import RequirementLinks and Disease for the links property
 
@@ -13,23 +15,22 @@ logger = logging.getLogger("patient")
 
 if TYPE_CHECKING:
     from endoreg_db.models import (
+        AnonymExaminationReport,
+        AnonymHistologyReport,
+        Center,
         ExaminationIndication,
-        PatientEvent, PatientDisease,
         Gender,
+        PatientDisease,
+        PatientEvent,
         PatientExamination,
-        Center,
-        AnonymExaminationReport,
-        AnonymHistologyReport, RawPdfFile,
-        # Added for links property
-        Medication,
+        PatientExternalID,
+        PatientLabValue,
         PatientMedication,
-        MedicationIndication,
-        MedicationIntakeTime,
-        PatientLabValue, # Assuming self.lab_values are PatientLabValue instances
-        LabValue # If RequirementLinks expects actual LabValue instances
+        RawPdfFile,
     )
     from endoreg_db.utils.links.requirement_link import RequirementLinks
 
+
 class Patient(Person):
     """
     A class representing a patient.
@@ -44,31 +45,47 @@ class Patient(Person):
 
     """
 
-    # -----gc-08-dev--changings---
-    first_name = models.CharField(max_length=100) # type: ignore[assignment]
-    last_name = models.CharField(max_length=100) # type: ignore[assignment]
-    dob = models.DateField(null=True, blank=True) # type: ignore[assignment]
-    gender = models.ForeignKey( # type: ignore[assignment]
-        "Gender", on_delete=models.SET_NULL, null=True, blank=True
-    )
-    center = models.ForeignKey( # type: ignore[assignment]
-        "Center", on_delete=models.SET_NULL, null=True, blank=True
-    )
+    first_name = models.CharField(max_length=100)
+    last_name = models.CharField(max_length=100)
+    dob = models.DateField(null=True, blank=True)
+    gender = models.ForeignKey("Gender", on_delete=models.SET_NULL, null=True, blank=True)
+    center = models.ForeignKey("Center", on_delete=models.SET_NULL, null=True, blank=True)
     patient_hash = models.CharField(max_length=255, blank=True, null=True)
-    
+
     objects = models.Manager()  # Default manager
 
     if TYPE_CHECKING:
-        first_name: str
-        last_name: str
-        dob: datetime.date
-        gender: "Gender"
-        center: "Center"
-        events: models.QuerySet["PatientEvent"]
-        diseases: models.QuerySet["PatientDisease"]
-        patient_examinations: models.QuerySet["PatientExamination"]
-        anonymexaminationreport_set: models.QuerySet["AnonymExaminationReport"]
-        anonymhistologyreport_set: models.QuerySet["AnonymHistologyReport"]
+        from django.db.models.manager import RelatedManager
+
+        first_name: models.CharField[str]
+        last_name: models.CharField[str]
+        dob: models.DateField[date | None]
+        gender: models.ForeignKey["Gender | None"]
+        center: models.ForeignKey["Center | None"]
+
+        @property
+        def events(self) -> RelatedManager[PatientEvent]: ...
+
+        @property
+        def diseases(self) -> RelatedManager[PatientDisease]: ...
+
+        @property
+        def patient_examinations(self) -> RelatedManager[PatientExamination]: ...
+
+        @property
+        def anonymexaminationreport_set(self) -> RelatedManager[AnonymExaminationReport]: ...
+
+        @property
+        def anonymhistologyreport_set(self) -> RelatedManager[AnonymHistologyReport]: ...
+
+        @property
+        def external_ids(self) -> RelatedManager[PatientExternalID]: ...
+
+        @property
+        def patientmedication_set(self) -> RelatedManager[PatientMedication]: ...
+
+        @property
+        def lab_values(self) -> RelatedManager[PatientLabValue]: ...
 
     def __str__(self):
         return f"{self.first_name} {self.last_name} ({self.dob})"
@@ -77,12 +94,13 @@ class Patient(Person):
     def get_or_create_pseudo_patient_by_hash(
         cls,
         patient_hash: str,
-        center: "Center" = None,
-        gender: "Gender | str" = None,  # Allow string type hint
-        birth_month: int = None,
-        birth_year: int = None,
+        center: Optional["Center"] = None,
+        gender: Optional["Gender | str"] = None,  # Allow string type hint
+        birth_month: Optional[int] = None,
+        birth_year: Optional[int] = None,
     ):
-        from endoreg_db.utils import random_day_by_year, create_mock_patient_name
+        from endoreg_db.utils import create_mock_patient_name, random_day_by_year
+
         from ....other import Gender  # Import Gender model
 
         created = False
@@ -96,9 +114,7 @@ class Patient(Person):
         # If no patient with the given hash exists, create a new pseudo patient
         assert center, "Center must be provided to create a new pseudo patient"
         assert gender, "Gender must be provided to create a new pseudo patient"
-        assert birth_month, (
-            "Birth month must be provided to create a new pseudo patient"
-        )
+        assert birth_month, "Birth month must be provided to create a new pseudo patient"
         assert birth_year, "Birth year must be provided to create a new pseudo patient"
 
         # Ensure gender is a Gender object
@@ -130,9 +146,8 @@ class Patient(Person):
 
         return patient, created
 
-    def get_dob(self) -> datetime.date:
-        dob: datetime.date = self.dob
-        return dob
+    def get_dob(self) -> date | None:
+        return self.dob
 
     def get_patient_examinations(self):  # field: self.patient_examinations
         """Returns all patient examinations for this patient ordered by date (most recent is first)."""
@@ -146,10 +161,9 @@ class Patient(Person):
         save: bool = True,
     ) -> "PatientExamination":
         """Creates a patient examination for this patient."""
+        from ....medical import Examination, PatientExamination
 
         if examination_name_str:
-            from ....medical import Examination, PatientExamination
-
             examination = Examination.objects.get(name=examination_name_str)
             patient_examination = PatientExamination(
                 patient=self,
@@ -159,21 +173,17 @@ class Patient(Person):
             )
 
         else:
-            patient_examination = PatientExamination(
-                patient=self, date_start=date_start, date_end=date_end
-            )
+            patient_examination = PatientExamination(patient=self, date_start=date_start, date_end=date_end)
 
         if save:
             patient_examination.save()
 
         return patient_examination
 
-    def create_examination_by_indication(
-        self, indication: "ExaminationIndication", date_start: datetime = None, date_end: datetime = None
-    ):
+    def create_examination_by_indication(self, indication: "ExaminationIndication", date_start: Optional[datetime] = None, date_end: Optional[datetime] = None):
         from ....medical import (
-            PatientExaminationIndication,
             PatientExamination,
+            PatientExaminationIndication,
         )
 
         examination = indication.get_examination()
@@ -187,9 +197,7 @@ class Patient(Person):
 
         patient_examination.save()
 
-        patient_examination_indication = PatientExaminationIndication.objects.create(
-            patient_examination=patient_examination, examination_indication=indication
-        )
+        patient_examination_indication = PatientExaminationIndication.objects.create(patient_examination=patient_examination, examination_indication=indication)
         patient_examination_indication.save()
 
         return patient_examination, patient_examination_indication
@@ -197,13 +205,13 @@ class Patient(Person):
     def create_event(
         self,
         event_name_str: str,
-        date_start: datetime = None,
-        date_end: datetime = None,
-        description: str = None,
+        date_start: Optional[datetime] = None,
+        date_end: Optional[datetime] = None,
+        description: Optional[str] = None,
     ):
         """
         Creates a patient event with the specified event name and start date.
-        
+
         If no start date is provided, the current datetime is used. Returns the created PatientEvent instance.
         """
         from ....medical import Event, PatientEvent
@@ -224,16 +232,17 @@ class Patient(Person):
     def create_examination_by_pdf(self, pdf: "RawPdfFile"):
         """
         Creates a patient examination and associates it with the provided PDF report file.
-        
+
         The examination is created for this patient, saved, and linked to the given RawPdfFile instance. The PDF's examination field is updated and saved. Returns the created examination instance.
-        
+
         Args:
             pdf: The RawPdfFile to associate with the new examination.
-        
+
         Returns:
             The created PatientExamination instance.
         """
         from ....medical import PatientExamination
+
         patient_examination = PatientExamination(patient=self)
         patient_examination.save()
         pdf.examination = patient_examination
@@ -264,9 +273,7 @@ class Patient(Person):
         return gender_obj
 
     @classmethod
-    def get_random_age(
-        cls, min_age=55, max_age=90, mean_age=65, std_age=10, distribution="normal"
-    ):
+    def get_random_age(cls, min_age=55, max_age=90, mean_age=65, std_age=10, distribution="normal"):
         """
         Get a random age based on the given distribution.
 
@@ -346,11 +353,17 @@ class Patient(Person):
             last_name=last_name,
             dob=dob,
             gender=gender,
-            center=center_obj, # Assign the center object
+            center=center_obj,  # Assign the center object
         )
         # No need to call save() again after create()
         return patient
 
+    @property
+    def age_safe(self) -> int:
+        age = self.age()
+        assert age is not None, "Patient age is not set."
+        return age
+
     def age(self) -> int | None:
         """
         Get the age of the patient.
@@ -362,11 +375,7 @@ class Patient(Person):
         dob = self.dob
         # Ensure dob is not None before calculation
         if dob:
-            age = (
-                current_date.year
-                - dob.year
-                - ((current_date.month, current_date.day) < (dob.month, dob.day))
-            )
+            age = current_date.year - dob.year - ((current_date.month, current_date.day) < (dob.month, dob.day))
             return age
         return None  # Or handle the case where dob is None appropriately
 
@@ -390,17 +399,11 @@ class Patient(Person):
 
         if isinstance(sample_type, str):
             sample_type = PatientLabSampleType.objects.get(name=sample_type)
-            assert sample_type is not None, (
-                f"Sample type with name '{sample_type}' not found."
-            )
+            assert sample_type is not None, f"Sample type with name '{sample_type}' not found."
         elif not isinstance(sample_type, PatientLabSampleType):
-            raise ValueError(
-                "Sample type must be either a string or a PatientLabSampleType object."
-            )
+            raise ValueError("Sample type must be either a string or a PatientLabSampleType object.")
 
-        patient_lab_sample = PatientLabSample.objects.create(
-            patient=self, sample_type=sample_type, date=date
-        )
+        patient_lab_sample = PatientLabSample.objects.create(patient=self, sample_type=sample_type, date=date)
 
         return patient_lab_sample
 
@@ -411,50 +414,50 @@ class Patient(Person):
         as a RequirementLinks object. For a Patient, this includes their diseases, associated classification choices,
         all their lab values, and medication information.
         """
-        from endoreg_db.utils.links.requirement_link import RequirementLinks
         from endoreg_db.models.medical.disease import Disease, DiseaseClassificationChoice
-        
+
         # Imports for medication related models
         from endoreg_db.models.medical.medication.medication import Medication
         from endoreg_db.models.medical.medication.medication_indication import MedicationIndication
         from endoreg_db.models.medical.medication.medication_intake_time import MedicationIntakeTime
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
         # PatientMedication objects are retrieved via self.patientmedication_set
         # PatientLabValue objects are retrieved via self.lab_values
 
-        patient_disease_instances = list(self.diseases.all()) # These are PatientDisease model instances
+        patient_disease_instances = list(self.diseases.all())  # These are PatientDisease model instances
         actual_diseases: List[Disease] = []
         all_classification_choices: List[DiseaseClassificationChoice] = []
 
         for pd_instance in patient_disease_instances:
-            if pd_instance.disease: # pd_instance.disease is a Disease instance
+            if pd_instance.disease:  # pd_instance.disease is a Disease instance
                 actual_diseases.append(pd_instance.disease)
             all_classification_choices.extend(list(pd_instance.classification_choices.all()))
-        
+
         # Assuming self.lab_values is a related manager for PatientLabValue instances
-        patient_lab_value_instances = list(self.lab_values.all()) # These are PatientLabValue model instances
+        patient_lab_value_instances = list(self.lab_values.all())  # These are PatientLabValue model instances
 
         # Medication information
         # self.patientmedication_set gives a QuerySet of PatientMedication
-        patient_medication_instances = list(self.patientmedication_set.all()) 
-        
+        patient_medication_instances = list(self.patientmedication_set.all())
+
         actual_medications: List[Medication] = []
         med_indications: List[MedicationIndication] = []
         med_intake_times: List[MedicationIntakeTime] = []
 
         for pm_instance in patient_medication_instances:
-            if pm_instance.medication: # pm_instance.medication is a Medication instance
+            if pm_instance.medication:  # pm_instance.medication is a Medication instance
                 actual_medications.append(pm_instance.medication)
-            if pm_instance.medication_indication: # pm_instance.medication_indication is a MedicationIndication instance
+            if pm_instance.medication_indication:  # pm_instance.medication_indication is a MedicationIndication instance
                 med_indications.append(pm_instance.medication_indication)
-            med_intake_times.extend(list(pm_instance.intake_times.all())) # pm_instance.intake_times is a ManyRelatedManager for MedicationIntakeTime
+            med_intake_times.extend(list(pm_instance.intake_times.all()))  # pm_instance.intake_times is a ManyRelatedManager for MedicationIntakeTime
 
         return RequirementLinks(
-            diseases=list(set(actual_diseases)), 
-            patient_diseases=patient_disease_instances, 
-            disease_classification_choices=list(set(all_classification_choices)), 
+            diseases=list(set(actual_diseases)),
+            patient_diseases=patient_disease_instances,
+            disease_classification_choices=list(set(all_classification_choices)),
             patient_lab_values=patient_lab_value_instances,
-            medications=list(set(actual_medications)), 
+            medications=list(set(actual_medications)),
             patient_medications=patient_medication_instances,
             medication_indications=list(set(med_indications)),
-            medication_intake_times=list(set(med_intake_times))
+            medication_intake_times=list(set(med_intake_times)),
         )

endoreg_db/models/administration/person/patient/patient_external_id.py

@@ -0,0 +1,37 @@
+from typing import TYPE_CHECKING
+
+from django.db import models  # Add this import
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Patient,
+    )
+
+
+class PatientExternalID(models.Model):
+    """
+    A class representing the identifier of external datasources.
+    Attributes:
+        external_id (str): The external ID value.
+    """
+
+    external_id: models.CharField = models.CharField(max_length=255)
+    patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.CASCADE,
+        related_name="external_ids",
+    )
+    origin = models.CharField(max_length=255)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=("origin", "external_id"),
+                name="uniq_patient_external_id_per_origin",
+            )
+        ]
+
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient"]
+        origin: models.CharField[str]
+        

endoreg_db/models/administration/person/person.py

@@ -22,6 +22,10 @@ class Person(models.Model):
     phone = models.CharField(max_length=255, blank=True, null=True)
     is_real_person = models.BooleanField(default=True)
 
+    post_code = models.CharField(max_length=20, blank=True, null=True)
+    city = models.CharField(max_length=255, blank=True, null=True)
+    street = models.CharField(max_length=255, blank=True, null=True)
+
     @abstractmethod
     def __str__(self):
         pass

endoreg_db/models/administration/person/profession/__init__.py

@@ -1,24 +1,28 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from endoreg_db.models import PortalUserInfo
 
+
 class ProfessionManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class Profession(models.Model):
     objects = ProfessionManager()
     name = models.CharField(max_length=100)
     description = models.TextField(blank=True, null=True)
 
-
     if TYPE_CHECKING:
-        portal_user_infos: models.QuerySet["PortalUserInfo"]
+
+        @property
+        def portal_user_infos(self) -> models.QuerySet["PortalUserInfo"]: ...
 
     def __str__(self):
         """
         Return the profession's name as its string representation.
         """
-        return str(self.name)
+        return str(self.name)

endoreg_db/models/administration/person/user/portal_user_information.py

@@ -1,17 +1,21 @@
-from django.db import models
 from typing import TYPE_CHECKING
+
+from django.db import models
+
 # models.py in your main app
 
 if TYPE_CHECKING:
-    from ..profession import Profession
-    from endoreg_db.models import Examiner
     from django.contrib.auth.models import User
 
+    from endoreg_db.models import Examiner
+
+    from ..profession import Profession
+
 
 class PortalUserInfo(models.Model):
     user = models.OneToOneField("auth.User", on_delete=models.CASCADE)
     profession = models.ForeignKey(
-        'endoreg_db.Profession',
+        "endoreg_db.Profession",
         on_delete=models.CASCADE,
         blank=True,
         null=True,
@@ -29,9 +33,9 @@ class PortalUserInfo(models.Model):
     )
 
     if TYPE_CHECKING:
-        user: "User"
-        profession: "Profession"
-        examiner: "Examiner"
+        user: models.OneToOneField["User"]
+        profession: models.ForeignKey["Profession|None"]
+        examiner: models.OneToOneField["Examiner|None"]
 
     def __str__(self):
         return self.user.username

endoreg_db/models/administration/product/product.py

@@ -1,20 +1,23 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 from endoreg_db.utils.product.sum_emissions import sum_emissions
 from endoreg_db.utils.product.sum_weights import sum_weights
 
 if TYPE_CHECKING:
     from ...other.transport_route import TransportRoute
     from .product_group import ProductGroup
-    from .reference_product import ReferenceProduct
     from .product_material import ProductMaterial
+    from .reference_product import ReferenceProduct
     # from .product_weight import ProductWeight
 
+
 class ProductManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class Product(models.Model):
     objects = ProductManager()
 
@@ -29,15 +32,14 @@ class Product(models.Model):
     )
 
     if TYPE_CHECKING:
-        transport_route: "TransportRoute"
-        product_group: "ProductGroup"
+        transport_route: models.ForeignKey["TransportRoute|None"]
+        product_group: models.ForeignKey["ProductGroup|None"]
         reference_products: models.QuerySet["ReferenceProduct"]
         product_product_materials: models.QuerySet["ProductMaterial"]
 
-
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         result = f"{self.name}"
         if self.product_group:
@@ -49,41 +51,44 @@ class Product(models.Model):
             result += f"{self.transport_route})"
         else:
             result += "no transport route)"
-        
+
         return result
-    
+
     def _calculate_material_metric(self, component: str, calculation_func):
         """Helper method to calculate weight or emission for materials of a specific component."""
-        from .product_material import ProductMaterial # Import locally to avoid circular dependency issues at module level
+        from .product_material import ProductMaterial  # Import locally to avoid circular dependency issues at module level
+
         materials = ProductMaterial.objects.filter(product=self, component=component)
         return calculation_func(materials)
 
     def get_product_weight(self):
         """Get the product weight, prioritizing material definitions."""
         from .product_material import ProductMaterial
+
         # Check if there are specific material definitions for the product component
         if ProductMaterial.objects.filter(product=self, component="product").exists():
             return self.get_product_material_weight()
-        
+
         # Fallback: check if there is a direct product weight defined (Not implemented yet)
         # TODO: Implement logic for ProductWeight lookup
-        return None # Or appropriate default/error
+        return None  # Or appropriate default/error
 
     def get_package_weight(self):
         """Get the package weight, prioritizing material definitions."""
         from .product_material import ProductMaterial
+
         # Check if there are specific material definitions for the package component
         if ProductMaterial.objects.filter(product=self, component="package").exists():
             return self.get_package_material_weight()
-        
+
         # Fallback: check if there is a direct package weight defined (Not implemented yet)
         # TODO: Implement logic for PackageWeight lookup (if different from ProductWeight)
-        return None # Or appropriate default/error
+        return None  # Or appropriate default/error
 
     def get_product_material_weight(self):
         """Calculate the total weight based on defined product materials."""
         return self._calculate_material_metric("product", sum_weights)
-    
+
     def get_package_material_weight(self):
         """Calculate the total weight based on defined package materials."""
         return self._calculate_material_metric("package", sum_weights)

endoreg_db/models/administration/product/product_material.py

@@ -1,54 +1,53 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 from endoreg_db.models.other.unit import Unit
 
 if TYPE_CHECKING:
-    from ...other.emission import EmissionFactor
+    from ...other.material import Material
     from ...other.unit import Unit
     from .product import Product
-    from ...other.material import Material
+
 
 class ProductMaterial(models.Model):
     component = models.CharField(max_length=255)
     material = models.ForeignKey(
         "Material",
         on_delete=models.CASCADE,
-        related_name="material_product_materials", # Changed related_name
+        related_name="material_product_materials",  # Changed related_name
     )
     product = models.ForeignKey(
         "Product",
         on_delete=models.CASCADE,
-        related_name="product_product_materials" # Changed related_name
+        related_name="product_product_materials",  # Changed related_name
     )
     unit = models.ForeignKey(
         "Unit",
         on_delete=models.CASCADE,
-        related_name="unit_product_materials", # Changed related_name
+        related_name="unit_product_materials",  # Changed related_name
     )
     quantity = models.FloatField()
 
     if TYPE_CHECKING:
-        product: "Product"
-        material: "Material"
-        unit: "Unit"
-        emission_factor: "EmissionFactor"
+        product: models.ForeignKey["Product"]
+        material: models.ForeignKey["Material"]
+        unit: models.ForeignKey["Unit"]
 
     def get_emission(self) -> tuple[float, Unit]:
         emission_factor = self.material.emission_factor
         if emission_factor is None:
             raise Exception("No emission factor for material " + self.material.name + " found.")
-        
+
         # make sure product_material.unit is the same as emission_factor.unit
-        if self.unit != emission_factor.unit:
-            raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
-        
+        if self.unit is not None and emission_factor.unit is not None:
+            if self.unit != emission_factor.unit:
+                raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
+
         emmision_value = emission_factor.value * self.quantity
+        assert isinstance(emission_factor.unit, Unit)
         emission_unit = emission_factor.unit
         return emmision_value, emission_unit
-    
+
     def __str__(self) -> str:
         return f"{self.product.name} - {self.material.name} - {self.quantity} {self.unit.name}"
-
-
-