endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/questionnaires/__init__.py

@@ -0,0 +1,114 @@
+from django.db import models
+
+YES_NO_CHOICES = (
+    ('yes', 'Ja'),
+    ('no', 'Nein'),
+)
+
+class TtoQuestionnaire(models.Model):
+
+    # Patient Information
+    patient_name = models.CharField(max_length=255, verbose_name="Identifikation des Patienten (Name)")
+    birth_date = models.DateField(verbose_name="Geburtsdatum")
+
+    # Base documentation
+    emergency_patient = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Notfallpatient/kürzlich untersuchter Patient (Verzicht auf Team-Time-Out möglich)")
+    consent_signed = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Einverständniserklärung unterschrieben (Arzt, Patient)")
+    documents_present = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Alle Dokumente liegen vor (Labor, Befunde, etc.)")
+    communication_possible = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Kommunikation mit Patient möglich")
+    work_incapacity_certificate = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Arbeitsunfähigkeitsbescheinigung")
+
+    # priority items
+    pregnancy = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Schwangerschaft")
+    asa_classification_checked = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="ASA-Klassifikation/Komorbidität geprüft")
+    previous_anesthesia_complications = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Komplikationen bei bisherigen Narkosen?")
+    last_meal_over_6_hours_ago = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Zeitpunkt letzte Mahlzeit > 6 Stunden")
+    allergies = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Allergien, welche?")
+    outpatient_accompaniment_post_sedation = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Nur bei ambulanter Vorstellung: Begleitung nach Sedierung?")
+    
+    # Possessions
+    dental_prosthesis = models.BooleanField(default=False, verbose_name="Zahnprothese")
+    glasses = models.BooleanField(default=False, verbose_name="Brille")
+    implants = models.BooleanField(default=False, verbose_name="Implantate")
+    hearing_aids = models.BooleanField(default=False, verbose_name="Hörgeräte")
+    
+
+    # Medical History
+    anticoagulants_ass = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Antikoagulation, ASS")
+    blood_pressure_medication = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Blutdruckmedikamente")
+    glaucoma = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Glaukom")
+
+    metal_implants = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Metallimplantate")
+    pacemaker_icd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Herzschrittmacher/ICD")
+    
+    copd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="COPD")
+    liver_cirrhosis = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Leberzirrhose")
+    
+    ibd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="CED (Chronisch entzündliche Darmerkrankungen)")
+    radiation = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Bestrahlung")
+    surgeries = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="OP´s")
+
+    # preflight
+    team_introduction = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Teamvorstellung mit Name und Aufgabe")
+    instruments_available = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Notwendige Instrumente vorhanden?")
+    monitoring_medications_equipment_checked = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Monitoring, Medikamente, Equipment zum Atemwegsmanagement zur Verfügung und überprüft?")
+    complete_documentation_inclusive_care_notes = models.TextField(verbose_name="Vollständige Dokumentation inklusive Hinweise für Nachsorge")
+    
+    # notes
+    notes = models.TextField(verbose_name="Bemerkungen", default = "Keine Bemerkungen")
+    
+    # postflight  
+    specimens_secured = models.BooleanField(default=False, verbose_name="Histologische Proben gesichert")
+    patient_condition_documented = models.TextField(verbose_name="Patientenzustand dokumentiert (je nach Ausgangszustand)")
+
+    
+
+    def __str__(self):
+        return f"Endoscopy Questionnaire for {self.patient_name} on {self.birth_date}"
+    
+    def get_id_attributes(self):
+        _ = [self.patient_name, self.birth_date]
+        return _
+    
+    def get_base_documentation_attributes(self):
+        _ = [self.emergency_patient, self.consent_signed, self.documents_present, self.communication_possible, self.work_incapacity_certificate]
+        return _
+    
+    def get_priority_items_attributes(self):
+        _ = [self.pregnancy, self.asa_classification_checked, self.previous_anesthesia_complications, self.last_meal_over_6_hours_ago, self.allergies, self.outpatient_accompaniment_post_sedation]
+        return _
+    
+    def get_possessions_attributes(self):
+        _ = [self.dental_prosthesis, self.glasses, self.implants, self.hearing_aids]
+        return _
+    
+    def get_medical_history_attributes(self): 
+        _ = [
+            self.anticoagulants_ass,
+            self.blood_pressure_medication,
+            self.glaucoma,
+            self.metal_implants,
+            self.pacemaker_icd,
+            self.copd,
+            self.liver_cirrhosis,
+            self.ibd,
+            self.radiation,
+            self.surgeries,
+        ]
+
+    def get_preflight_attributes(self):
+        _ = [
+            self.team_introduction,
+            self.instruments_available,
+            self.monitoring_medications_equipment_checked,
+        ]
+
+    def get_note_attributes(self):
+        _ = [self.notes]
+
+    def get_postflight_attributes(self):
+        _ = [
+            self.specimens_secured,
+            self.patient_condition_documented
+        ]
+

