endoreg-db 0.8.3.9__tar.gz → 0.8.4.1__tar.gz

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/CONFIGURATION_GUIDE.md

@@ -65,6 +65,33 @@ The command automatically detects your cache configuration:
 
 Use `--skip-ai-setup` if AI video processing features are not needed, or `--force-recreate` to recreate AI metadata.
 
+### AI Model Validation and Troubleshooting
+
+If you encounter "No model metadata found for this model" errors during video processing, use the dedicated validation command:
+
+```bash
+# Check AI model metadata status without making changes
+python manage.py validate_ai_models --dry-run
+
+# Fix AI model metadata issues automatically  
+python manage.py validate_ai_models
+
+# View detailed help
+python manage.py validate_ai_models --help
+```
+
+The validation command automatically:
+- Checks all AI models for proper metadata configuration
+- Creates missing metadata with sensible defaults (ImageNet normalization, etc.)
+- Sets active metadata for models that don't have it assigned
+- Validates that all models can access their latest versions
+
+Common scenarios this fixes:
+- **"No model metadata found"** errors in pipe_1 video processing
+- AI models exist but have no `active_meta` set
+- Models have metadata versions but none are marked as active
+- Missing ModelMeta records for classification/segmentation models
+
 This repo standalone (local):
 - Development server: DJANGO_SETTINGS_MODULE=config.settings.dev python manage.py runserver
 - Tests (persistent test DB): pytest --reuse-db --create-db

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.3.9
+Version: 0.8.4.1
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/endoreg_db/management/commands/setup_endoreg_db.py

@@ -8,8 +8,10 @@ from pathlib import Path
 
 from django.core.management import call_command
 from django.core.management.base import BaseCommand
+
 from endoreg_db.models import ModelMeta
 
