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

endoreg_db/management/commands/load_finding_data.py

@@ -1,63 +1,45 @@
 from django.core.management.base import BaseCommand
 from endoreg_db.models import (
     Finding, FindingType, Examination,
-    FindingLocationClassification, FindingLocationClassificationChoice,
+    FindingClassification, FindingClassificationType, FindingClassificationChoice,
     Organ,
-    FindingMorphologyClassificationType, FindingMorphologyClassification,
-    FindingMorphologyClassificationChoice,
     FindingIntervention, FindingInterventionType, LabValue, Contraindication
 
 )
 from ...utils import load_model_data_from_yaml
 from ...data import (
     FINDING_DATA_DIR, FINDING_TYPE_DATA_DIR,
-    FINDING_LOCATION_CLASSIFICATION_DATA_DIR, 
-    FINDING_LOCATION_CLASSIFICATION_CHOICE_DATA_DIR,
-    FINDING_MORPHOLOGY_CLASSIFICATION_CHOICE_DATA_DIR, 
-    FINDING_MORPHOLOGY_CLASSIFICATION_DATA_DIR,
-    FINDING_MORPGOLOGY_CLASSIFICATION_TYPE_DATA_DIR,
     FINDING_INTERVETION_DATA_DIR,
-    FINIDNG_INTERVENTION_TYPE_DATA_DIR
+    FINIDNG_INTERVENTION_TYPE_DATA_DIR,
+    FINDING_CLASSIFICATION_TYPE_DATA_DIR,
+    FINDING_CLASSIFICATION_DATA_DIR,
+    FINDING_CLASSIFICATION_CHOICE_DATA_DIR
 )
 
-MODEL_0 = FindingType
-MODEL_1 = Finding
-MODEL_2 = FindingLocationClassificationChoice
-MODEL_3 = FindingLocationClassification
-MODEL_4 = FindingMorphologyClassificationType
-MODEL_5 = FindingMorphologyClassification
-MODEL_6 = FindingMorphologyClassificationChoice
-MODEL_7 = FindingInterventionType
-MODEL_8 = FindingIntervention
-
 IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_7.__name__,