endoreg_db/models/quiz/__init__.py

@@ -0,0 +1,9 @@
+from .quiz_answer import QuizAnswer, QuizAnswerType
+from .quiz_question import QuizQuestion, QuizQuestionType
+
+__all__ = [
+    "QuizAnswer",
+    "QuizAnswerType",
+    "QuizQuestion",
+    "QuizQuestionType",
+] 

endoreg_db/models/quiz/quiz_answer.py

@@ -0,0 +1,41 @@
+from django.db import models
+
+class QuizAnswerTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class QuizAnswerType(models.Model):
+    objects = QuizAnswerTypeManager()
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+class QuizAnswerManager(models.Manager):
+    def get_by_natural_key(self, text):
+        return self.get(text=text)
+    
+class QuizAnswer(models.Model):
+    objects = QuizAnswerManager()
+
+    text_value = models.CharField(max_length=255, null=True, blank=True)
+    number_value = models.FloatField(null=True, blank=True)
+    answer_type = models.ForeignKey("QuizAnswerType", on_delete=models.CASCADE)
+    question = models.ForeignKey("QuizQuestion", on_delete=models.CASCADE)
+
+    last_updated = models.DateTimeField(auto_now=True)
+
+    #TODO add user as foreign key
+
+    def natural_key(self):
+        return (self.text,)
+    
+    def __str__(self):
+        return self.text
+    
+

endoreg_db/models/quiz/quiz_question.py

