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

endoreg_db/models/finding/finding_morphology_classification.py

@@ -1,89 +0,0 @@
-from django.db import models
-from typing import List
-
-class FindingMorphologyClassificationTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class FindingMorphologyClassificationType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True)
-    name_en = models.CharField(max_length=255, blank=True)
-    description = models.TextField(blank=True)
-    
-    objects = FindingMorphologyClassificationTypeManager()
-    
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-    
-    @classmethod
-    def get_required_classifications_for_finding(cls, finding):
-        """
-        Returns all required morphology classification types for a given finding.
-        """
-        from endoreg_db.models import FindingMorphologyClassificationType
-        required_classification_types:List[FindingMorphologyClassificationType] = [
-            _ for _ in finding.required_morphology_classification_types.all()
-        ]
-        return required_classification_types
-    
-class FindingMorphologyClassificationManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class FindingMorphologyClassification(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True)
-    name_en = models.CharField(max_length=255, blank=True)
-    description = models.TextField(blank=True)
-    classification_type = models.ForeignKey(FindingMorphologyClassificationType, on_delete=models.CASCADE)
-    
-    objects = FindingMorphologyClassificationManager()
-    
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-    
-    def get_choices(self):
-        choices: List[FindingMorphologyClassificationChoice] = [_ for _ in self.choices.all()]
-        return choices
-    
-class FindingMorphologyClassificationChoiceManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class FindingMorphologyClassificationChoice(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True)
-    name_en = models.CharField(max_length=255, blank=True)
-    description = models.TextField(blank=True)
-    classification = models.ForeignKey(
-        FindingMorphologyClassification, 
-        on_delete=models.CASCADE,
-        related_name='choices'
-    )
-    
-    subcategories = models.JSONField(
-        default = dict
-    )
-
-    numerical_descriptors = models.JSONField(
-        default = dict
-    )
-
-    objects = FindingMorphologyClassificationChoiceManager()
-    
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        _str = f"{self.name} ({self.classification})"
-        return _str
-
-    
-        

endoreg_db/models/finding/finding_type.py

