endoreg-db 0.6.4__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/models/network/network_device.py

@@ -1,58 +0,0 @@
-import subprocess
-from django.db import models
-
-# Django db class to store network devices (e.g., servers, clients, switches, etc.)
-
-class NetworkDeviceManager(models.Manager):
-    """Custom manager for NetworkDevice that defines name as natural key."""
-    def get_by_natural_key(self, name):
-        """Return the network device with the given name as its natural key."""
-        return self.get(name=name)
-    
-class NetworkDevice(models.Model):
-    """Django model representing a network device."""
-    name = models.CharField(max_length=255)
-    ip = models.GenericIPAddressField(blank=True, null=True)
-    description = models.CharField(max_length=255)
-    device_type = models.ForeignKey("NetworkDeviceType", on_delete=models.CASCADE)
-    online = models.BooleanField(default=False)
-    created = models.DateTimeField(auto_now_add=True)
-    updated = models.DateTimeField(auto_now=True)
-    objects = NetworkDeviceManager()
-
-    def __str__(self):
-        """Return the device name."""
-        return str(self.name)
-
-    # pylint: disable=too-few-public-methods
-    class Meta:
-        """Meta options for the NetworkDevice model."""
-        db_table = 'network_devices'
-        ordering = ['name']
-        
-    def natural_key(self):
-        """Return a tuple representing the natural key for this network device."""
-        return (self.name,)
-    
-    def ping(self):
-        """Check device availability by sending one ping request."""
-        target_ip = self.ip
-
-        # Define the command
-        command = ['ping', '-c', '1', target_ip]
-
-        # Run the command
-        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-        # Wait for the process to terminate
-        process.wait()
-
-        # Check the return code
-        return_code = process.returncode
-        
-        # Return True if the return code is 0, False otherwise
-        self.online = return_code == 0
-        self.save()
-        return self.online
-
-

endoreg_db/models/network/network_device_type.py

@@ -1,23 +0,0 @@
-# Django db class to store network device types (e.g., server, client, switch, etc.)
-
-from django.db import models
-
-class NetworkDeviceTypeManager(models.Manager):
-    # Custom manager for NetworkDeviceType; defines name as natural key
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class NetworkDeviceType(models.Model):
-    name = models.CharField(max_length=255)
-    description = models.CharField(max_length=255)
-    created = models.DateTimeField(auto_now_add=True)
-    updated = models.DateTimeField(auto_now=True)
-    objects = NetworkDeviceTypeManager()
-
-    def __str__(self):
-        return self.name
-
-    class Meta:
-        db_table = 'network_device_types'
-        ordering = ['name']
-

endoreg_db/models/other/distribution.py

@@ -1,5 +0,0 @@
-
-
-
-
-   

endoreg_db/models/patient/__init__.py

@@ -1,24 +0,0 @@
-from .patient_examination import PatientExamination
-from .patient_finding import (
-    PatientFinding
-)
-from .patient_finding_location import (
-    PatientFindingLocation
-)
-from .patient_finding_morphology import (
-    PatientFindingMorphology
-)
-
-from .patient_finding_intervention import (
-    PatientFindingIntervention
-)
-
-# TODO Migrate to persons/patient
-
-__all__ = [
-    "PatientExamination",
-    "PatientFinding",
-    "PatientFindingLocation",
-    "PatientFindingMorphology",
-    "PatientFindingIntervention"
-]

endoreg_db/models/patient/patient_examination.py