@@ -0,0 +1,54 @@
+from django.db import models
+
+class QuizQuestionTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class QuizQuestionType(models.Model):
+    """
+    A class representing a quiz question type.
+
+    Attributes:
+        name (str): The name of the quiz question type.
+        description (str): A description of the quiz question type.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = QuizQuestionTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+class QuizQuestionManager(models.Manager):
+    def get_by_natural_key(self, text):
+        return self.get(text=text)
+    
+class QuizQuestion(models.Model):
+    """
+    A class representing a quiz question.
+
+    Attributes:
+        text (str): The text of the quiz question.
+        question_type (QuizQuestionType): The type of the quiz question.
+        description (str): A description of the quiz question.
+
+    """
+    text = models.TextField()
+    description = models.TextField(blank=True, null=True)
+    question_type = models.ForeignKey("QuizQuestionType", on_delete=models.CASCADE)
+
+    objects = QuizQuestionManager()
+
+    def natural_key(self):
+        return (self.text,)
+    
+    def __str__(self):
+        return self.text
+    
+    def get_question_type(self):
+        return self.question_type.name

endoreg_db/models/report_reader/__init__.py

@@ -0,0 +1,7 @@
+from .report_reader_config import ReportReaderConfig
+from .report_reader_flag import ReportReaderFlag
+
+__all__ = [
+    'ReportReaderConfig',
+    'ReportReaderFlag',
+]

endoreg_db/models/report_reader/report_reader_config.py

@@ -0,0 +1,53 @@
+# ReportReaderConfig Class
+# Description: This class is used to store the configuration of the ReportReader
+
+# PATIENT_INFO_LINE_FLAG = "Patient: "
+# ENDOSCOPE_INFO_LINE_FLAG = "Gerät: "
+# EXAMINER_INFO_LINE_FLAG = "1. Unters.:"
+# CUT_OFF_BELOW_LINE_FLAG = "________________"
+
+
+# CUT_OFF_ABOVE_LINE_FLAGS = [
+#     ENDOSCOPE_INFO_LINE_FLAG,
+#     EXAMINER_INFO_LINE_FLAG,
+# ]
+
+# CUT_OFF_BELOW_LINE_FLAGS = [
+#         CUT_OFF_BELOW_LINE_FLAG
+#     ]
+
+from django.db import models
+from .report_reader_flag import ReportReaderFlag
+from ..center import Center
+from ..data_file import PdfType
+
+class ReportReaderConfig(models.Model):
+
+    locale = models.CharField(default="de_DE", max_length=10)
+    first_names = models.ManyToManyField('FirstName', related_name='report_reader_configs')
+    last_names = models.ManyToManyField('LastName', related_name='report_reader_configs')
+    text_date_format = models.CharField(default = "%d.%m.%Y", max_length=10)
+    patient_info_line_flag = models.ForeignKey(ReportReaderFlag, related_name='report_reader_configs_patient_info_line', on_delete=models.CASCADE)
+    endoscope_info_line_flag = models.ForeignKey(ReportReaderFlag, related_name='report_reader_configs_endoscope_info_line', on_delete=models.CASCADE)
+    examiner_info_line_flag = models.ForeignKey(ReportReaderFlag, related_name='report_reader_configs_examiner_info_line', on_delete=models.CASCADE)
+    cut_off_below = models.ManyToManyField(ReportReaderFlag, related_name='report_reader_configs_cut_off_below')
+    cut_off_above = models.ManyToManyField(ReportReaderFlag, related_name='report_reader_configs_cut_off_above')
+    
+    def __str__(self):
+        return self.locale
+    
+    def update_names_by_center(self, center:Center, save = True):
+        self.first_names.set(center.first_names.all())
+        self.last_names.set(center.last_names.all())
+        if save:
+            self.save()
+
+    def update_flags_by_pdf_type(self, pdf_type:PdfType, save = True):
+        self.patient_info_line_flag = pdf_type.patient_info_line_flag
+        self.endoscope_info_line_flag = pdf_type.endoscope_info_line_flag
+        self.examiner_info_line_flag = pdf_type.examiner_info_line_flag
+        self.cut_off_below.set(pdf_type.cut_off_below.all())
+        self.cut_off_above.set(pdf_type.cut_off_above.all())
+        if save:
+            self.save()
+

endoreg_db/models/report_reader/report_reader_flag.py

@@ -0,0 +1,20 @@
+# Django model for the report reader flag
+# have name and value
+# name is natural key
+
+from django.db import models
+
+class ReportReaderFlagManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ReportReaderFlag(models.Model):
+    objects = ReportReaderFlagManager()
+    name = models.CharField(max_length=255, unique=True)
+    value = models.CharField(max_length=255)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/rules/__init__.py

@@ -0,0 +1,5 @@
+from .rule_type import RuleType
+from .rule import Rule
+from .ruleset import Ruleset
+from .rule_attribute_dtype import RuleAttributeDType
+from .rule_applicator import RuleApplicator

endoreg_db/models/rules/rule.py

@@ -0,0 +1,24 @@
+from django.db import models
+
+class RuleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Rule(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)
+    description = models.TextField(blank=True, null=True)
+    attribute_key = models.CharField(max_length=255)
+    rule_type = models.ForeignKey("RuleType", on_delete=models.CASCADE)
+    attribute_dtype = models.ForeignKey("RuleAttributeDType", on_delete=models.CASCADE)
+
+    objects = RuleManager()
+
+    class Meta:
+        verbose_name = 'Rule'
+        verbose_name_plural = 'Rules'
+
+    def natural_key(self):
+        return (self.name,)
+    

endoreg_db/models/rules/rule_applicator.py

@@ -0,0 +1,224 @@
+from .rule import Rule
+import random
+from django.core.exceptions import ValidationError
+
+class RuleApplicator:
+    """
+    A class to apply different types of rules to a Django model instance based on the Rule configuration.
+    """
+
+    def get_rule_by_name(self, rule_name):
+        """
+        A helper method to fetch a rule by name. This can be further customized.
+        """
+        # get rule by name which is natural key
+        rule = Rule.objects.get_by_natural_key(rule_name)
+        return rule
+
+
+    def apply(self, obj, rule):
+        """
+        Applies a specified rule to an object based on the rule type and attributes.
+
+        Parameters:
+        obj (Django model instance): The object to which the rule is applied.
+        rule (Rule): The rule instance containing the rule_type and attribute details.
+        """
+        rule_type_method = self.get_rule_type_method(rule.rule_type.name)
+        if rule_type_method:
+            rule_type_method(obj, rule)
+
+        else:
+            raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
+        
+    def apply_rule_by_name(self, obj, rule_name):
+        """
+        A helper method to apply a rule and get a value. This can be further customized.
+        """
+        rule = self.get_rule_by_name(rule_name)
+        self.apply(obj, rule)
+
+    def apply_rules_by_name(self, obj, rule_names):
+        """
+        A helper method to apply multiple rules and get values. This can be further customized.
+        """
+        rules = [self.get_rule_by_name(rule_name) for rule_name in rule_names]
+        for rule in rules:
+            self.apply(obj, rule)
+            
+
+    def get_rule_type_method(self, rule_type_name):
+        """
+        Maps rule type name to the corresponding method.
+        """
+        return getattr(self, f"handle_{rule_type_name}", None)
+
+    def parse_attribute_path(self, obj, attribute_key):
+        """
+        Parses the attribute path and applies the value to the correct attribute of a nested object.
+        """
+        parts = attribute_key.split('.')
+        model_name = parts[0]
+        if model_name.lower() != obj.__class__.__name__.lower():
+            raise ValidationError(f"Model type mismatch: expected {model_name}, got {obj.__class__.__name__}")
+
+        # Navigate through the nested attributes
+        target = obj
+        for part in parts[1:-1]:
+            target = getattr(target, part)
+
+        return target, parts[-1]
+
+    def set_attribute_value(self, obj, rule):
+        """
+        Generic method to set attribute value considering nested paths.
+        """
+        target, attribute = self.parse_attribute_path(obj, rule.attribute_key)
+        setattr(target, attribute, rule.attribute_dict['value'])
+        target.save()
+
+    #####
+
+    def handle_case_attribute_set_value(self, obj, rule):
+        """
+        Sets a specific attribute to a given value.
+        """
+        self.set_attribute_value(obj, rule.attribute_key, rule.attribute_dict["value"])
+
+    def handle_case_attribute_set_value_range_uniform(self, obj, rule):
+        """
+        Sets an attribute to a value within a specified range, selected uniformly.
+        """
+        if not hasattr(rule, 'attribute_dtype') or rule.attribute_dtype.name not in ['numeric', 'ordered_categorical']:
+            raise ValidationError("Attribute dtype must be numeric or ordered_categorical")
+        min_val = rule.attribute_dict["value_min"]
+        max_val = rule.attribute_dict["value_max"]
+        value = random.uniform(min_val, max_val)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+
+    def handle_case_attribute_set_value_range_norm_dist(self, obj, rule):
+        """
+        Sets an attribute to a value within a specified range, based on a normal distribution.
+        """
+        if rule.attribute_dtype.name in ['float', "integer"]:
+            raise ValidationError("Attribute dtype must be float or integer")
+        mean = rule.attribute_dict["value_mean"]
+        std_dev = rule.attribute_dict["value_sd"]
+        value = random.normalvariate(mean, std_dev)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+        
+
+    def handle_case_attribute_set_from_list_uniform(self, obj, rule):
+        """
+        Selects an attribute value uniformly from a list of choices.
+        """
+        choices = rule.attribute_dict["value_choices"]
+        value = random.choice(choices)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+
+    def handle_case_attribute_set_from_prop_tuple_list(self, obj, rule):
+        """
+        Selects an attribute value based on a list of value-probability tuples.
+        """
+        prop_list = rule.attribute_dict["value_prop_tuple_list"]
+        total = sum(prop for _, prop in prop_list)
+        pick = random.uniform(0, total)
+        current = 0
+        for value, prop in prop_list:
+            current += prop
+            if current > pick:
+                self.set_attribute_value(obj, rule.attribute_key, value)
+                break
+
+
+    #####
+
+    def handle_case_add_patient(self, obj, rule):
+        """Function to add a patient to a case. If the patient already exists, raise an error. Requires the following
+        rules in the rule_dict:
+        - gender_rule
+        - dob_rule
+        - event_rules
+        - disease_rules
+        """
+        from endoreg_db.models import Patient, PatientEvent, PatientDisease, Case
+
+        # Check if the 
+        obj:Case = obj
+        if obj.patient:
+            raise ValueError("Patient already exists in the case")
+        
+        patient = Patient()
+        self.apply_rule_by_name(patient, rule.attribute_dict["patient_gender_rule"])
+        self.apply_rule_by_name(patient, rule.attribute_dict["patient_dob_rule"])
+        self.apply_rules_by_name(patient, rule.attribute_dict["patient_event_rules"])
+        self.apply_rules_by_name(patient, rule.attribute_dict["patient_disease_rules"])
+
+    def handle_case_add_polyp(self, obj, rule):
+        """
+        Adds a polyp to the case, processing various polyp characteristics. Requires Rules for each attribute:
+        - polyp_location_organ_rule (single rule)
+        - polyp_location_organ_part_rule (single rule)
+        - polyp_morphology_classification_shape_choices_rule (list of rules)
+        - polyp_morphology_classification_chromo_choices_rule (list of rules)
+        - polyp_intervention_type_rule (single rule)
+        - polyp_intervention_instrument_rule (single rule)
+        - polyp_size_mm_rule (single rule)
+
+        """
+        # Example: create and add a polyp instance based on the rules
+        from endoreg_db.models import Polyp  # Ensure you have a Polyp model and adjust the import
+        from endoreg_db.models import Location
+        from endoreg_db.models import EndoscopicIntervention
+        from endoreg_db.models import PolypMorphology
+
+        assert obj.examination.type != None, "Examination type is required"
+
+        location = Location()
+        location.organ = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_rule"])
+        location.organ_part = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_part_rule"])
+        location.save()
+
+        morphology = PolypMorphology()
+        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
+        morphology.shape_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_shape_choices_rules"])
+        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
+        morphology.chromo_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_chromo_choices_rules"])
+        morphology.save()
+
+        intervention = EndoscopicIntervention()
+        intervention.type = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_type_rule"])
+        intervention.instrument = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_instrument_rule"])
+        intervention.save()
+
+        polyp = Polyp()
+        polyp.size_mm = self.apply_rule_by_name(polyp, rule.attribute_dict["polyp_size_mm_rule"])
+        polyp.location = location
+        polyp.morphology = morphology
+        polyp.intervention = intervention
+        
+        polyp.save()
+
+        obj.polyps.add(polyp)
+        obj.save()
+
+
+    # def handle_case_add_esophageal_varices(self, obj, rule):
+    #     """
+    #     Handles adding esophageal varices to a case based on the rule.
+    #     """
+    #     # Similar to the polyp case, create and add esophageal varices based on the attributes
+    #     from endoreg_db.models import EsophagealVarices  # Ensure this model exists
+    #     varices = EsophagealVarices()
+    #     varices.origin = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_origin_rule"])
+    #     varices.classification = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_classification_rule"])
+    #     varices.location_extent = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_location_extent_rule"])
+    #     varices.save()
+    #     # Assuming a relationship setup
+    #     obj.esophageal_varices.add(varices)
+    #     obj.save()
+
+
+    
+    
+        

