endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/management/commands/load_shift_data.py

@@ -1,32 +1,34 @@
 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
-from ...data import REPORT_READER_FLAG_DATA_DIR
 
-SOURCE_DIR = REPORT_READER_FLAG_DATA_DIR # e.g. settings.DATA_DIR_INTERVENTION
+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
+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]
+        "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, # e.g. Intervention
-        "foreign_keys": ["shift_types"], # e.g. ["intervention_types"]
-        "foreign_key_models": [model_0]   # e.g. [InterventionType]
-    }
+        "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"""
@@ -36,25 +38,20 @@ class Command(BaseCommand):
         Adds the --verbose command-line option to enable detailed output during execution.
         """
         parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Display verbose output',
+            "--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']
+        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_tag_data.py

@@ -1,14 +1,11 @@
 from django.core.management.base import BaseCommand
+
 from endoreg_db.models import (
     Tag,
-
 )
 
+from ...data import TAG_DATA_DIR
 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__,
@@ -17,7 +14,7 @@ IMPORT_MODELS = [  # string as model key, serves as key in IMPORT_METADATA
 IMPORT_METADATA = {
     Tag.__name__: {
         "dir": TAG_DATA_DIR,  # e.g. "interventions"
-        "model": Tag,  # e.g. Intervention
+        "model": Tag,
         "foreign_keys": [],  # e.g. ["intervention_types"]
         "foreign_key_models": [],  # e.g. [InterventionType]
     },
@@ -32,7 +29,7 @@ class Command(BaseCommand):
     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.
         """
@@ -45,10 +42,10 @@ class Command(BaseCommand):
     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 
+
+        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"]

endoreg_db/management/commands/load_unit_data.py

@@ -1,46 +1,44 @@
-from django.conf import settings
 import os
+
+import yaml
+from django.conf import settings
 from django.core.management.base import BaseCommand
+
+from ...data import UNIT_DATA_DIR
 from ...models import Unit
-import yaml
 from ...utils import load_model_data_from_yaml
-from ...data import UNIT_DATA_DIR
 
-SOURCE_DIR = UNIT_DATA_DIR # e.g. settings.DATA_DIR_INTERVENTION
+SOURCE_DIR = UNIT_DATA_DIR  # e.g. settings.DATA_DIR_INTERVENTION
 
 MODEL_0 = Unit
 
-IMPORT_MODELS = [ # string as model key, serves as key in IMPORT_METADATA
+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]
+        "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',
+            "--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/setup_endoreg_db.py

@@ -158,9 +158,9 @@ class Command(BaseCommand):
 
         self.stdout.write(self.style.SUCCESS("\n🎉 EndoReg DB embedded app setup completed successfully!"))
         self.stdout.write("\nNext steps:")
-        self.stdout.write("1. Run migrations: python manage.py migrate")
-        self.stdout.write("2. Create superuser: python manage.py createsuperuser")
-        self.stdout.write("3. Start development server: python manage.py runserver")
+        # self.stdout.write("1. Run migrations: python manage.py migrate")
+        self.stdout.write("1. Create superuser: python manage.py createsuperuser")
+        self.stdout.write("2. Start development server: python manage.py runserver")
 
     def _find_model_weights_file(self):
         """Find the model weights file using configurable search patterns and directories."""

endoreg_db/management/commands/start_filewatcher.py

@@ -4,72 +4,80 @@ 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
+import sys
 from pathlib import Path
 
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
 
 class Command(BaseCommand):
     help = """
-    Start the file watcher service for automatic video and PDF processing.
+    Start the file watcher service for automatic video and report processing.
     
     This command monitors:
     - data/raw_videos/ for video files (.mp4, .avi, .mov, .mkv, .webm, .m4v)
-    - data/raw_pdfs/ for PDF files (.pdf)
+    - data/raw_pdfs/ for report files (.pdf)
     
     When files are detected, they are automatically processed with:
     - Video: Import, anonymization, and segmentation
-    - PDF: Import and anonymization
+    - report: Import and anonymization
     """
 
     def add_arguments(self, parser):
         parser.add_argument(
-            '--test',
-            action='store_true',
-            help='Test the file watcher configuration without starting monitoring',
+            "--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',
+            "--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)',
+            "--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']
-        
+        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'
-            
+            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}"))
+                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)
+
+            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']:
+
+            if options["test"]:
                 self.stdout.write("Testing file watcher configuration...")
                 service = FileWatcherService()
                 try:
@@ -79,28 +87,29 @@ class Command(BaseCommand):
                     return
                 self.stdout.write(self.style.SUCCESS("✅ File watcher test passed"))
                 return
-            
+
             # Create and start the service
             service = FileWatcherService()
-            
-            if options['existing']:
+
+            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(f"report directory: {service.report_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:
+            if options["verbosity"] >= 2:
                 import traceback
+
                 self.stdout.write(traceback.format_exc())
-            sys.exit(1)
+            sys.exit(1)