@@ -1,22 +0,0 @@
-from django.db import models
-
-
-class FindingTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class FindingType(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    name_de = models.CharField(max_length=100, blank=True, null=True)
-    name_en = models.CharField(max_length=100, blank=True, null=True)
-    description = models.TextField(blank=True, null=True)
-    description_de = models.TextField(blank=True, null=True)
-    description_en = models.TextField(blank=True, null=True)
-
-    objects = FindingTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name

endoreg_db/models/hardware/__init__.py

@@ -1,2 +0,0 @@
-from .endoscopy_processor import EndoscopyProcessor
-from .endoscope import Endoscope, EndoscopeType

endoreg_db/models/information_source.py

@@ -1,65 +0,0 @@
-from django.db import models
-
-
-def get_prediction_information_source():
-    """
-    Retrieve the prediction information source.
-    
-    This function queries the InformationSource model for an entry with the name
-    "prediction" using Django's ORM and asserts that the retrieved object is valid.
-    It returns the matching InformationSource instance.
-    
-    Returns:
-        InformationSource: The InformationSource object with name "prediction".
-    
-    Raises:
-        AssertionError: If no prediction information source is found.
-    """
-    _source = InformationSource.objects.get(name="prediction")
-
-    # make sure to return only one object
-    assert _source, "No prediction information source found"
-    return _source
-
-
-class InformationSourceManager(models.Manager):
-    def get_by_natural_key(self, name):
-        """
-        Retrieves a model instance using its natural key.
-        
-        Args:
-            name: The natural key value corresponding to the model's 'name' field.
-        
-        Returns:
-            The model instance that matches the provided natural key.
-        """
-        return self.get(name=name)
-
-
-class InformationSource(models.Model):
-    objects = InformationSourceManager()
-
-    name = models.CharField(max_length=100)
-    name_de = models.CharField(max_length=100, blank=True, null=True)
-    name_en = models.CharField(max_length=100, blank=True, null=True)
-
-    url = models.URLField(blank=True, null=True)
-    description = models.TextField(blank=True, null=True)
-    date = models.DateField(blank=True, null=True)
-
-    def natural_key(self):
-        """
-        Returns the natural key tuple for the information source.
-        
-        The tuple contains the object's name, which uniquely identifies it for 
-        serialization and natural key lookup.
-        """
-        return (self.name,)
-
-    def __str__(self):
-        """
-        Return the string representation of the InformationSource instance.
-        
-        This method returns the instance's name attribute converted explicitly to a string.
-        """
-        return str(self.name)

endoreg_db/models/laboratory/__init__.py

@@ -1 +0,0 @@
-from .lab_value import LabValue

endoreg_db/models/laboratory/lab_value.py

@@ -1,162 +0,0 @@
-from django.db import models
-import warnings
-
-LANG = "de"
-
-
-class LabValueManager(models.Manager):
-    def get_by_natural_key(self, name):
-        """
-        Retrieves a model instance by its natural key.
-        
-        This method returns the instance whose unique name matches the provided natural key.
-          
-        Args:
-            name: The unique identifier corresponding to the model's "name" field.
-          
-        Returns:
-            The model instance with a matching name.
-        """
-        return self.get(name=name)
-
-
-class LabValue(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-    abbreviation = models.CharField(max_length=10, blank=True, null=True)
-    default_unit = models.ForeignKey(
-        "Unit", on_delete=models.CASCADE, blank=True, null=True
-    )
-    numeric_precision = models.IntegerField(default=3)
-    default_single_categorical_value_distribution = models.ForeignKey(
-        "SingleCategoricalValueDistribution",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="default_single_categorical_value_distribution",
-    )
-    default_numerical_value_distribution = models.ForeignKey(
-        "NumericValueDistribution",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="default_numerical_value_distribution",
-    )
-    default_multiple_categorical_value_distribution = models.ForeignKey(
-        "MultipleCategoricalValueDistribution",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="default_multiple_categorical_value_distribution",
-    )
-    default_date_value_distribution = models.ForeignKey(
-        "DateValueDistribution",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="default_date_value_distribution",
-    )
-    default_normal_range = models.JSONField(blank=True, null=True)
-    normal_range_age_dependent = models.BooleanField(default=False)
-    normal_range_gender_dependent = models.BooleanField(default=False)
-    normal_range_special_case = models.BooleanField(default=False)
-    objects = LabValueManager()
-
-    def natural_key(self):
-        """
-        Return a tuple representing the natural key for this instance.
-        
-        Returns:
-            tuple: A single-element tuple containing the instance's unique name.
-        """
-        return (self.name,)
-
-    def __str__(self):
-        """
-        Return the lab value name as a string.
-        
-        Converts the lab value's `name` attribute into its string representation for
-        display purposes.
-        """
-        return str(self.name)
-
-    def get_default_default_distribution(self):
-        """
-        Returns the first available default distribution for the lab value.
-        
-        Checks the default distribution fields in the following order:
-        default_single_categorical_value_distribution, default_numerical_value_distribution,
-        default_multiple_categorical_value_distribution, and default_date_value_distribution.
-        If none are set, a warning is issued and None is returned.
-        """
-        if self.default_single_categorical_value_distribution:
-            return self.default_single_categorical_value_distribution
-        elif self.default_numerical_value_distribution:
-            return self.default_numerical_value_distribution
-        elif self.default_multiple_categorical_value_distribution:
-            return self.default_multiple_categorical_value_distribution
-        elif self.default_date_value_distribution:
-            return self.default_date_value_distribution
-        else:
-            warnings.warn("No default distribution set for lab value")
-            return None
-
-    def get_normal_range(self, age: int = None, gender=None):
-        """
-        Retrieve the normal range for the lab value based on optional age and gender.
-        
-        This method returns the default normal range when the lab value is not age-, gender-, or special-case dependent.
-        For gender-dependent ranges, it uses a gender-specific default range and, if no gender is provided, selects one at random with a warning.
-        Note that age-dependent and special-case normal ranges are not implemented and will issue warnings when invoked.
-        
-        Args:
-            age (int, optional): The age in years used for age-dependent range computation.
-            gender (Gender, optional): The gender instance used for gender-dependent range computation.
-        
-        Returns:
-            dict: A dictionary with 'min' and 'max' keys indicating the lower and upper bounds of the normal range.
-        """
-        from endoreg_db.models import Gender
-
-        assert isinstance(age, int) or age is None
-        assert isinstance(gender, Gender) or gender is None
-
-        age_dependent = self.normal_range_age_dependent
-        gender_dependent = self.normal_range_gender_dependent
-        special_case = self.normal_range_special_case
-
-        min_value = None
-        max_value = None
-
-        if not age_dependent and not gender_dependent and not special_case:
-            min_value = self.default_normal_range.get("min", None)
-            max_value = self.default_normal_range.get("max", None)
-
-        if age_dependent:
-            # get normal range for age)
-            warnings.warn("Age dependent normal range not implemented yet")
-            pass
-
-        if gender_dependent:
-            if not gender:
-                warnings.warn(
-                    "Calling get_normal_range with gender_dependent=True requires gender to be set, choosing by random"
-                )
-                # set gender to either "male" or "female"
-                from random import choice
-
-                choices = ["male", "female"]
-                gender = choice(choices)
-
-            default_range_dict = self.default_normal_range.get(gender.name, {})
-            min_value = default_range_dict.get("min", None)
-            max_value = default_range_dict.get("max", None)
-
-        if special_case:
-            # get normal range for special case
-            warnings.warn("Special case normal range not implemented yet")
-
-        normal_range_dict = {"min": min_value, "max": max_value}
-
-        return normal_range_dict

endoreg_db/models/logging/__init__.py

@@ -1,11 +0,0 @@
-from .base import AbstractLogEntry
-from .network_device import NetworkDeviceLogEntry
-from .log_type import LogType
-from .agl_service import AglServiceLogEntry
-
-__all__ = [
-    "AbstractLogEntry",
-    "NetworkDeviceLogEntry",
-    "LogType",
-    "AglServiceLogEntry",
-]

endoreg_db/models/logging/agl_service.py

@@ -1,19 +0,0 @@
-from django.db import models
-from .base import AbstractLogEntry
-
-class AglServiceLogEntry(AbstractLogEntry):
-    """
-    Model for log entries related to AGL services.
-    """
-    service = models.ForeignKey("AglService", on_delete=models.CASCADE)
-    device = models.ForeignKey(
-        "NetworkDevice", on_delete=models.CASCADE, null=True, blank=True
-    )
-    log_type = models.ForeignKey("LogType", on_delete=models.CASCADE, null=True, blank=True)
-
-    class Meta:
-        verbose_name = "AGL Service Log Entry"
-        verbose_name_plural = "AGL Service Log Entries"
-
-    def __str__(self):
-        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.service} - {self.message}"

endoreg_db/models/logging/base.py

@@ -1,22 +0,0 @@
-# django model for logging, first define an abstract base model
-from django.db import models
-from django.conf import settings
-
-class AbstractLogEntry(models.Model):
-    """
-    Abstract base model for log entries.
-    """
-
-    class Meta:
-        abstract = True
-
-    timestamp = models.DateTimeField(auto_now_add=True)
-    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True)
-    ip_address = models.GenericIPAddressField(null=True, blank=True)
-    user_agent = models.CharField(max_length=256, null=True, blank=True)
-    message = models.TextField()
-    json_content = models.JSONField(null=True, blank=True)
-    
-
-    def __str__(self):
-        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.message}"