-    MODEL_8.__name__,
-    MODEL_0.__name__,
-    MODEL_1.__name__,
-    MODEL_2.__name__,
-    MODEL_3.__name__,
-    MODEL_4.__name__,
-    MODEL_5.__name__,
-    MODEL_6.__name__,
+    FindingInterventionType.__name__,
+    FindingIntervention.__name__,
+    FindingType.__name__,
+    Finding.__name__,
+    FindingClassificationType.__name__,
+    FindingClassificationChoice.__name__,
+    FindingClassification.__name__,
 ]
 
 IMPORT_METADATA = {
-    MODEL_0.__name__: {
+    FindingType.__name__: {
         "dir": FINDING_TYPE_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
+        "model": FindingType, # e.g. Intervention
         "foreign_keys": [], # e.g. ["intervention_types"]
         "foreign_key_models": [] # e.g. [InterventionType]
     },
     Finding.__name__: {
         "dir": FINDING_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_1, # e.g. Intervention
+        "model": Finding, # e.g. Intervention
         "foreign_keys": [
             "finding_types",
             "examinations",
             "finding_interventions",
-            "causing_finding_interventions",
-            "opt_causing_finding_interventions",
         ], # e.g. ["intervention_types"]
         "foreign_key_models": [
             FindingType,
@@ -67,65 +49,6 @@ IMPORT_METADATA = {
             FindingIntervention,
         ] # e.g. [InterventionType]
     },
-    MODEL_2.__name__: {
-        "dir": FINDING_LOCATION_CLASSIFICATION_CHOICE_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_2, # e.g. Intervention
-        "foreign_keys": [
-            "organs"
-        ], # e.g. ["intervention_types"]
-        "foreign_key_models": [
-            Organ
-        ] # e.g. [InterventionType]
-    },
-    MODEL_3.__name__: {
-        "dir": FINDING_LOCATION_CLASSIFICATION_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_3, # e.g. Intervention
-        "foreign_keys": [
-            "examinations",
-            "finding_types",
-            "findings",
-            "choices"
-        ], # e.g. ["intervention_types"]
-        "foreign_key_models": [
-            Examination,
-            FindingType,
-            Finding,
-            FindingLocationClassificationChoice
-        ] # e.g. [InterventionType]
-    },
-    MODEL_4.__name__: {
-        "dir": FINDING_MORPGOLOGY_CLASSIFICATION_TYPE_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_4, # e.g. Intervention
-        "foreign_keys": [
-            "required_by_findings",
-            "optional_for_findings"
-        ], # e.g. ["intervention_types"]
-        "foreign_key_models": [
-            Finding,
-            Finding
-        ] # e.g. [InterventionType]
-    },
-
-    MODEL_5.__name__: {
-        "dir": FINDING_MORPHOLOGY_CLASSIFICATION_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_5, # e.g. Intervention
-        "foreign_keys": [
-            "classification_type",
-        ],
-        "foreign_key_models": [
-            FindingMorphologyClassificationType,
-        ] 
-    },
-    MODEL_6.__name__: {
-        "dir": FINDING_MORPHOLOGY_CLASSIFICATION_CHOICE_DATA_DIR, # e.g. "interventions"
-        "model": MODEL_6, # e.g. Intervention
-        "foreign_keys": [
-            "classification",
-        ],
-        "foreign_key_models": [
-            FindingMorphologyClassification,
-        ] 
-    },
     FindingInterventionType.__name__: {
         "dir": FINIDNG_INTERVENTION_TYPE_DATA_DIR, # e.g. "interventions"
         "model": FindingInterventionType, # e.g. Intervention
@@ -146,6 +69,40 @@ IMPORT_METADATA = {
             Contraindication
         ] # e.g. [InterventionType]
     },
+    FindingClassificationType.__name__: {
+        "dir": FINDING_CLASSIFICATION_TYPE_DATA_DIR, # e.g. "interventions"
+        "model": FindingClassificationType, # e.g. Intervention
+        "foreign_keys": [], # e.g. ["intervention_types"]
+        "foreign_key_models": [] # e.g. [InterventionType]
+    },
+    FindingClassification.__name__: {
+        "dir": FINDING_CLASSIFICATION_DATA_DIR, # e.g. "interventions"
+        "model": FindingClassification, # e.g. Intervention
+        "foreign_keys": [
+            "classification_types",
+            "findings",
+            "examinations",
+            "finding_types",
+            "choices"
+        ], # e.g. ["intervention_types"]
+        "foreign_key_models": [
+            FindingClassificationType,
+            Finding,
+            Examination,
+            FindingType,
+            FindingClassificationChoice,
+        ] # e.g. [InterventionType]
+    },
+    FindingClassificationChoice.__name__: {
+        "dir": FINDING_CLASSIFICATION_CHOICE_DATA_DIR, # e.g. "interventions"
+        "model": FindingClassificationChoice, # e.g. Intervention
+        "foreign_keys": [
+            # "classifications",
+        ], # e.g. ["intervention_types"]
+        "foreign_key_models": [
+            # FindingClassification
+        ] # e.g. [InterventionType]
+    },
 }
 
 class Command(BaseCommand):

endoreg_db/management/commands/load_green_endoscopy_wuerzburg_data.py

@@ -7,7 +7,6 @@ from endoreg_db.models import (
     Product,
     ProductGroup,
     ReferenceProduct,
-    ProductGroup,
     TransportRoute,
     CenterWaste,
     CenterResource,

endoreg_db/management/commands/load_information_source.py

@@ -1,24 +1,30 @@
 from django.conf import settings
 import os
 from django.core.management.base import BaseCommand
-from ...models import InformationSource
+from ...models import InformationSource, InformationSourceType
 from ...utils import load_model_data_from_yaml
-from ...data import INFORMATION_DATA_DIR
+from ...data import INFORMATION_DATA_DIR, INFORMATION_SOURCE_TYPE_DATA_DIR
 
 SOURCE_DIR = INFORMATION_DATA_DIR # e.g. settings.DATA_DIR_INTERVENTION
 
-MODEL_0 = InformationSource
 
 IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
-    MODEL_0.__name__,
+    InformationSourceType.__name__,
+    InformationSource.__name__,
 ]
 
 IMPORT_METADATA = {
-    MODEL_0.__name__: {
-        "dir": SOURCE_DIR, # e.g. "interventions"
-        "model": MODEL_0, # e.g. Intervention
+    InformationSourceType.__name__: {
+        "dir": INFORMATION_SOURCE_TYPE_DATA_DIR, # e.g. "intervention_type"
+        "model": InformationSourceType, # e.g. InterventionType
         "foreign_keys": [], # e.g. ["intervention_types"]
         "foreign_key_models": [] # e.g. [InterventionType]
+    },
+    InformationSource.__name__: {
+        "dir": SOURCE_DIR, # e.g. "interventions"
+        "model": InformationSource, # e.g. Intervention
+        "foreign_keys": ["information_source_types"], # e.g. ["intervention_types"]
+        "foreign_key_models": [InformationSourceType] # e.g. [InterventionType]
     }
 }
 

endoreg_db/management/commands/load_name_data.py

@@ -0,0 +1,37 @@
+# endoreg_db/management/commands/generate_names.py
+
+import os
+from django.core.management.base import BaseCommand
+from endoreg_db.utils import collect_center_names  # Import your function here
+from pathlib import Path
+
+class Command(BaseCommand):
+    help = "Generate first_names.yaml and last_names.yaml from center data"
+
+    def add_arguments(self, parser):
+        # Adding an argument for the input file path
+        # parser.add_argument(
+        #     '--input_file_path',
+        #     type=str,
+        #     required=False,
+        #     help="Path to the input YAML file containing center data",
+        #     default="data/center/data.yaml",
+        # )
+        # parser.add_argument(
+        #     '--output-dir',
+        #     type=str,
+        #     default=os.getcwd(),
+        #     help="Directory where the output files will be saved (default: current directory)",
+        # )
+        pass
+
+    def handle(self, *args, **options):
+
+        # Run the function with the provided arguments
+        try:
+            collect_center_names()
+            self.stdout.write(self.style.SUCCESS("Successfully generated YAML files."))
+        except Exception as e:
+            self.stderr.write(self.style.ERROR(f"An error occurred: {e}"))
+
+            self.stderr.write(self.style.ERROR(f"PWD: {os.getcwd()}"))

endoreg_db/management/commands/load_qualification_data.py

@@ -0,0 +1,59 @@
+from django.core.management.base import BaseCommand
+from ...models import Qualification, QualificationType
+from ...utils import load_model_data_from_yaml
+from ...data import QUALIFICATION_DATA_DIR
+
+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, # e.g. Intervention
+        "foreign_keys": [], # e.g. ["intervention_types"]
+        "foreign_key_models": [] # e.g. [InterventionType]
+    },
+    model_1.__name__: {
+        "dir": SOURCE_DIR, # e.g. "interventions"
+        "model": model_1, # e.g. Intervention
+        "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_requirement_data.py

@@ -12,8 +12,8 @@ from endoreg_db.models import (
     Event,
     LabValue,
     Finding,
-    FindingMorphologyClassificationChoice,
-    FindingLocationClassificationChoice,
+    FindingClassification,
+    FindingClassificationChoice,
     FindingIntervention,
     InformationSource,
     Unit,
@@ -22,7 +22,12 @@ from endoreg_db.models import (
     MedicationIndication,
     MedicationIndicationType,
     MedicationSchedule,
+    Medication,  # Added Medication model
+    MedicationIntakeTime,
+    Tag,
+    ExaminationRequirementSet,  # Added to avoid circular import issues
 )
+from endoreg_db.models.other.gender import Gender
 from ...utils import load_model_data_from_yaml
 from ...data import (
     REQUIREMENT_TYPE_DATA_DIR,
@@ -30,6 +35,7 @@ from ...data import (
     REQUIREMENT_DATA_DIR,
     REQUIREMENT_SET_TYPE_DATA_DIR,
     REQUIREMENT_SET_DATA_DIR,
+    EXAMINATION_REQUIREMENT_SET_DATA_DIR
 )
 
 
@@ -38,6 +44,7 @@ IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
     RequirementOperator.__name__,
     Requirement.__name__,
     RequirementSetType.__name__,
+    ExaminationRequirementSet.__name__,
     RequirementSet.__name__,
 ]
 
@@ -54,6 +61,13 @@ IMPORT_METADATA = {
         "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,  # e.g. Intervention
+        "foreign_keys": ["examinations",], # Through model uses foreign keys of both models
+        "foreign_key_models": [Examination,],
+    },
+    # ExaminationRequirementSet.__name__,
     Requirement.__name__: {
         "dir": REQUIREMENT_DATA_DIR,  # e.g. "interventions"
         "model": Requirement,  # e.g. Intervention
@@ -68,14 +82,17 @@ IMPORT_METADATA = {
             "events",
             "lab_values",
             "findings",
-            "finding_morphology_classification_choices",
-            "finding_location_classification_choices",
+            "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,
@@ -88,14 +105,17 @@ IMPORT_METADATA = {
             Event,
             LabValue,
             Finding,
-            FindingMorphologyClassificationChoice,
-            FindingLocationClassificationChoice,
+            FindingClassification,
+            FindingClassificationChoice,
             FindingIntervention,
             Risk,
             RiskType,
             MedicationIndication,
             MedicationIndicationType,
             MedicationSchedule,
+            Medication,  # Added Medication model
+            MedicationIntakeTime,
+            Gender
         ],
     },
     RequirementSetType.__name__: {
@@ -112,12 +132,16 @@ IMPORT_METADATA = {
             "requirements",  # This is a many-to-many field
             "links_to_sets",
             "information_sources",
+            "tags",
+            "reqset_exam_links"
         ],  # e.g. ["intervention_types"]
         "foreign_key_models": [
             RequirementSetType,
             Requirement,
             RequirementSet,
             InformationSource,
+            Tag,
+            ExaminationRequirementSet
         ],  # e.g. [InterventionType]
     },
 }

endoreg_db/management/commands/load_shift_data.py

@@ -0,0 +1,60 @@
+from django.core.management.base import BaseCommand
+from ...models import Shift, ShiftType
+from ...utils import load_model_data_from_yaml
+from ...data import REPORT_READER_FLAG_DATA_DIR
+
+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, # e.g. Intervention
+        "foreign_keys": [], # e.g. ["intervention_types"]
+        "foreign_key_models": [] # e.g. [InterventionType]
+    },
+    model_1.__name__: {
+        "dir": SOURCE_DIR, # e.g. "interventions"
+        "model": model_1, # e.g. Intervention
+        "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
+            )

endoreg_db/management/commands/load_tag_data.py

@@ -0,0 +1,57 @@
+from django.core.management.base import BaseCommand
+from endoreg_db.models import (
+    Tag,
+
+)
+
+from ...utils import load_model_data_from_yaml
+from ...data import (
+    TAG_DATA_DIR
+)
+
+
+IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
+    Tag.__name__,
+]
+
+IMPORT_METADATA = {
+    Tag.__name__: {
+        "dir": TAG_DATA_DIR,  # e.g. "interventions"
+        "model": Tag,  # e.g. Intervention
+        "foreign_keys": [],  # e.g. ["intervention_types"]
+        "foreign_key_models": [],  # 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/register_ai_model.py

@@ -25,7 +25,7 @@ class Command(BaseCommand):
         parser.add_argument('model_meta_path', type=str)
 
     def handle(self, *args, **options):
-        model_meta_path = Path(options['model_meta_path']).resolve()
+        model_meta_path = Path(options['model_meta_path'])
 
         with open(model_meta_path, 'r') as f:
             model_meta = json.load(f)

endoreg_db/management/commands/start_filewatcher.py

@@ -0,0 +1,106 @@
+"""
+Django Management Command for File Watcher Service
+
+This command provides Django integration for the file watcher service.
+"""
+
+from django.core.management.base import BaseCommand
+from django.conf import settings
+import sys
+import os
+from pathlib import Path
+
+
+class Command(BaseCommand):
+    help = """
+    Start the file watcher service for automatic video and PDF processing.
+    
+    This command monitors:
+    - data/raw_videos/ for video files (.mp4, .avi, .mov, .mkv, .webm, .m4v)
+    - data/raw_pdfs/ for PDF files (.pdf)
+    
+    When files are detected, they are automatically processed with:
+    - Video: Import, anonymization, and segmentation
+    - PDF: Import and anonymization
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--test',
+            action='store_true',
+            help='Test the file watcher configuration without starting monitoring',
+        )
+        parser.add_argument(
+            '--existing',
+            action='store_true',
+            help='Process existing files in the directories before starting monitoring',
+        )
+        parser.add_argument(
+            '--log-level',
+            choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+            default='INFO',
+            help='Set logging level (default: INFO)',
+        )
+
+    def handle(self, *args, **options):
+        self.stdout.write(self.style.SUCCESS("Starting File Watcher Service"))
+        
+        # Set environment variables
+        os.environ['WATCHER_LOG_LEVEL'] = options['log_level']
+        
+        try:
+            # Add project root to path
+            project_root = Path(settings.BASE_DIR)
+            if str(project_root) not in sys.path:
+                sys.path.insert(0, str(project_root))
+            
+            # Import the file watcher service from the correct location
+            file_watcher_path = project_root / 'scripts' / 'file_watcher.py'
+            
+            if not file_watcher_path.exists():
+                self.stdout.write(self.style.ERROR(f"❌ File watcher script not found: {file_watcher_path}"))
+                return
+            
+            # Import the module dynamically
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("file_watcher", file_watcher_path)
+            file_watcher_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(file_watcher_module)
+            
+            FileWatcherService = file_watcher_module.FileWatcherService
+            
+            if options['test']:
+                self.stdout.write("Testing file watcher configuration...")
+                service = FileWatcherService()
+                try:
+                    service._validate_django_setup()
+                except Exception as e:
+                    self.stdout.write(self.style.ERROR(f"❌ Validation failed: {e}"))
+                    return
+                self.stdout.write(self.style.SUCCESS("✅ File watcher test passed"))
+                return
+            
+            # Create and start the service
+            service = FileWatcherService()
+            
+            if options['existing']:
+                self.stdout.write("Processing existing files...")
+                service._process_existing_files()
+                self.stdout.write(self.style.SUCCESS("✅ Existing files processed"))
+                return
+            
+            self.stdout.write("Starting file monitoring...")
+            self.stdout.write(f"Video directory: {service.video_dir}")
+            self.stdout.write(f"PDF directory: {service.pdf_dir}")
+            self.stdout.write("Press Ctrl+C to stop")
+            
+            service.start()
+            
+        except KeyboardInterrupt:
+            self.stdout.write(self.style.WARNING("\n⚠️  File watcher stopped by user"))
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Error: {str(e)}"))
+            if options['verbosity'] >= 2:
+                import traceback
+                self.stdout.write(traceback.format_exc())
+            sys.exit(1)