endoreg_db/models/rules/rule_attribute_dtype.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+
+class RuleAttributeDtypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class RuleAttributeDType(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)
+
+    objects = RuleAttributeDtypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/rules/rule_type.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class RuleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class RuleType(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)
+
+    objects = RuleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        verbose_name = 'Rule Type'
+        verbose_name_plural = 'Rule Types'

endoreg_db/models/rules/ruleset.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+class RulesetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Ruleset(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)
+    rules = models.ManyToManyField('Rule')
+
+    objects = RulesetManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/unit.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class UnitManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Unit(models.Model):
+    objects = UnitManager()
+
+    name = models.CharField(max_length=100) # e.g. "Centimeter"
+    name_de = models.CharField(max_length=100, blank=True, null=True) # e.g. "Zentimeter"
+    name_en = models.CharField(max_length=100, blank=True, null=True) # e.g. "Centimeter"
+    description = models.CharField(max_length=100, blank=True, null=True) # e.g. "centimeters", "milimeters", "inches"
+    abbreviation = models.CharField(max_length=25, blank=True, null=True) # e.g. "cm", "mm", "in"
+    
+    def __str__(self):
+        if self.abbreviation:
+            return self.abbreviation
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)

endoreg_db/queries/__init__.py

@@ -0,0 +1,5 @@
+from .annotations import (
+    generate_legacy_dataset_output
+)
+
+from .get import *

endoreg_db/queries/annotations/__init__.py

@@ -0,0 +1,3 @@
+from .legacy import (
+    get_legacy_annotations_for_labelset, generate_legacy_dataset_output
+)