endoreg_db/models/logging/log_type.py

@@ -1,23 +0,0 @@
-from django.db import models
-
-class LogTypeManager(models.Manager):
-    # Custom manager for LogType; defines name as natural key
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-
-class LogType(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 = LogTypeManager()
-    
-    def __str__(self):
-        return self.name
-    
-    class Meta:
-        ordering = ['name']
-        
-    def natural_key(self):
-        return (self.name,)

endoreg_db/models/logging/network_device.py

@@ -1,27 +0,0 @@
-from django.db import models
-from .base import AbstractLogEntry
-
-class NetworkDeviceLogEntry(AbstractLogEntry):
-    """
-    Model for log entries related to network devices.
-    """
-    device = models.ForeignKey("NetworkDevice", on_delete=models.CASCADE)
-    log_type = models.ForeignKey("LogType", on_delete=models.CASCADE, null=True, blank=True)
-
-    datetime = models.DateTimeField(default=None, null=True, blank=True)
-    # hostname = models.CharField(max_length=255, null=True, blank=True)
-    aglnet_ip = models.GenericIPAddressField(null=True, blank=True)
-    vpn_service_status = models.CharField(max_length=255, null=True, blank=True)
-    vpn_service_restart_attempt = models.BooleanField(default=False)
-    vpn_service_restart_success = models.BooleanField(null=True, blank=True)
-    ping_vpn = models.BooleanField(default=False)
-    ping_www = models.BooleanField(default=False)
-    transferred_to_host = models.BooleanField(default=False)
-
-    class Meta:
-        verbose_name = "Network Device Log Entry"
-        verbose_name_plural = "Network Device Log Entries"
-
-    def __str__(self):
-        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.device} - {self.message}"
-