+
 class Command(BaseCommand):
     help = """
     Complete setup for EndoReg DB when used as an embedded app.
@@ -119,6 +121,15 @@ class Command(BaseCommand):
                 self.stdout.write(self.style.ERROR(f"❌ Failed to create AI model metadata: {e}"))
                 return
 
+            # Step 5.5: Validate and fix AI model active metadata
+            self.stdout.write("\n🔧 Step 5.5: Validating AI model active metadata...")
+            try:
+                self._validate_and_fix_ai_model_metadata()
+                self.stdout.write(self.style.SUCCESS("✅ AI model metadata validation completed"))
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f"❌ Failed to validate AI model metadata: {e}"))
+                return
+
         # Step 6: Verification
         self.stdout.write("\n🔍 Step 6: Verifying setup...")
         try:
@@ -137,12 +148,11 @@ class Command(BaseCommand):
     def _find_model_weights_file(self):
         """Find the model weights file in various possible locations."""
         # Check common locations for model weights
-        
+
         if not ModelMeta.objects.exists():
             print("📦 No model metadata found — creating from Hugging Face...")
             ModelMeta.setup_default_from_huggingface(
-                "wg-lux/colo_segmentation_RegNetX800MF_base",
-                labelset_name="multilabel_classification_colonoscopy_default"
+                "wg-lux/colo_segmentation_RegNetX800MF_base", labelset_name="multilabel_classification_colonoscopy_default"
             )
             print("✅ Default ModelMeta created.")
         possible_paths = [
@@ -162,10 +172,8 @@ class Command(BaseCommand):
                 return path
 
         self.stdout.write("Model weights file not found in standard locations")
-        
-        return None
-    
 
+        return None
 
     def _verify_setup(self):
         """Verify that the setup was successful."""
@@ -205,5 +213,81 @@ class Command(BaseCommand):
             self.stdout.write(f"Found {meta_count} model metadata record(s)")
 
         self.stdout.write("Setup verification passed")
-        
 
+    def _validate_and_fix_ai_model_metadata(self):
+        """
+        Validate that all AI models have proper active metadata and fix if necessary.
+        This addresses the "No model metadata found for this model" error.
+        """
+        from endoreg_db.models import AiModel, LabelSet, ModelMeta
+
+        all_models = AiModel.objects.all()
+        fixed_count = 0
+
+        for model in all_models:
+            self.stdout.write(f"Checking model: {model.name}")
+
+            # Check if model has metadata versions
+            metadata_count = model.metadata_versions.count()
+            self.stdout.write(f"  Metadata versions: {metadata_count}")
+
+            if metadata_count == 0:
+                # Create metadata for models that don't have any
+                self.stdout.write(f"  Creating metadata for {model.name}...")
+
+                # Use existing labelset or create default
+                labelset = LabelSet.objects.first()
+                if not labelset:
+                    labelset = LabelSet.objects.create(name="default_colonoscopy_labels", description="Default colonoscopy classification labels")
+
+                # Create basic metadata
+                meta = ModelMeta.objects.create(
+                    name=model.name,
+                    version="1.0",
+                    model=model,
+                    labelset=labelset,
+                    activation="sigmoid" if "classification" in model.name else "sigmoid",
+                    mean="0.485,0.456,0.406",  # ImageNet defaults
+                    std="0.229,0.224,0.225",  # ImageNet defaults
+                    size_x=224,
+                    size_y=224,
+                    axes="CHW",
+                    batchsize=32,
+                    num_workers=4,
+                    description=f"Auto-generated metadata for {model.name}",
+                )
+
+                model.active_meta = meta
+                model.save()
+                fixed_count += 1
+                self.stdout.write(f"  ✅ Created and set metadata for {model.name}")
+
+            elif not model.active_meta:
+                # Model has metadata but no active meta set
+                first_meta = model.metadata_versions.first()
+                if first_meta:
+                    self.stdout.write(f"  Setting active metadata for {model.name}...")
+                    model.active_meta = first_meta
+                    model.save()
+                    fixed_count += 1
+                    self.stdout.write(f"  ✅ Set active metadata: {first_meta.name} v{first_meta.version}")
+                else:
+                    self.stdout.write(f"  ⚠️  No metadata versions available for {model.name}")
+
+            else:
+                self.stdout.write(f"  ✅ Model {model.name} has active metadata: {model.active_meta}")
+
+        # Verify all models can get latest version
+        self.stdout.write("\nTesting model metadata access...")
+        for model in all_models:
+            try:
+                latest = model.get_latest_version()
+                self.stdout.write(f"  ✅ {model.name}: {latest}")
+            except Exception as e:
+                self.stdout.write(f"  ❌ {model.name}: {e}")
+                raise Exception(f"Model {model.name} still has metadata issues: {e}")
+
+        if fixed_count > 0:
+            self.stdout.write(f"Fixed metadata for {fixed_count} model(s)")
+        else:
+            self.stdout.write("All models already had proper metadata")

endoreg_db-0.8.4.1/endoreg_db/management/commands/validate_ai_models.py

@@ -0,0 +1,124 @@
+"""
+Django management command to validate and fix AI model metadata issues.
+This command addresses the "No model metadata found for this model" error.
+"""
+
+from django.core.management.base import BaseCommand
+
+from endoreg_db.models.metadata.model_meta_logic import validate_and_fix_ai_model_metadata_logic
+
+
+class Command(BaseCommand):
+    help = """
+    Validate and fix AI model metadata to prevent processing errors.
+    
+    This command:
+    - Checks all AI models for proper metadata configuration
+    - Creates missing metadata with sensible defaults
+    - Sets active metadata for models that don't have it
+    - Validates that all models can access their latest versions
+    
+    Use this command to fix "No model metadata found for this model" errors.
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be fixed without making changes",
+        )
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Force recreation of existing metadata",
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options.get("dry_run", False)
+        force = options.get("force", False)
+
+        self.stdout.write(self.style.SUCCESS("🔍 Validating AI model metadata..."))
+
+        if dry_run:
+            self.stdout.write(self.style.WARNING("🧪 DRY RUN MODE - No changes will be made"))
+
+        try:
+            if dry_run:
+                # In dry run, we just check and report issues
+                summary = self._check_ai_models_dry_run()
+            else:
+                # Actually fix the issues
+                summary = validate_and_fix_ai_model_metadata_logic()
+
+            # Report results
+            self._report_summary(summary)
+
+            if summary["errors"]:
+                self.stdout.write(self.style.ERROR("❌ Validation completed with errors"))
+                for error in summary["errors"]:
+                    self.stdout.write(self.style.ERROR(f"  - {error}"))
+                return
+
+            self.stdout.write(self.style.SUCCESS("✅ AI model metadata validation completed successfully"))
+
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Validation failed: {e}"))
+            raise
+
+    def _check_ai_models_dry_run(self):
+        """Check AI models without making changes."""
+        from endoreg_db.models import AiModel
+
+        summary = {"models_checked": 0, "models_fixed": 0, "metadata_created": 0, "active_meta_set": 0, "errors": []}
+
+        all_models = AiModel.objects.all()
+        summary["models_checked"] = all_models.count()
+
+        for model in all_models:
+            self.stdout.write(f"Checking model: {model.name}")
+
+            metadata_count = model.metadata_versions.count()
+            self.stdout.write(f"  Metadata versions: {metadata_count}")
+
+            if metadata_count == 0:
+                self.stdout.write(f"  🔧 Would create metadata for {model.name}")
+                summary["models_fixed"] += 1
+                summary["metadata_created"] += 1
+
+            elif not model.active_meta:
+                self.stdout.write(f"  🔧 Would set active metadata for {model.name}")
+                summary["models_fixed"] += 1
+                summary["active_meta_set"] += 1
+
+            else:
+                self.stdout.write(f"  ✅ Model {model.name} has valid active metadata")
+
+            # Test metadata access
+            try:
+                latest = model.get_latest_version()
+                self.stdout.write(f"  ✅ Can access latest version: {latest}")
+            except Exception as e:
+                error_msg = f"Model {model.name} metadata test failed: {e}"
+                self.stdout.write(self.style.ERROR(f"  ❌ {error_msg}"))
+                summary["errors"].append(error_msg)
+
+        return summary
+
+    def _report_summary(self, summary):
+        """Report the validation summary."""
+        self.stdout.write("\n📊 Validation Summary:")
+        self.stdout.write(f"  Models checked: {summary['models_checked']}")
+
+        if summary["models_fixed"] > 0:
+            self.stdout.write(f"  Models fixed: {summary['models_fixed']}")
+
+        if summary["metadata_created"] > 0:
+            self.stdout.write(f"  Metadata created: {summary['metadata_created']}")
+
+        if summary["active_meta_set"] > 0:
+            self.stdout.write(f"  Active metadata set: {summary['active_meta_set']}")
+
+        if summary["errors"]:
+            self.stdout.write(f"  Errors encountered: {len(summary['errors'])}")
+        else:
+            self.stdout.write("  No errors found")

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/endoreg_db/models/metadata/model_meta_logic.py

