endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/management/commands/load_organ_data.py

@@ -0,0 +1,39 @@
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import Organ
+
+from ...data import ORGAN_DATA_DIR
+from ...utils import load_model_data_from_yaml
+
+MODEL_0 = Organ
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    MODEL_0.__name__,  #
+]
+
+IMPORT_METADATA = {
+    MODEL_0.__name__: {
+        "dir": ORGAN_DATA_DIR,  # e.g. "interventions"
+        "model": MODEL_0,
+        "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_pdf_type_data.py

@@ -0,0 +1,58 @@
+from django.core.management.base import BaseCommand
+
+from ...data import REPORT_TYPE_DATA_DIR
+
+#### CUSTOMIZE
+from ...models import PdfType, ReportReaderFlag
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = REPORT_TYPE_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
+
+MODEL_0 = PdfType
+
+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
+        "dir": SOURCE_DIR,  # e.g. "interventions"
+        "model": MODEL_0,
+        "foreign_keys": [
+            "patient_info_line",
+            "endoscope_info_line",
+            "examiner_info_line",
+            "cut_off_below_lines",
+            "cut_off_above_lines",
+        ],  # e.g. ["intervention_types"]
+        "foreign_key_models": [
+            ReportReaderFlag,
+            ReportReaderFlag,
+            ReportReaderFlag,
+            ReportReaderFlag,
+            ReportReaderFlag,
+        ],  # e.g. [InterventionType]
+    }
+}
+
+
+class Command(BaseCommand):
+    help = f"""Load all .yaml files in the {SOURCE_DIR} directory"""
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        verbose = options["verbose"]
+        verbose = options["verbose"]
+        for model_name in IMPORT_MODELS:
+            _metadata = IMPORT_METADATA[model_name]
+            load_model_data_from_yaml(self, model_name, _metadata, verbose)
+
+            load_model_data_from_yaml(self, model_name, _metadata, verbose)

endoreg_db/management/commands/load_profession_data.py

@@ -0,0 +1,40 @@
+from django.core.management.base import BaseCommand
+
+from ...data import PROFESSION_DATA_DIR
+from ...models import Profession
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = PROFESSION_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
+
+MODEL_0 = Profession
+
+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,
+        "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_qualification_data.py