@@ -1,182 +0,0 @@
-from django.db import models
-from typing import List
-
-# Serializer located in serializers/examination.py
-from typing import Optional
-from datetime import datetime
-
-
-class PatientExamination(models.Model):
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.CASCADE, related_name="patient_examinations"
-    )
-    examination = models.ForeignKey(
-        "Examination", on_delete=models.CASCADE, null=True, blank=True
-    )
-    video = models.OneToOneField(
-        "Video",
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-        related_name="patient_examination",
-    )
-    date_start = models.DateField(null=True, blank=True)
-    date_end = models.DateField(null=True, blank=True)
-    hash = models.CharField(max_length=255, unique=True)
-
-    # report_files
-    class Meta:
-        verbose_name = "Patient Examination"
-        verbose_name_plural = "Patient Examinations"
-        ordering = ["patient", "examination", "date_start"]
-
-    @classmethod
-    def get_or_create_pseudo_patient_examination_by_hash(
-        cls,
-        patient_hash: str,
-        examination_hash: str,
-        examination_name: Optional[str] = None,
-    ):
-        from endoreg_db.models import Patient, Examination
-
-        created = False
-
-        if PatientExamination.objects.filter(
-            patient__patient_hash=patient_hash, hash=examination_hash
-        ).exists():
-            return PatientExamination.objects.get(
-                patient__patient_hash=patient_hash, hash=examination_hash
-            ), created
-
-        patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
-        if examination_name is not None:
-            examination = Examination.objects.get(name=examination_name)
-        else:
-            examination = None
-
-        patient_examination = cls.objects.create(
-            patient=patient, examination=examination, hash=examination_hash
-        )
-
-        patient_examination.save()
-
-        created = True
-        return patient_examination, created
-
-    def __str__(self):
-        return f"{self.patient} - {self.examination} - {self.date_start}"
-
-    # override save method to make sure that the hash is always set,
-    # if none is existing generate an unique string
-
-    def generate_default_hash(self):
-        # create random hash
-        import random
-        import string
-
-        _hash = "DEFAULT_HASH_" + "".join(
-            random.choices(string.ascii_uppercase + string.digits, k=10)
-        )
-
-        return _hash
-
-    def save(self, *args, **kwargs):
-        if not self.hash:
-            self.hash = self.generate_default_hash()
-        super().save(*args, **kwargs)
-
-    def get_patient_age_at_examination(self) -> int:
-        """
-        Returns the patient's age at the time of the examination.
-        """
-        from endoreg_db.models import Patient
-        from datetime import datetime
-
-        patient: Patient = self.patient
-        dob = patient.get_dob()
-        date_start = self.date_start
-        return (date_start - dob).days // 365
-
-    def get_available_findings(self):
-        """
-        Returns all findings that are associated with the examination of this patient examination.
-        """
-        from endoreg_db.models import Finding, Examination
-
-        examination: Examination = self.examination
-        findings: List[Finding] = [_ for _ in examination.get_available_findings()]
-        return findings
-
-    def get_findings(self):
-        """
-        Returns all findings that are associated with this patient examination.
-        """
-        from endoreg_db.models import PatientFinding
-
-        patient_findings: List[PatientFinding] = [
-            _ for _ in self.patient_findings.all()
-        ]
-        return patient_findings
-
-    def get_indications(self):
-        """
-        Returns all indications that are associated with this patient examination.
-        """
-        from endoreg_db.models import PatientExaminationIndication
-
-        indications: List[PatientExaminationIndication] = [
-            _ for _ in self.indications.all()
-        ]
-        return indications
-
-    def get_indication_choices(self):
-        """
-        Returns all indication choices that are associated with this patient examination.
-        """
-        from endoreg_db.models import ExaminationIndicationClassificationChoice
-
-        choices: List[ExaminationIndicationClassificationChoice] = [
-            _.indication_choice for _ in self.get_indications()
-        ]
-        return choices
-
-    def create_finding(self, finding):
-        """
-        Adds a finding to this patient examination.
-        """
-        from endoreg_db.models import Finding, Examination, PatientFinding
-
-        examination: Examination = self.examination
-        assert examination
-
-        finding: Finding
-
-        patient_finding = PatientFinding.objects.create(
-            patient_examination=self, finding=finding
-        )
-
-        patient_finding.save()
-
-        return patient_finding
-
-    def find_matching_video_from_patient(self):
-        """
-        Finds a video for this patient examination based on the patient's videos.
-        For this, the videos date must be the same as the report file's date.
-        #TODO add more criteria for matching: Examination type
-        """
-        videos = self.patient.video_set.filter(
-            date=self.report_file.date, patient_examination__isnull=True
-        )
-        if videos:
-            if len(videos) > 1:
-                print(
-                    f"Warning: Found more than one video for patient {self.patient} on date {self.report_file.date}. Choosing the first one."
-                )
-            return videos[0]
-        else:
-            videos = self.patient.video_set.filter(patient_examination__isnull=True)
-            if len(videos) == 1:
-                return videos[0]
-
-        return None

endoreg_db/models/patient/patient_finding.py