@@ -18,18 +18,14 @@ if TYPE_CHECKING:
     from .model_meta import ModelMeta  # Import ModelMeta for type hinting
 
 
-def get_latest_version_number_logic(
-    cls: Type["ModelMeta"], meta_name: str, model_name: str
-) -> int:
+def get_latest_version_number_logic(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> int:
     """
     Finds the highest numerical version for a given meta_name and model_name.
     Iterates through all versions, attempts to parse them as integers,
     and returns the maximum integer found. If no numeric versions are found,
     returns 0.
     """
-    versions_qs = cls.objects.filter(
-        name=meta_name, model__name=model_name
-    ).values_list("version", flat=True)
+    versions_qs = cls.objects.filter(name=meta_name, model__name=model_name).values_list("version", flat=True)
 
     max_v = 0
     found_numeric_version = False
@@ -84,24 +80,17 @@ def create_from_file_logic(
 
     if requested_version:
         target_version = str(requested_version)
-        existing = cls.objects.filter(
-            name=meta_name, model=ai_model, version=target_version
-        ).first()
+        existing = cls.objects.filter(name=meta_name, model=ai_model, version=target_version).first()
         if existing and not bump_if_exists:
             raise ValueError(
-                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' "
-                f"already exists. Use bump_if_exists=True to increment."
+                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' already exists. Use bump_if_exists=True to increment."
             )
         elif existing and bump_if_exists:
             target_version = str(latest_version_num + 1)
-            logger.info(
-                f"Bumping version for {meta_name}/{model_name} to {target_version}"
-            )
+            logger.info(f"Bumping version for {meta_name}/{model_name} to {target_version}")
     else:
         target_version = str(latest_version_num + 1)
-        logger.info(
-            f"Setting next version for {meta_name}/{model_name} to {target_version}"
-        )
+        logger.info(f"Setting next version for {meta_name}/{model_name} to {target_version}")
 
     # --- Prepare Weights File ---
     source_weights_path = Path(weights_file).resolve()
@@ -111,10 +100,7 @@ def create_from_file_logic(
     # Construct destination path within MEDIA_ROOT/WEIGHTS_DIR
     weights_filename = source_weights_path.name
     # Relative path for the FileField upload_to
-    relative_dest_path = (
-        Path(WEIGHTS_DIR.relative_to(STORAGE_DIR))
-        / f"{meta_name}_v{target_version}_{weights_filename}"
-    )
+    relative_dest_path = Path(WEIGHTS_DIR.relative_to(STORAGE_DIR)) / f"{meta_name}_v{target_version}_{weights_filename}"
     # Full path for shutil.copy
     full_dest_path = STORAGE_DIR / relative_dest_path
 
@@ -233,22 +219,14 @@ def get_model_meta_by_name_version_logic(
         try:
             return cls.objects.get(name=meta_name, model=ai_model, version=version)
         except Exception as exc:
-            raise cls.DoesNotExist(
-                f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found."
-            ) from exc
+            raise cls.DoesNotExist(f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found.") from exc
     else:
         # Get latest version
-        latest = (
-            cls.objects.filter(name=meta_name, model=ai_model)
-            .order_by("-date_created")
-            .first()
-        )
+        latest = cls.objects.filter(name=meta_name, model=ai_model).order_by("-date_created").first()
         if latest:
             return latest
         else:
-            raise cls.DoesNotExist(
-                f"No ModelMeta found for '{meta_name}' and model '{model_name}'."
-            )
+            raise cls.DoesNotExist(f"No ModelMeta found for '{meta_name}' and model '{model_name}'.")
 
 
 import re
@@ -266,9 +244,7 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     """
 
     if not (info := model_info(model_id)):
-        logger.info(
-            f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults."
-        )
+        logger.info(f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults.")
         return {
             "name": "wg-lux/colo_segmentation_RegNetX800MF_base",
             "activation": "sigmoid",
@@ -317,9 +293,7 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     }
 
 
-def setup_default_from_huggingface_logic(
-    cls, model_id: str, labelset_name: str | None = None
-):
+def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str | None = None):
     """
     Downloads model weights from Hugging Face and auto-fills ModelMeta fields.
     """
@@ -333,11 +307,7 @@ def setup_default_from_huggingface_logic(
     )
 
     ai_model, _ = AiModel.objects.get_or_create(name=meta["name"])
-    labelset = (
-        LabelSet.objects.first()
-        if not labelset_name
-        else LabelSet.objects.get(name=labelset_name)
-    )
+    labelset = LabelSet.objects.first() if not labelset_name else LabelSet.objects.get(name=labelset_name)
 
     return create_from_file_logic(
         cls,
@@ -352,3 +322,99 @@ def setup_default_from_huggingface_logic(
         size_y=meta["size_y"],
         description=meta["description"],
     )
+
+
+def validate_and_fix_ai_model_metadata_logic():
+    """
+    Validates that all AI models have proper active metadata and fixes any issues.
+    This prevents the "No model metadata found for this model" error.
+
+    Returns:
+        dict: Summary of fixes applied
+    """
+    from ..administration.ai.ai_model import AiModel
+    from ..label.label_set import LabelSet
+
+    summary = {"models_checked": 0, "models_fixed": 0, "metadata_created": 0, "active_meta_set": 0, "errors": []}
+
+    try:
+        all_models = AiModel.objects.all()
+        summary["models_checked"] = all_models.count()
+
+        for model in all_models:
+            logger.info(f"Validating model: {model.name}")
+
+            # Check if model has metadata versions
+            metadata_count = model.metadata_versions.count()
+
+            if metadata_count == 0:
+                # Create metadata for models that don't have any
+                logger.info(f"Creating metadata for {model.name}")
+
+                # Use existing labelset or create default
+                labelset = LabelSet.objects.first()
+                if not labelset:
+                    labelset = LabelSet.objects.create(name="default_colonoscopy_labels", description="Default colonoscopy classification labels")
+
+                # Import here to avoid circular imports
+                from .model_meta import ModelMeta
+
+                # Create basic metadata
+                meta = ModelMeta.objects.create(
+                    name=model.name,
+                    version="1.0",
+                    model=model,
+                    labelset=labelset,
+                    activation="sigmoid" if "classification" in model.name else "sigmoid",
+                    mean="0.485,0.456,0.406",  # ImageNet defaults
+                    std="0.229,0.224,0.225",  # ImageNet defaults
+                    size_x=224,
+                    size_y=224,
+                    axes="CHW",
+                    batchsize=32,
+                    num_workers=4,
+                    description=f"Auto-generated metadata for {model.name}",
+                )
+
+                model.active_meta = meta
+                model.save()
+                summary["models_fixed"] += 1
+                summary["metadata_created"] += 1
+                logger.info(f"Created and set metadata for {model.name}")
+
+            elif not model.active_meta:
+                # Model has metadata but no active meta set
+                first_meta = model.metadata_versions.first()
+                if first_meta:
+                    logger.info(f"Setting active metadata for {model.name}")
+                    model.active_meta = first_meta
+                    model.save()
+                    summary["models_fixed"] += 1
+                    summary["active_meta_set"] += 1
+                    logger.info(f"Set active metadata: {first_meta.name} v{first_meta.version}")
+                else:
+                    error_msg = f"No metadata versions available for {model.name}"
+                    logger.warning(error_msg)
+                    summary["errors"].append(error_msg)
+
+            else:
+                logger.info(f"Model {model.name} has valid active metadata: {model.active_meta}")
+
+        # Verify all models can get latest version
+        logger.info("Testing model metadata access...")
+        for model in all_models:
+            try:
+                latest = model.get_latest_version()
+                logger.info(f"✅ {model.name}: {latest}")
+            except Exception as e:
+                error_msg = f"Model {model.name} metadata test failed: {e}"
+                logger.error(error_msg)
+                summary["errors"].append(error_msg)
+
+        return summary
+
+    except Exception as e:
+        error_msg = f"Validation failed: {e}"
+        logger.error(error_msg)
+        summary["errors"].append(error_msg)
+        return summary

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/endoreg_db/services/video_import.py

@@ -55,7 +55,18 @@ class VideoImportService():
             self.project_root = Path(__file__).parent.parent.parent.parent
         
         # Track processed files to prevent duplicates
-        self.processed_files = set(str(Path(ANONYM_VIDEO_DIR) / file) for file in os.listdir(ANONYM_VIDEO_DIR))
+        try:
+            # Ensure anonym_video directory exists before listing files
+            anonym_video_dir = Path(ANONYM_VIDEO_DIR)
+            if anonym_video_dir.exists():
+                self.processed_files = set(str(anonym_video_dir / file) for file in os.listdir(ANONYM_VIDEO_DIR))
+            else:
+                logger.info(f"Creating anonym_videos directory: {anonym_video_dir}")
+                anonym_video_dir.mkdir(parents=True, exist_ok=True)
+                self.processed_files = set()
+        except Exception as e:
+            logger.warning(f"Failed to initialize processed files tracking: {e}")
+            self.processed_files = set()
                     
         # Central video instance and processing context
         self.current_video: Optional[VideoFile] = None
@@ -146,6 +157,9 @@ class VideoImportService():
         High-level helper that orchestrates the complete video import and anonymization process.
         Uses the central video instance pattern for improved state management.
         """
+        # DEFENSIVE: Initialize processing_context immediately to prevent KeyError crashes
+        self.processing_context = {'file_path': Path(file_path)}
+        
         try:
             # Initialize processing context
             self._initialize_processing_context(file_path, center_name, processor_name, 
@@ -182,7 +196,12 @@ class VideoImportService():
             return self.current_video
             
         except Exception as e:
-            self.logger.error(f"Video import and anonymization failed for {file_path}: {e}")
+            # Safe file path access - handles cases where processing_context wasn't initialized
+            safe_file_path = getattr(self, 'processing_context', {}).get('file_path', file_path)
+            # Debug: Log context state for troubleshooting
+            context_keys = list(getattr(self, 'processing_context', {}).keys())
+            self.logger.debug(f"Context keys during error: {context_keys}")
+            self.logger.error(f"Video import and anonymization failed for {safe_file_path}: {e}")
             self._cleanup_on_error()
             raise
         finally:
@@ -969,6 +988,10 @@ class VideoImportService():
         This method is always called in the finally block of import_and_anonymize()
         to ensure the file lock is released even if processing fails.
         """
+        # DEFENSIVE: Ensure processing_context exists before accessing it
+        if not hasattr(self, 'processing_context'):
+            self.processing_context = {}
+            
         try:
             # Release file lock if it was acquired
             lock_context = self.processing_context.get('_lock_context')

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/pyproject.toml

@@ -14,7 +14,7 @@ maintainers = [
 ]
 name = "endoreg-db"
 readme = "README.md"
-version = "0.8.3.9"
+version = "0.8.4.1"
 
 classifiers = [
   "Development Status :: 3 - Alpha",

{endoreg_db-0.8.3.9 → endoreg_db-0.8.4.1}/uv.lock

@@ -771,7 +771,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/62/59/e47bbd0542d0e6f4c
 
 [[package]]
 name = "endoreg-db"
-version = "0.8.3.9"
+version = "0.8.4.1"
 source = { editable = "." }
 dependencies = [
     { name = "agl-report-reader" },

endoreg_db-0.8.3.9/lx-anonymizer/.envrc

@@ -1,3 +0,0 @@
-source_url "https://raw.githubusercontent.com/cachix/devenv/82c0147677e510b247d8b9165c54f73d32dfd899/direnvrc" "sha256-7u4iDd1nZpxL4tCzmPG0dQgC5V+/44Ba+tHkPob1v2k="
-
-use devenv

endoreg_db-0.8.3.9/lx-anonymizer/.git

@@ -1 +0,0 @@
-gitdir: ../.git/modules/lx-anonymizer

endoreg_db-0.8.3.9/lx-anonymizer/.github/workflows/publish.yml

@@ -1,39 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-    tags:  # Optional: only publish on tagged releases
-      - 'v*'  
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out the repository
-        uses: actions/checkout@v4
-
-      # (Optional) run tests, lint, etc. in preceding steps
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.11'
-
-      - name: Install build and twine
-        run: |
-          pip install --upgrade pip
-          pip install build twine
-
-      - name: Build Distribution
-        run: |
-          python -m build
-
-      - name: Publish to PyPI
-        if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-        run: |
-          python -m twine upload dist/*
-        env:
-          PYPI_USERNAME: __token__
-          PYPI_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}