endoreg_db/models/lx/__init__.py

@@ -1,4 +0,0 @@
-from .client import LxClientType, LxClientTag, LxClient
-from .identity import LxIdentity, LxIdentityType
-from .permission import LxPermission
-from .user import LxUser

endoreg_db/models/lx/client.py

@@ -1,57 +0,0 @@
-# Insert models for Client, Client Type, Client Tag
-
-from django.db import models
-
-class LxClientTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-#TODO implement base population for client Type
-
-class LxClientType(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    abbreviation = models.CharField(max_length=10, unique=True)  # New field
-    description = models.TextField(blank=True)
-    objects = LxClientTypeManager()
-    
-    def __str__(self):
-        return self.name
-    
-    def natural_key(self):
-        return (self.name,)
-    
-
-class LxClientTagManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-#TODO implement base population for client Tag
-
-class LxClientTag(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    objects = LxClientTagManager()
-
-    # M2M relationship with LxPermission
-    permissions = models.ManyToManyField('LxPermission', blank=True, related_name="allowed_client_tags")
-    
-    def __str__(self):
-        return self.name
-    
-    def natural_key(self):
-        return (self.name,)
-
-class LxClientManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-#TODO implement base population for client
-
-class LxClient(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    client_type = models.ForeignKey(LxClientType, on_delete=models.CASCADE)
-    client_tags = models.ManyToManyField(LxClientTag, blank=True)
-    vpn_ip = models.GenericIPAddressField(blank=True, null=True)
-    objects = LxClientManager()
-

endoreg_db/models/lx/identity.py

@@ -1,34 +0,0 @@
-from django.db import models
-
-class LxIdentityTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-#TODO implement base population for identity Type
-## ed25519, rsa, ecdsa, dsa, etc
-
-class LxIdentityType(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    objects = LxIdentityTypeManager()
-    
-    def __str__(self):
-        return self.name
-    
-    def natural_key(self):
-        return (self.name,)
-
-class LxIdentity(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    identity_type = models.ForeignKey(LxIdentityType, on_delete=models.CASCADE)
-    objects = models.Manager()
-
-    # Foreign key to user, nullable
-    user = models.ForeignKey('LxUser', on_delete=models.CASCADE, null=True, blank=True)
-    
-    def __str__(self):
-        return self.name
-    
-    def natural_key(self):
-        return (self.name,)

endoreg_db/models/lx/permission.py

@@ -1,18 +0,0 @@
-from django.db import models
-
-class LxPermissionManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-#TODO implement base population for permission
-
-class LxPermission(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    objects = LxPermissionManager()
-    
-    def __str__(self):
-        return self.name
-    
-    def natural_key(self):
-        return (self.name,)

endoreg_db/models/lx/user.py

@@ -1,16 +0,0 @@
-from django.db import models
-
-class LxUserManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-
-class LxUser(models.Model):
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-
-    
-
-    # to be extended
-
-

endoreg_db/models/network/__init__.py

@@ -1,9 +0,0 @@
-from .network_device import NetworkDevice
-from .network_device_type import NetworkDeviceType
-from .agl_service import AglService
-
-__all__ = [
-    "NetworkDevice",
-    "NetworkDeviceType",
-    "AglService",
-]

endoreg_db/models/network/agl_service.py

@@ -1,38 +0,0 @@
-from django.db import models
-
-class AglServiceManager(models.Manager):
-    # Custom manager for AglService; defines name as natural key
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class AglService(models.Model):
-    name = models.CharField(max_length=255)
-    description = models.CharField(max_length=255)
-    online = models.BooleanField(default=False)
-    created = models.DateTimeField(auto_now_add=True)
-    updated = models.DateTimeField(auto_now=True)
-    objects = AglServiceManager()
-    devices = models.ManyToManyField("NetworkDevice", related_name="services")
-    port = models.IntegerField(blank=True, null=True)
-    protocol = models.CharField(max_length=255, blank=True, null=True)
-    url = models.URLField(blank=True, null=True)
-
-    def alive_log(self, user, ip_address, user_agent):
-        from ..logging import AglServiceLogEntry
-        AglServiceLogEntry.objects.create(
-            user=user,
-            ip_address=ip_address,
-            user_agent=user_agent,
-            message=f"Service {self.name} is alive.",
-            service=self
-        )
-
-    def __str__(self):
-        return self.name
-
-    class Meta:
-        ordering = ['name']
-        
-    def natural_key(self):
-        return (self.name,)
-