@@ -1,143 +0,0 @@
-from django.db import models
-from typing import List
-
-class PatientFinding(models.Model):
-    patient_examination = models.ForeignKey('PatientExamination', on_delete=models.CASCADE, related_name='patient_findings')
-    finding = models.ForeignKey('Finding', on_delete=models.CASCADE, related_name='patient_findings')
-    locations = models.ManyToManyField(
-        'PatientFindingLocation',
-        blank=True,
-        related_name='patient_findings'
-    )
-    morphologies = models.ManyToManyField(
-        'PatientFindingMorphology',
-        blank=True,
-        related_name='patient_findings'
-    )
-    
-
-    class Meta:
-        verbose_name = 'Patient Finding'
-        verbose_name_plural = 'Patient Findings'
-        ordering = ['patient_examination', 'finding']
-
-    def __str__(self):
-        return f"{self.patient_examination} - {self.finding}"
-
-   # functions to get all associated location and morphology choices
-    def get_locations(self):
-        """
-        Returns all location choices that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingLocation
-        locations:List[PatientFindingLocation] = [_ for _ in self.locations.all()]
-        return locations
-    
-    def get_morphologies(self):
-        """
-        Returns all morphology choices that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingMorphology
-        morphologies:List[PatientFindingMorphology] = [_ for _ in self.morphologies.all()]
-        return morphologies   
-
-    def add_morphology_choice(self, morphology_choice, morphology_classification):
-        """
-        Adds a morphology choice to this patient finding morphology.
-        """
-        from endoreg_db.models import (
-            FindingMorphologyClassificationChoice,
-            FindingMorphologyClassification,
-            PatientFindingMorphology
-        )
-        morphology_choice: FindingMorphologyClassificationChoice
-        morphology_classification: FindingMorphologyClassification
-        
-        patient_finding_morphology = PatientFindingMorphology.objects.create(
-            morphology_classification=morphology_classification,
-            morphology_choice=morphology_choice
-        )
-        patient_finding_morphology.save()
-
-        self.morphologies.add(patient_finding_morphology)
-        self.save()
-
-        return patient_finding_morphology
-
-    def add_intervention(self, intervention, state="pending", date=None):
-        """
-        Adds an intervention to this patient finding.
-        """
-        from endoreg_db.models import PatientFindingIntervention
-        patient_finding_intervention = PatientFindingIntervention.objects.create(
-            patient_finding=self,
-            intervention=intervention,
-            state = state,
-            date = date
-        )
-        patient_finding_intervention.save()
-
-        return patient_finding_intervention
-
-    def add_location_choice(self, location_choice, location_classification):
-        """
-        Adds a location choice to this patient finding location.
-        """
-        from endoreg_db.models import (
-            FindingLocationClassificationChoice,
-            FindingLocationClassification,
-            PatientFindingLocation
-        )
-        location_choice: FindingLocationClassificationChoice
-        location_classification: FindingLocationClassification
-        
-        patient_finding_location = PatientFindingLocation.objects.create(
-            location_classification=location_classification,
-            location_choice=location_choice
-        )
-        patient_finding_location.save()
-
-        self.locations.add(patient_finding_location)
-        self.save()
-
-        return patient_finding_location
-
-    def get_interventions(self):
-        """
-        Returns all interventions that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingIntervention
-        interventions:List[PatientFindingIntervention] = [_ for _ in self.interventions.all()]
-        return interventions
-
-    def set_random_location(
-            self, location_classification
-        ):
-        """
-        Sets a random location for this finding based on the location classification.
-        """
-        from endoreg_db.models import (
-            FindingLocationClassificationChoice,
-            FindingLocationClassification, 
-            PatientFindingLocation
-        )
-        import random
-        from typing import List
-        location_classification:FindingLocationClassification
-
-        # assert location_classification in self.finding.location_classifications.all()
-
-        location_choices:List[FindingLocationClassificationChoice] = location_classification.choices.all()
-        location_choice = random.choice(location_choices)
-
-        patient_finding_location = PatientFindingLocation.objects.create(
-            location_classification=location_classification,
-            location_choice=location_choice
-        )
-
-        self.locations.add(patient_finding_location)
-        self.save()
-
-        return patient_finding_location
-    
-    

endoreg_db/models/patient/patient_finding_location.py

@@ -1,120 +0,0 @@
-from django.db import models
-
-class PatientFindingLocation(models.Model):
-    location_classification = models.ForeignKey('FindingLocationClassification', on_delete=models.CASCADE, related_name='patient_finding_locations')
-    location_choice = models.ForeignKey('FindingLocationClassificationChoice', on_delete=models.CASCADE, related_name='patient_finding_locations')
-    subcategories = models.JSONField(blank=True, null=True)
-    numerical_descriptors = models.JSONField(blank=True, null=True)
-
-    class Meta:
-        verbose_name = 'Patient Finding Location'
-        verbose_name_plural = 'Patient Finding Locations'
-        ordering = ['location_classification', 'location_choice']
-
-    def __str__(self):
-        return f"{self.location_classification} - {self.location_choice}"
-    
-    # override save method to do the following:
-    # - check if location_choice is in location_classification.choices
-    # - check if subcategories and numerical_descriptors exist
-    # - if not set, fetch them from location_choice and set them
-
-    def save(self, *args, **kwargs):
-        if self.location_choice not in self.location_classification.choices.all():
-            raise ValueError("location_choice must be in location_classification.choices")
-
-        if not self.subcategories:
-            self.subcategories = self.location_choice.subcategories
-
-        if not self.numerical_descriptors:
-            self.numerical_descriptors = self.location_choice.numerical_descriptors
-
-        super().save(*args, **kwargs)
-
-    def set_subcategory(self, subcategory_name, subcategory_value):
-        """
-        Sets a subcategory for this location.
-        """
-        assert subcategory_name in self.subcategories, "Subcategory must be in subcategories."
-        self.subcategories[subcategory_name]["value"] = subcategory_value
-        self.save()
-
-        return self.subcategories[subcategory_name]
-
-    def set_random_subcategories(self):
-        """
-        Sets random subcategories for this location if they are required.
-        """
-        import random
-        if not self.subcategories or not self.numerical_descriptors:
-            self.save()
-
-        self.refresh_from_db()
-        assert self.subcategories, "Subcategories must be set."
-
-        subcategories = self.subcategories
-        # print("SUBCATS")
-        # print(subcategories)
-
-        # subcategories is dict with keys as subcategory names and values as dict with keys as "choices" (List of str) and "required" (bool)
-        # for each subcategory, set a random choice if it is required
-        for subcategory_name, subcategory_dict in subcategories.items():
-            if subcategory_dict["required"]:
-                subcategory_choice = random.choice(subcategory_dict["choices"])
-                self.subcategories[subcategory_name]["value"] = subcategory_choice
-
-        self.save()
-
-        return self.subcategories
-    
-    def set_random_numerical_descriptor(self, descriptor_name):
-        """
-        Sets a random numerical descriptor for this location.
-        """
-        import random
-        if descriptor_name not in self.numerical_descriptors:
-            raise ValueError("Descriptor name must be in numerical descriptors.")
-
-        numerical_descriptor = self.numerical_descriptors[descriptor_name]
-        min_value = numerical_descriptor["min"]
-        max_value = numerical_descriptor["max"]
-
-        assert min_value <= max_value, "Min value must be less than or equal to max value."
-
-        random_value = random.uniform(min_value, max_value)
-        self.numerical_descriptors[descriptor_name]["value"] = random_value
-        self.save()
-
-        return self.numerical_descriptors[descriptor_name]
-
-
-    def set_random_numerical_descriptors(self):
-        """
-        Sets random numerical descriptors for this location if they are required.
-        """
-        import random
-        from endoreg_db.models import FindingLocationClassificationChoice
-        if not self.subcategories or not self.numerical_descriptors:
-            self.save()
-
-        numerical_descriptors = self.numerical_descriptors
-        numerical_descriptor = {}
-
-        # numerical_descriptors is dict with keys as numerical descriptor names 
-        # and values as dict with keys as "min" (float), "max" (float), required (bool), distribution_name (str)
-        # distribution name can be either "uniform" or "normal"
-        # for each numerical descriptor, set a random value between min and max
-        for numerical_descriptor_name, numerical_descriptor_dict in numerical_descriptors.items():
-            min_value = numerical_descriptor_dict["min"]
-            max_value = numerical_descriptor_dict["max"]
-
-            assert min_value <= max_value, "Min value must be less than or equal to max value."
-
-
-            random_value = random.uniform(min_value, max_value)
-            numerical_descriptor[numerical_descriptor_name] = random_value
-
-        self.numerical_descriptors = numerical_descriptor
-        self.save()
-
-        return numerical_descriptor