@@ -0,0 +1,56 @@
+from django.core.management.base import BaseCommand
+
+from ...data import QUALIFICATION_DATA_DIR
+from ...models import Qualification, QualificationType
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = QUALIFICATION_DATA_DIR  # qualification data directory
+
+model_0 = QualificationType
+model_1 = Qualification
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    model_0.__name__,
+    model_1.__name__,
+]
+
+IMPORT_METADATA = {
+    model_0.__name__: {
+        "dir": SOURCE_DIR,  # e.g. "interventions"
+        "model": model_0,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    model_1.__name__: {
+        "dir": SOURCE_DIR,  # e.g. "interventions"
+        "model": model_1,
+        "foreign_keys": ["qualification_types"],  # e.g. ["intervention_types"]
+        "foreign_key_models": [model_0],  # e.g. [InterventionType]
+    },
+}
+
+
+class Command(BaseCommand):
+    help = """Load all .yaml files in the data/qualification directory
+    into the Qualification / Qualification Type model"""
+
+    def add_arguments(self, parser):
+        """
+        Adds the --verbose flag to the command-line parser to enable detailed output.
+        """
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Loads data from YAML files into the QualificationType and Qualification models.
+
+        Iterates over predefined models and imports their data from YAML files using associated metadata. Supports verbose output if enabled via command-line 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_report_reader_flag_data.py

@@ -0,0 +1,40 @@
+from django.core.management.base import BaseCommand
+
+from ...data import REPORT_READER_FLAG_DATA_DIR
+from ...models import ReportReaderFlag
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = REPORT_READER_FLAG_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
+
+MODEL_0 = ReportReaderFlag
+
+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,
+        "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_requirement_data.py

@@ -0,0 +1,207 @@
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import (
+    Disease,
+    DiseaseClassificationChoice,
+    Event,
+    Examination,
+    ExaminationIndication,
+    ExaminationRequirementSet,  # Added to avoid circular import issues
+    Finding,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingIntervention,
+    InformationSource,
+    LabValue,
+    Medication,  # Added Medication model
+    MedicationIndication,
+    MedicationIndicationType,
+    MedicationIntakeTime,
+    MedicationSchedule,
+    Requirement,
+    RequirementOperator,
+    RequirementSet,
+    RequirementSetType,
+    RequirementType,
+    Risk,
+    RiskType,
+    Tag,
+    Unit,
+)
+from endoreg_db.models.other.gender import Gender
+
+from ...data import (
+    EXAMINATION_REQUIREMENT_SET_DATA_DIR,
+    REQUIREMENT_DATA_DIR,
+    REQUIREMENT_OPERATOR_DATA_DIR,
+    REQUIREMENT_SET_DATA_DIR,
+    REQUIREMENT_SET_TYPE_DATA_DIR,
+    REQUIREMENT_TYPE_DATA_DIR,
+)
+from ...utils import load_model_data_from_yaml
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    RequirementType.__name__,
+    RequirementOperator.__name__,
+    Requirement.__name__,
+    RequirementSetType.__name__,
+    # ExaminationRequirementSet.__name__,
+    RequirementSet.__name__,
+]
+
+
+def _validate_requirement_configuration(fields: dict, *, entry: dict, model):
+    """Ensures requirement fixtures declare both requirement_types and operators."""
+    name = fields.get("name") or entry.get("pk") or "<unnamed>"
+
+    def _values_missing(key: str) -> bool:
+        value = fields.get(key)
+        if not isinstance(value, list):
+            return True
+        if not value:
+            return True
+        return any(not item for item in value)
+
+    missing = [
+        key for key in ("requirement_types", "operators") if _values_missing(key)
+    ]
+    if missing:
+        missing_display = ", ".join(missing)
+        raise ValueError(
+            f"{model.__name__} '{name}' is missing required configuration for: {missing_display}."
+        )
+
+
+IMPORT_METADATA = {
+    RequirementType.__name__: {
+        "dir": REQUIREMENT_TYPE_DATA_DIR,  # e.g. "interventions"
+        "model": RequirementType,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    RequirementOperator.__name__: {
+        "dir": REQUIREMENT_OPERATOR_DATA_DIR,  # e.g. "interventions"
+        "model": RequirementOperator,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    ExaminationRequirementSet.__name__: {
+        "dir": EXAMINATION_REQUIREMENT_SET_DATA_DIR,  # e.g. "interventions"
+        "model": ExaminationRequirementSet,
+        "foreign_keys": [],  # Through model uses foreign keys of both models
+        "foreign_key_models": [],
+    },
+    # ExaminationRequirementSet.__name__,
+    Requirement.__name__: {
+        "dir": REQUIREMENT_DATA_DIR,  # e.g. "interventions"
+        "model": Requirement,
+        "foreign_keys": [
+            "requirement_types",
+            "operator",
+            "unit",
+            "examinations",
+            "examination_indications",
+            "diseases",
+            "disease_classification_choices",
+            "events",
+            "lab_values",
+            "findings",
+            "finding_classifications",
+            "finding_classification_choices",  # updated from finding_morphology_classification_choices
+            "finding_interventions",
+            "risks",
+            "risk_types",
+            "medication_indications",
+            "medication_indication_types",
+            "medication_schedules",
+            "medications",  # Added medications
+            "medication_intake_times",
+            "genders",
+        ],
+        "foreign_key_models": [
+            RequirementType,
+            RequirementOperator,
+            Unit,
+            Examination,
+            ExaminationIndication,
+            Disease,
+            DiseaseClassificationChoice,
+            Event,
+            LabValue,
+            Finding,
+            FindingClassification,
+            FindingClassificationChoice,
+            FindingIntervention,
+            Risk,
+            RiskType,
+            MedicationIndication,
+            MedicationIndicationType,
+            MedicationSchedule,
+            Medication,  # Added Medication model
+            MedicationIntakeTime,
+            Gender,
+        ],
+        # "validators": [_validate_requirement_configuration],
+    },
+    RequirementSetType.__name__: {
+        "dir": REQUIREMENT_SET_TYPE_DATA_DIR,  # e.g. "interventions"
+        "model": RequirementSetType,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    RequirementSet.__name__: {
+        "dir": REQUIREMENT_SET_DATA_DIR,  # e.g. "interventions"
+        "model": RequirementSet,
+        "foreign_keys": [
+            "requirement_set_type",
+            "requirements",  # This is a many-to-many field
+            "links_to_sets",
+            "information_sources",
+            "tags",
+            "reqset_exam_links",
+            "depends_on",
+        ],  # e.g. ["intervention_types"]
+        "foreign_key_models": [
+            RequirementSetType,
+            Requirement,
+            RequirementSet,
+            InformationSource,
+            Tag,
+            ExaminationRequirementSet,
+            RequirementSet,
+        ],  # e.g. [InterventionType]
+    },
+}
+
+
+class Command(BaseCommand):
+    help = """Load all requirement-related YAML files from their respective directories
+    into the database, including RequirementType, RequirementOperator, Requirement, 
+    RequirementSetType, and RequirementSet models"""
+
+    def add_arguments(self, parser):
+        """
+        Add command-line arguments to enable verbose output.
+
+        Adds an optional '--verbose' flag to the command parser. When specified,
+        this flag causes the command to display detailed output during execution.
+        """
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Executes data import for requirement models from YAML files.
+
+        Retrieves the verbosity setting from the command options and iterates over each model
+        listed in IMPORT_MODELS. For each model, it obtains the corresponding metadata from
+        IMPORT_METADATA and calls a helper to load the YAML data into the database. Verbose mode
+        enables detailed output during the process.
+        """
+        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_requirement_set_tags.py

@@ -0,0 +1,95 @@
+"""
+Management command to load default requirement set tags for role-based filtering.
+
+⚠️ DEPRECATED: This command is deprecated. Please use 'load_tag_data' instead.
+
+The new method loads tags from YAML configuration files, making it easier to
+add, modify, or remove tags without changing Python code.
+
+New Usage:
+    uv run python manage.py load_tag_data --verbose
+
+Tags are now managed in: endoreg_db/data/tag/requirement_set_tags.yaml
+
+This command is kept for backward compatibility but may be removed in future versions.
+"""
+
+import logging
+
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import Tag
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    ⚠️ DEPRECATED: Load default requirement set tags for role-based filtering.
+
+    Please use 'load_tag_data' instead:
+        uv run python manage.py load_tag_data --verbose
+
+    This command creates or verifies the existence of default tags used
+    for filtering requirement sets by user role/expertise level.
+    """
+
+    help = "Load default requirement set tags for role-based filtering"
+
+    def handle(self, *args, **options):
+        """
+        Create or verify default tags for requirement set filtering.
+
+        Tags created:
+            - Gastroenterologist: For specialist-level requirements
+            - Student: For educational/basic requirements
+            - Professor: For academic/research requirements
+            - Terminology Expert: For terminology standardization
+            - Default Prototype: For baseline/reference requirements
+        """
+        default_tags = [
+            ("Gastroenterologist", "Specialist-level endoscopy requirements"),
+            ("Student", "Educational and basic learning requirements"),
+            ("Professor", "Academic and research-focused requirements"),
+            ("Terminology Expert", "Terminology standardization requirements"),
+            ("Default Prototype", "Baseline reference requirements"),
+        ]
+
+        created_count = 0
+        updated_count = 0
+
+        for tag_name, description in default_tags:
+            tag, created = Tag.objects.get_or_create(
+                name=tag_name,
+                defaults={"description": description}
+                if hasattr(Tag, "description")
+                else {},
+            )
+
+            if created:
+                created_count += 1
+                self.stdout.write(self.style.SUCCESS(f"✓ Created tag: {tag_name}"))
+                logger.info(f"Created requirement set tag: {tag_name}")
+            else:
+                updated_count += 1
+                self.stdout.write(f"  Tag already exists: {tag_name}")
+
+        # Summary
+        total_tags = len(default_tags)
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\n{'=' * 60}\n"
+                f"Tag Loading Complete\n"
+                f"{'=' * 60}\n"
+                f"  New tags created:     {created_count}\n"
+                f"  Existing tags found:  {updated_count}\n"
+                f"  Total tags verified:  {total_tags}\n"
+                f"{'=' * 60}"
+            )
+        )
+
+        logger.info(
+            f"Requirement set tag loading complete: "
+            f"{created_count} created, {updated_count} existing, "
+            f"{total_tags} total"
+        )

endoreg_db/management/commands/load_risk_data.py

@@ -0,0 +1,57 @@
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models import Risk, RiskType
+
+from ...data import RISK_DATA_DIR, RISK_TYPE_DATA_DIR
+from ...utils import load_model_data_from_yaml
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    RiskType.__name__,
+    Risk.__name__,
+]
+
+IMPORT_METADATA = {
+    RiskType.__name__: {
+        "dir": RISK_TYPE_DATA_DIR,  # e.g. "interventions"
+        "model": RiskType,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    Risk.__name__: {
+        "dir": RISK_DATA_DIR,  # e.g. "interventions"
+        "model": Risk,
+        "foreign_keys": ["risk_type"],  # e.g. ["intervention_types"]
+        "foreign_key_models": [RiskType],  # 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):
+        """
+        Adds the '--verbose' flag to the argument parser for detailed output.
+
+        This method extends the given parser by adding an option that, when specified,
+        enables verbose output during command execution.
+        """
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Execute the command to load YAML data into configured models.
+
+        Retrieves the verbosity setting from the options and iterates over each model in IMPORT_MODELS.
+        For each model, it obtains the corresponding metadata from IMPORT_METADATA and calls the utility
+        function load_model_data_from_yaml to load data from the associated YAML files.
+        """
+        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_shift_data.py

@@ -0,0 +1,57 @@
+from django.core.management.base import BaseCommand
+
+from ...data import REPORT_READER_FLAG_DATA_DIR
+from ...models import Shift, ShiftType
+from ...utils import load_model_data_from_yaml
+
+SOURCE_DIR = REPORT_READER_FLAG_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
+
+model_0 = ShiftType
+model_1 = Shift
+
+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,
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # e.g. [InterventionType]
+    },
+    model_1.__name__: {
+        "dir": SOURCE_DIR,  # e.g. "interventions"
+        "model": model_1,
+        "foreign_keys": ["shift_types"],  # e.g. ["intervention_types"]
+        "foreign_key_models": [model_0],  # e.g. [InterventionType]
+    },
+}
+
+
+class Command(BaseCommand):
+    help = """Load all .yaml files in the data/shift directory
+    into the Shift and ShiftType model"""
+
+    def add_arguments(self, parser):
+        """
+        Adds the --verbose command-line option to enable detailed output during execution.
+        """
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Display verbose output",
+        )
+
+    def handle(self, *args, **options):
+        """
+        Loads YAML data files into models defined in IMPORT_MODELS using provided metadata.
+
+        Iterates over each model specified in IMPORT_MODELS, retrieves its import metadata,
+        and calls the data loading utility to populate the database from YAML files. Supports
+        optional verbose output if enabled via command-line 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)