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

endoreg_db/data/agl_service/data.yaml

@@ -1,19 +0,0 @@
-- model: endoreg_db.agl_service
-  fields:
-    name: "agl-home-django"
-    description: "AGL Home Django service"
-    devices: [
-      "agl-server-04",
-    ]
-    port: 9100
-    url: "https://home.endo-reg.net/"
-
-- model: endoreg_db.agl_service
-  fields:
-    name: "endoreg-client-manager"
-    description: "AGL Home Django service"
-    devices: [
-      "agl-gpu-client-dev",
-    ]
-    port: 9000
-    url: "https://home.endo-reg.net/"

endoreg_db/data/finding_location_classification/colonoscopy.yaml

@@ -1,46 +0,0 @@
-- model: endoreg_db.finding_location_classification
-  fields:
-    name: "colonoscopy_default"
-    name_de: "Koloskopie Standard"
-    name_en: "Colonoscopy Default"
-    examinations: [
-      "colonoscopy"
-    ]
-    finding_types: [
-      "macroscopic"
-    ]
-    findings: [
-      "tumor",
-      "erosion",
-      "ulcer",
-      "scar"
-    ]
-    choices: [
-      "terminal_ileum",
-      "cecum",
-      "ascending_colon",
-      "right_flexure",
-      "transverse_colon",
-      "descending_colon",
-      "sigmoid_colon",
-      "rectum",
-      "anal_canal"
-    ]
-
-- model: endoreg_db.finding_location_classification_choice
-  fields:
-    name: "colonoscopy_coarse"
-    name_de: "Koloskopie Grob"
-    name_en: "Colonoscopy Coarse"
-    examinations: [
-      "colonoscopy"
-    ]
-    finding_types: [
-      "macroscopic"
-    ]
-    findings: []
-    choices: [
-      "left_colon",
-      "right_colon",
-      "rectum"
-    ]

endoreg_db/data/finding_morphology_classification/colonoscopy.yaml

@@ -1,48 +0,0 @@
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_size_categorical"
-    classification_type: "colon_lesion_size"
-    name_de: "Größenklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Size Classification (categorical)"
-    
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_size_mm"
-    classification_type: "colon_lesion_size"
-    name_de: "Größenklassifikation Kolonläsion (numerisch)"
-    name_en: "Colon Lesion Size Classification (numerical)"
-
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_surface_intact_default"
-    classification_type: "colon_lesion_surface_intact"
-    name_de: "Oberflächenklassifikation Kolonläsion"
-    name_en: "Colon Lesion Surface Classification"
-
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_planarity_default"
-    classification_type: "colon_lesion_planarity"
-    name_de: "Planaritätsklassifikation Kolonläsion"
-    name_en: "Colon Lesion Planarity Classification"
-
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_circularity_default"
-    name_de: "Kolonläsion - Zirkularität"
-    name_en: "Colon lesion - circularity"
-    classification_type: "colon_lesion_circularity"    
-
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_nice"
-    classification_type: "colon_lesion_advanced_imaging"
-    name_de: "Kolonläsion - NICE"
-    name_en: "Colon lesion - NICE"
-
-- model: endoreg_db.finding_morphology_classification
-  fields:
-    name: "colon_lesion_paris"
-    classification_type: "colon_lesion_shape"
-    name_de: "Formklassifikation Kolonläsion"
-    name_en: "Colon Lesion Shape Classification"

endoreg_db/data/finding_morphology_classification_choice/colonoscopy_size.yaml

@@ -1,57 +0,0 @@
-- model: endoreg_db.finding_morphology_classification_choice
-  fields:
-    name: "colon_lesion_size_categorical_diminutive"
-    name_de: "Größenklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Size Classification (categorical)"
-    classification: "colon_lesion_size_categorical"
-    description: "Diminutive (< 6 mm)"
-
-- model: endoreg_db.finding_morphology_classification_choice
-  fields:
-    name: "colon_lesion_size_categorical_small"
-    name_de: "Größenklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Size Classification (categorical)"
-    classification: "colon_lesion_size_categorical"
-    description: "Small (6 - 9 mm)"
-
-- model: endoreg_db.finding_morphology_classification_choice
-  fields:
-    name: "colon_lesion_size_categorical_medium"
-    name_de: "Größenklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Size Classification (categorical)"
-    classification: "colon_lesion_size_categorical"
-    description: "Medium (10 - 19 mm)"
-
-- model: endoreg_db.finding_morphology_classification_choice
-  fields:
-    name: "colon_lesion_size_categorical_large"
-    name_de: "Größenklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Size Classification (categorical)"
-    classification: "colon_lesion_size_categorical"
-    description: "Large (> 19 mm)"
-
-##########
-
-- model: endoreg_db.finding_morphology_classification_choice
-  fields:
-    name: "colon_lesion_size_oval_mm"
-    name_de: "Formklassifikation Kolonläsion (kategorisch)"
-    name_en: "Colon Lesion Shape Classification (categorical)"
-    classification: "colon_lesion_size_mm"
-    description: "oval lesions"
-    numerical_descriptors:
-      largest_diameter_mm:
-        unit: "mm"
-        min: 0
-        max: 35
-        distribution: "normal"
-        mean: 5
-        std: 3
-        description: "Largest diameter of the lesion in mm"
-        required: true
-      perpendicular_diameter_mm:
-        unit: "mm"
-        min: 0
-        max: 35
-        description: "Perpendicular diameter of the lesion in mm"
-        required: false

