endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__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,55 @@ 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]
+    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( # type: ignore[assignment]
+    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 +102,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
@@ -130,9 +156,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 +171,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,
@@ -168,42 +192,16 @@ class Patient(Person):
 
         return patient_examination
 
-    def create_examination_by_indication(
-        self, indication: "ExaminationIndication", date_start: datetime = None, date_end: datetime = None
-    ):
-        from ....medical import (
-            PatientExaminationIndication,
-            PatientExamination,
-        )
-
-        examination = indication.get_examination()
-
-        patient_examination = PatientExamination.objects.create(
-            patient=self,
-            examination=examination,
-            date_start=date_start,
-            date_end=date_end,
-        )
-
-        patient_examination.save()
-
-        patient_examination_indication = PatientExaminationIndication.objects.create(
-            patient_examination=patient_examination, examination_indication=indication
-        )
-        patient_examination_indication.save()
-
-        return patient_examination, patient_examination_indication
-
     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
@@ -223,17 +221,18 @@ 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.
-        
+        Creates a patient examination and associates it with the provided report report file.
+
+        The examination is created for this patient, saved, and linked to the given RawPdfFile instance. The report'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
@@ -346,11 +345,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.
@@ -358,7 +363,9 @@ class Patient(Person):
         :return: The age of the patient.
         """
         # calculate correct age based on current date including day and month
-        current_date = timezone.now().date()  # Use timezone.now() here too for consistency
+        current_date = (
+            timezone.now().date()
+        )  # Use timezone.now() here too for consistency
         dob = self.dob
         # Ensure dob is not None before calculation
         if dob:
@@ -385,7 +392,9 @@ class Patient(Person):
             date = timezone.now()  # Use timezone.now() instead of datetime.now()
         # Ensure the provided date is timezone-aware if it's not None
         elif timezone.is_naive(date):
-            logger.warning(f"Received naive datetime {date} for PatientLabSample. Making it timezone-aware using current timezone.")
+            logger.warning(
+                f"Received naive datetime {date} for PatientLabSample. Making it timezone-aware using current timezone."
+            )
             date = timezone.make_aware(date, timezone.get_current_timezone())
 
         if isinstance(sample_type, str):
@@ -411,50 +420,70 @@ 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
-        
+        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.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()))
-        
+            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}"
-
-
-