endoreg_db/management/commands/_load_model_template.py

@@ -1,41 +0,0 @@
-from django.conf import settings
-from django.core.management.base import BaseCommand
-from reports.models import Intervention, InterventionType  # Replace 'your_app_name' with the actual app name
-import os
-from reports.dataloader_utils import load_model_data
-
-SOURCE_DIR = None # e.g. settings.DATA_DIR_INTERVENTION
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-]
-
-IMPORT_METADATA = {
-    # "": { # same as model name in "import models", e.g. "Intervention"
-    #     "dir": os.path.join(SOURCE_DIR,""), # e.g. "interventions"
-    #     "model": None, # e.g. Intervention
-    #     "foreign_keys": [], # e.g. ["intervention_types"]
-    #     "foreign_key_models": [] # e.g. [InterventionType]
-    # },
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/delete_all.py

@@ -1,18 +0,0 @@
-from django.core.management.base import BaseCommand
-from django.apps import apps
-from django.db import transaction
-
-class Command(BaseCommand):
-    help = 'Deletes all objects from all models in the "endoreg_db" app.'
-
-    def handle(self, *args, **options):
-        app_models = apps.get_models()
-        app_models = [model for model in app_models if "endoreg_db" in model._meta.app_label]  # Filter models by the "endoreg_db" app
-        for model in app_models:
-            with transaction.atomic():  # Use a separate transaction for each model
-                try:
-                    model.objects.all().delete()
-                    self.stdout.write(self.style.SUCCESS(f'Successfully deleted all objects in {model._meta.db_table}'))
-                except Exception as e:
-                    # This catches exceptions and continues with the next model
-                    self.stdout.write(self.style.ERROR(f'Error deleting objects in {model._meta.db_table}: {e}'))

endoreg_db/management/commands/fetch_legacy_image_dataset.py

@@ -1,32 +0,0 @@
-# command to fetch the legacy dataset and save it to a json file.
-from django.core.management.base import BaseCommand, CommandError
-from endoreg_db.queries import generate_legacy_dataset_output 
-import json
-
-LABELSET_NAME = "multilabel_classification"
-LABELSET_VERSION = 0
-
-class Command(BaseCommand):
-    help = 'Fetches the legacy dataset and saves it to a jsonl file'
-
-    def handle(self, *args, **options):
-        output, labelset = generate_legacy_dataset_output(LABELSET_NAME, LABELSET_VERSION)
-        # output is a list of dicts, each dict is an image
-        labels_in_order = labelset.get_labels_in_order()
-
-        # write to file
-        with open('legacy_dataset.jsonl', 'w') as f:
-            for img_dict in output:
-                f.write(json.dumps(img_dict) + '\n')
-
-
-        _dict = {
-            "labels": [label.name for label in labels_in_order],
-            "name": LABELSET_NAME,
-            "version": LABELSET_VERSION
-        }
-
-        with open('legacy_dataset_info.json', 'w') as f:
-            f.write(json.dumps(_dict))
-
-        self.stdout.write(self.style.SUCCESS('Successfully fetched and saved the legacy dataset'))

endoreg_db/management/commands/fix_auth_permission.py

@@ -1,20 +0,0 @@
-from django.core.management.base import BaseCommand
-from django.contrib.auth.models import Permission
-from django.contrib.contenttypes.models import ContentType
-from django.apps import apps
-
-class Command(BaseCommand):
-    help = 'Sets up default permissions for each model in the app.'
-
-    def handle(self, *args, **options):
-        for model in apps.get_models():
-            content_type = ContentType.objects.get_for_model(model)
-            permissions = ['view', 'add', 'change', 'delete']
-            for perm in permissions:
-                codename = f'{perm}_{model._meta.model_name}'
-                name = f'Can {perm} {model._meta.verbose_name}'
-                Permission.objects.get_or_create(
-                    codename=codename,
-                    defaults={'name': name, 'content_type': content_type},
-                )
-            self.stdout.write(self.style.SUCCESS(f'Set up permissions for {model._meta.verbose_name}'))

endoreg_db/management/commands/load_active_model_data.py

@@ -1,45 +0,0 @@
-from django.conf import settings
-import os
-from django.core.management.base import BaseCommand
-from ...models import ActiveModel
-from ...utils import load_model_data_from_yaml
-from ...data import ACTIVE_MODEL_DATA_DIR
-
-SOURCE_DIR = ACTIVE_MODEL_DATA_DIR # e.g. settings.DATA_DIR_INTERVENTION
-
-MODEL_0 = ActiveModel
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_0.__name__,
-]
-
-IMPORT_METADATA = {
-    MODEL_0.__name__: {
-        "dir": SOURCE_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
-        "foreign_keys": [], # e.g. ["intervention_types"]
-        "foreign_key_models": [] # e.g. [InterventionType]
-    }
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/load_g_play_data.py

@@ -1,113 +0,0 @@
-from django.core.management.base import BaseCommand
-from endoreg_db.models import (
-    CaseTemplateRuleType,
-    CaseTemplateRuleValueType,
-    CaseTemplateRuleValue,
-    CaseTemplateRule,
-    CaseTemplateType,
-    CaseTemplate,
-    SingleCategoricalValueDistribution,
-    NumericValueDistribution,
-    MultipleCategoricalValueDistribution,
-    DateValueDistribution,
-
-    QuizQuestionType,
-    QuizAnswerType,
-    QuizQuestion,
-    QuizAnswer,
-
-    # Other models for ForeignKeys
-    Unit, Center
-)
-from collections import OrderedDict
-
-from ...utils import load_model_data_from_yaml
-from ...data import (
-    CASE_TEMPLATE_RULE_TYPE_DATA_DIR,
-    CASE_TEMPLATE_RULE_DATA_DIR,
-    CASE_TEMPLATE_RULE_VALUE_TYPE_DATA_DIR,
-    CASE_TEMPLATE_RULE_VALUE_DATA_DIR,
-    CASE_TEMPLATE_TYPE_DATA_DIR,
-    CASE_TEMPLATE_DATA_DIR,
-)
-
-IMPORT_METADATA = OrderedDict({
-    CaseTemplateRuleType.__name__: {
-        "dir": CASE_TEMPLATE_RULE_TYPE_DATA_DIR,
-        "model": CaseTemplateRuleType, 
-        "foreign_keys": [], 
-        "foreign_key_models": [] 
-    },
-    CaseTemplateRuleValueType.__name__: {
-        "dir": CASE_TEMPLATE_RULE_VALUE_TYPE_DATA_DIR,
-        "model": CaseTemplateRuleValueType, 
-        "foreign_keys": [], 
-        "foreign_key_models": [] 
-    },
-    CaseTemplateRuleValue.__name__: {
-        "dir": CASE_TEMPLATE_RULE_VALUE_DATA_DIR,
-        "model": CaseTemplateRuleValue, 
-        "foreign_keys": ["value_type"], 
-        "foreign_key_models": [CaseTemplateRuleValueType] 
-    },
-    CaseTemplateRule.__name__: {
-        "dir": CASE_TEMPLATE_RULE_DATA_DIR,
-        "model": CaseTemplateRule, 
-        "foreign_keys": [
-            "rule_type", 
-            # "rule_values",
-            "chained_rules", 
-            "value_type",
-            "single_categorical_value_distribution",
-            "numerical_value_distribution",
-            "multiple_categorical_value_distribution",
-            "date_value_distribution"
-        ], 
-        "foreign_key_models": [
-            CaseTemplateRuleType,
-            # CaseTemplateRuleValue,
-            CaseTemplateRule,
-            CaseTemplateRuleValueType,
-            SingleCategoricalValueDistribution,
-            NumericValueDistribution,
-            MultipleCategoricalValueDistribution,
-            DateValueDistribution
-
-        ] 
-    },
-    CaseTemplateType.__name__: {
-        "dir": CASE_TEMPLATE_TYPE_DATA_DIR,
-        "model": CaseTemplateType, 
-        "foreign_keys": [], 
-        "foreign_key_models": [] 
-    },
-    CaseTemplate.__name__: {
-        "dir": CASE_TEMPLATE_DATA_DIR,
-        "model": CaseTemplate, 
-        "foreign_keys": ["template_type", "rules"], 
-        "foreign_key_models": [CaseTemplateType, CaseTemplateRule] 
-    },
-    
-})
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_METADATA.keys():
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/load_logging_data.py

@@ -1,39 +0,0 @@
-from django.core.management.base import BaseCommand
-from endoreg_db.models import LogType as MODEL_0
-from ...utils import load_model_data_from_yaml
-from ...data import LOG_TYPE_DATA_DIR as SOURCE_DIR
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_0.__name__,
-]
-
-IMPORT_METADATA = {
-    MODEL_0.__name__: {
-        "dir": SOURCE_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
-        "foreign_keys": [], # e.g. ["intervention_types"]
-        "foreign_key_models": [] # e.g. [InterventionType]
-    }
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/load_lx_data.py

@@ -1,64 +0,0 @@
-# Management command to load LuxNix Model Data
-
-from django.core.management.base import BaseCommand
-
-from endoreg_db.models import (
-    LxClientType, LxClientTag, LxPermission
-)
-
-from ...utils import load_model_data_from_yaml
-
-from ...data import (
-    LX_CLIENT_TYPE_DATA_DIR,
-    LX_CLIENT_TAG_DATA_DIR,
-    LX_PERMISSION_DATA_DIR
-)
-
-IMPORT_MODELS = [
-    LxPermission.__name__,
-    LxClientType.__name__,
-    LxClientTag.__name__, # M2M relationship with LxPermission ("permissions")
-]
-
-IMPORT_METADATA = {
-    LxPermission.__name__: {
-        "dir": LX_PERMISSION_DATA_DIR,
-        "model": LxPermission,
-        "foreign_keys": [],
-        "foreign_key_models": []
-    },
-    LxClientType.__name__: {
-        "dir": LX_CLIENT_TYPE_DATA_DIR,
-        "model": LxClientType,
-        "foreign_keys": [],
-        "foreign_key_models": []
-    },
-    LxClientTag.__name__: {
-        "dir": LX_CLIENT_TAG_DATA_DIR,
-        "model": LxClientTag,
-        "foreign_keys": ["permissions"],
-        "foreign_key_models": [LxPermission]
-    },
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/load_medication_indication_data.py

@@ -1,63 +0,0 @@
-from django.core.management.base import BaseCommand
-from endoreg_db.models import (
-    MedicationIndication,
-    MedicationIndicationType,
-    MedicationSchedule,
-    Disease,
-    Event,
-    DiseaseClassificationChoice,
-    InformationSource
-)
-from ...utils import load_model_data_from_yaml
-from ...data import MEDICATION_INDICATION_DATA_DIR as SOURCE_DIR
-
-MODEL_0 = MedicationIndication
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_0.__name__,
-]
-
-IMPORT_METADATA = {
-    MODEL_0.__name__: {
-        "dir": SOURCE_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
-        "foreign_keys": [
-            "indication_type",
-            "medication_schedules",
-            "diseases",
-            "events",
-            "classification_choices",
-            "sources"
-        ], # e.g. ["intervention_types"]
-        "foreign_key_models": [
-            MedicationIndicationType,
-            MedicationSchedule,
-            Disease,
-            Event,
-            DiseaseClassificationChoice,
-            InformationSource
-        ] # e.g. [InterventionType]
-    }
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )

endoreg_db/management/commands/load_medication_indication_type_data.py

@@ -1,41 +0,0 @@
-from django.core.management.base import BaseCommand
-from endoreg_db.models import MedicationIndicationType
-from ...utils import load_model_data_from_yaml
-from ...data import MEDICATION_INDICATION_TYPE_DATA_DIR as SOURCE_DIR
-
-MODEL_0 = MedicationIndicationType
-
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_0.__name__,
-]
-
-IMPORT_METADATA = {
-    MODEL_0.__name__: {
-        "dir": SOURCE_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
-        "foreign_keys": [], # e.g. ["intervention_types"]
-        "foreign_key_models": [] # e.g. [InterventionType]
-    }
-}
-
-class Command(BaseCommand):
-    help = """Load all .yaml files in the data/intervention directory
-    into the Intervention and InterventionType model"""
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
-        )
-
-    def handle(self, *args, **options):
-        verbose = options['verbose']
-        for model_name in IMPORT_MODELS:
-            _metadata = IMPORT_METADATA[model_name]
-            load_model_data_from_yaml(
-                self,
-                model_name,
-                _metadata,
-                verbose
-            )