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

endoreg_db/urls/__init__.py

@@ -3,14 +3,14 @@ from django.conf.urls.static import static
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
+from endoreg_db.authz.views_auth import auth_bootstrap
+
 from endoreg_db.views import (
     ExaminationViewSet,
     FindingClassificationViewSet,
     FindingViewSet,
     PatientExaminationViewSet,
     PatientFindingViewSet,
-    VideoExaminationViewSet,
-    VideoViewSet,
 )
 
 from .anonymization import url_patterns as anonymization_url_patterns
@@ -29,11 +29,9 @@ from .patient import urlpatterns as patient_url_patterns
 
 # TODO Phase 1.2: Implement VideoMediaView and PDFMediaView before enabling
 # from .media import urlpatterns as media_url_patterns
-from .report import url_patterns as report_url_patterns
 from .requirements import urlpatterns as requirements_url_patterns
 from .stats import url_patterns as stats_url_patterns
 from .upload import urlpatterns as upload_url_patterns
-from .video import url_patterns as video_url_patterns
 
 api_urls = []
 api_urls += classification_url_patterns
@@ -42,22 +40,16 @@ api_urls += auth_url_patterns
 api_urls += examination_url_patterns
 api_urls += files_url_patterns
 api_urls += label_video_segments_url_patterns
-api_urls += label_video_segment_validate_url_patterns  # Neue Validierungs-Endpunkte
-# Phase 1.2: Enable media_url_patterns ✅ IMPLEMENTED
+api_urls += label_video_segment_validate_url_patterns 
 api_urls += media_url_patterns
-api_urls += report_url_patterns
 api_urls += upload_url_patterns
-api_urls += video_url_patterns
 api_urls += requirements_url_patterns
 api_urls += patient_url_patterns
 api_urls += stats_url_patterns
 
 router = DefaultRouter()
-router.register(r"videos", VideoViewSet, basename="videos")
 router.register(r"examinations", ExaminationViewSet)
-router.register(
-    r"video-examinations", VideoExaminationViewSet, basename="video-examinations"
-)
+
 router.register(r"findings", FindingViewSet)
 router.register(r"classifications", FindingClassificationViewSet)
 router.register(r"patient-findings", PatientFindingViewSet)
@@ -65,17 +57,12 @@ router.register(r"patient-examinations", PatientExaminationViewSet)
 
 # Additional custom video examination routes
 # Frontend expects: GET /api/video/{id}/examinations/
-video_examinations_list = VideoExaminationViewSet.as_view({"get": "by_video"})
 
 # Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
 urlpatterns = [
-    path(
-        "video/<int:video_id>/examinations/",
-        video_examinations_list,
-        name="video-examinations-by-video",
-    ),
-    path("", include(api_urls)),  # Specific routes first
-    path("", include(router.urls)),  # Generic router routes second
+    path("auth/bootstrap", auth_bootstrap, name="auth-bootstrap"),
+    path('', include(router.urls)),  
+    path('', include(api_urls)),
 ]
 
 if settings.DEBUG:

endoreg_db/urls/media.py

@@ -1,37 +1,36 @@
-from PIL.PdfParser import PdfStream
 from django.urls import path
 
+from endoreg_db.views import VideoStreamView
 from endoreg_db.views.media import (
-    VideoMediaView,
     PdfMediaView,  # Alias to avoid conflict with legacy pdf.PDFMediaView
+    VideoMediaView,
+    pdf_sensitive_metadata,
+    pdf_sensitive_metadata_list,
+    pdf_sensitive_metadata_verify,
+    sensitive_metadata_list,
+    video_segment_detail,
+    video_segment_validate,
     video_segments_by_pk,
-    video_segments_collection,
     video_segments_by_video,
-    video_segment_detail,
+    video_segments_collection,
     video_segments_stats,
-    video_segment_validate,
     video_segments_validate_bulk,
     video_segments_validation_status,
     video_sensitive_metadata,
     video_sensitive_metadata_verify,
-    pdf_sensitive_metadata,
-    pdf_sensitive_metadata_verify,
-    sensitive_metadata_list,
-    pdf_sensitive_metadata_list,
-)
-from endoreg_db.views import (
-    VideoStreamView,
+    get_sensitive_metadata_pk
 )
-from endoreg_db.views.pdf.reimport import PdfReimportView
 from endoreg_db.views.pdf.pdf_stream import PdfStreamView
-from endoreg_db.views.video.reimport import VideoReimportView
+from endoreg_db.views.pdf.reimport import PdfReimportView
 from endoreg_db.views.video.correction import (
+    VideoApplyMaskView,
+    VideoCorrectionView,
     VideoMetadataView,
     VideoProcessingHistoryView,
-    VideoApplyMaskView,
     VideoRemoveFramesView,
-    VideoCorrectionView,
 )
+from endoreg_db.views.video.reimport import VideoReimportView
+
 # ---------------------------------------------------------------------------------------
 # ANNOTATION API ENDPOINTS
 #
@@ -41,19 +40,32 @@ from endoreg_db.views.video.correction import (
 # ---------------------------------------------------------------------------------------
 
 # Simplified Meta and Validation Endpoints
-    
+
 urlpatterns = [
+    path(
+        "media/sensitive-media-id/<int:pk>/<str:mediaType>/", 
+        get_sensitive_metadata_pk,
+        name="sm-pk"
+    ),
     # Video media endpoints
     path("media/videos/", VideoMediaView.as_view(), name="video-list"),
-    path("media/videos/<int:pk>/", VideoStreamView.as_view(), name="video-detail-stream"),  # Support ?type= params
-    path("media/videos/<int:pk>/details/", VideoMediaView.as_view(), name="video-detail"),  # JSON metadata
-    path("media/videos/<int:pk>/stream/", VideoStreamView.as_view(), name="video-stream"),  # Legacy support
-    
+    path(
+        "media/videos/<int:pk>/", VideoStreamView.as_view(), name="video-detail-stream"
+    ),  # Support ?type= params
+    path(
+        "media/videos/<int:pk>/details/", VideoMediaView.as_view(), name="video-detail"
+    ),  # JSON metadata
+    path(
+        "media/videos/<int:pk>/stream/", VideoStreamView.as_view(), name="video-stream"
+    ),  # Legacy support
     # Video Re-import API endpoint (modern media framework)
     # POST /api/media/videos/<int:pk>/reimport/
     # Re-imports a video file to regenerate metadata when OCR failed or data is incomplete
-    path("media/videos/<int:pk>/reimport/", VideoReimportView.as_view(), name="video-reimport"),
-    
+    path(
+        "media/videos/<int:pk>/reimport/",
+        VideoReimportView.as_view(),
+        name="video-reimport",
+    ),
     # ---------------------------------------------------------------------------------------
     # VIDEO CORRECTION API ENDPOINTS (Modern Media Framework - October 14, 2025)
     #
@@ -66,38 +78,51 @@ urlpatterns = [
     # - Metadata: View analysis results
     # - History: Track all correction operations
     # ---------------------------------------------------------------------------------------
-    
     # Video Correction API
     # GET /api/media/videos/video-correction/{id}/ - Get video details for correction
-    path("media/videos/video-correction/<int:pk>", VideoCorrectionView.as_view(), name="video-correction"),
-
+    path(
+        "media/videos/video-correction/<int:pk>",
+        VideoCorrectionView.as_view(),
+        name="video-correction",
+    ),
     # Video Metadata API
     # GET /api/media/videos/<int:pk>/metadata/
     # Returns analysis results (sensitive frame count, ratio, frame IDs)
-    path("media/videos/<int:pk>/metadata/", VideoMetadataView.as_view(), name="video-metadata"),
-    
+    path(
+        "media/videos/<int:pk>/metadata/",
+        VideoMetadataView.as_view(),
+        name="video-metadata",
+    ),
     # Video Processing History API
     # GET /api/media/videos/<int:pk>/processing-history/
     # Returns history of all processing operations (masking, frame removal, analysis)
-    path("media/videos/<int:pk>/processing-history/", VideoProcessingHistoryView.as_view(), name="video-processing-history"),
-    
+    path(
+        "media/videos/<int:pk>/processing-history/",
+        VideoProcessingHistoryView.as_view(),
+        name="video-processing-history",
+    ),
     # Video Analysis API
     # POST /api/media/videos/<int:pk>/analyze/
     # Analyzes video for sensitive frames using MiniCPM-o 2.6 or OCR+LLM
     # Body: { detection_method: 'minicpm'|'ocr_llm'|'hybrid', sample_interval: 30 }
-    
     # Video Masking API
     # POST /api/media/videos/<int:pk>/apply-mask/
     # Applies device mask or custom ROI mask to video
     # Body: { mask_type: 'device'|'custom', device_name: 'olympus', roi: {...} }
-    path("media/videos/<int:pk>/apply-mask/", VideoApplyMaskView.as_view(), name="video-apply-mask"),
-    
+    path(
+        "media/videos/<int:pk>/apply-mask/",
+        VideoApplyMaskView.as_view(),
+        name="video-apply-mask",
+    ),
     # Video Frame Removal API
     # POST /api/media/videos/<int:pk>/remove-frames/
     # Removes specified frames from video
     # Body: { frame_list: [10,20,30] OR frame_ranges: '10-20,30' OR detection_method: 'automatic' }
-    path("media/videos/<int:pk>/remove-frames/", VideoRemoveFramesView.as_view(), name="video-remove-frames"),
-        
+    path(
+        "media/videos/<int:pk>/remove-frames/",
+        VideoRemoveFramesView.as_view(),
+        name="video-remove-frames",
+    ),
     # ---------------------------------------------------------------------------------------
     # VIDEO SEGMENT API ENDPOINTS (Modern Media Framework - October 14, 2025)
     #
@@ -106,29 +131,40 @@ urlpatterns = [
     # Video-scoped: GET/POST segments for specific video
     # Detail: GET/PATCH/DELETE individual segment
     # ---------------------------------------------------------------------------------------
-    
     # Video Segments Collection API
     # GET/POST /api/media/videos/segments/
     # List all video segments across videos or create new segment
-    path("media/videos/segments/", video_segments_collection, name="video-segments-collection"),
-    
+    path(
+        "media/videos/segments/",
+        video_segments_collection,
+        name="video-segments-collection",
+    ),
     # Video Segments Stats API
     # GET /api/media/videos/segments/stats/
     # Get statistics about video segments
-    path("media/videos/segments/stats/", video_segments_stats, name="video-segments-stats"),
-    
+    path(
+        "media/videos/segments/stats/",
+        video_segments_stats,
+        name="video-segments-stats",
+    ),
     # Video-Specific Segments API
     # GET/POST /api/media/videos/<int:pk>/segments/
     # List segments for specific video or create segment for video
-    path("media/videos/<int:pk>/segments/", video_segments_by_video, name="video-segments-by-video"),
-    
+    path(
+        "media/videos/<int:pk>/segments/",
+        video_segments_by_video,
+        name="video-segments-by-video",
+    ),
     # Segment Detail API
     # GET /api/media/videos/<int:pk>/segments/<int:segment_id>/
     # PATCH /api/media/videos/<int:pk>/segments/<int:segment_id>/
     # DELETE /api/media/videos/<int:pk>/segments/<int:segment_id>/
     # Manages individual segment operations
-    path("media/videos/<int:pk>/segments/<int:segment_id>/", video_segment_detail, name="video-segment-detail"),
-    
+    path(
+        "media/videos/<int:pk>/segments/<int:segment_id>/",
+        video_segment_detail,
+        name="video-segment-detail",
+    ),
     # ---------------------------------------------------------------------------------------
     # VIDEO SEGMENT VALIDATION API ENDPOINTS (Modern Media Framework - October 14, 2025)
     #
@@ -137,65 +173,68 @@ urlpatterns = [
     # Bulk: POST validate multiple segments
     # Status: GET/POST validation status for all segments
     # ---------------------------------------------------------------------------------------
-    
     # Single Segment Validation API
     # POST /api/media/videos/<int:pk>/segments/<int:segment_id>/validate/
     # Validates a single video segment
     # Body: { "is_validated": true, "notes": "..." }
-    path("media/videos/<int:pk>/segments/<int:segment_id>/validate/", video_segment_validate, name="video-segment-validate"),
-    
+    path(
+        "media/videos/<int:pk>/segments/<int:segment_id>/validate/",
+        video_segment_validate,
+        name="video-segment-validate",
+    ),
     # Bulk Segment Validation API
     # POST /api/media/videos/<int:pk>/segments/validate-bulk/
     # Validates multiple segments at once
     # Body: { "segment_ids": [1,2,3], "is_validated": true, "notes": "..." }
-    path("media/videos/<int:pk>/segments/validate-bulk/", video_segments_validate_bulk, name="video-segments-validate-bulk"),
-    
+    path(
+        "media/videos/<int:pk>/segments/validate-bulk/",
+        video_segments_validate_bulk,
+        name="video-segments-validate-bulk",
+    ),
     # Segment Validation Status API
     # GET /api/media/videos/<int:pk>/segments/validation-status/
     # Returns validation statistics for all segments
     # POST /api/media/videos/<int:pk>/segments/validation-status/
     # Marks all segments (or filtered by label) as validated
     # Body: { "label_name": "polyp", "notes": "..." }
-    path("media/videos/<int:pk>/segments/validation-status/", video_segments_validation_status, name="video-segments-validation-status"),
-
+    path(
+        "media/videos/<int:pk>/segments/validation-status/",
+        video_segments_validation_status,
+        name="video-segments-validation-status",
+    ),
     # ---------------------------------------------------------------------------------------
     # SENSITIVE METADATA ENDPOINTS (Modern Media Framework)
     # ---------------------------------------------------------------------------------------
-    
     # Video Sensitive Metadata (Resource-Scoped)
     # GET/PATCH /api/media/videos/<pk>/sensitive-metadata/
     # Get or update sensitive patient data for a video
     path(
         "media/videos/<int:pk>/sensitive-metadata/",
         video_sensitive_metadata,
-        name="video-sensitive-metadata"
+        name="video-sensitive-metadata",
     ),
-    
     # POST /api/media/videos/<pk>/sensitive-metadata/verify/
     # Update verification state (dob_verified, names_verified)
     path(
         "media/videos/<int:pk>/sensitive-metadata/verify/",
         video_sensitive_metadata_verify,
-        name="video-sensitive-metadata-verify"
+        name="video-sensitive-metadata-verify",
     ),
-    
     # PDF Sensitive Metadata (Resource-Scoped)
     # GET/PATCH /api/media/pdfs/<pk>/sensitive-metadata/
     # Get or update sensitive patient data for a PDF
     path(
         "media/pdfs/<int:pk>/sensitive-metadata/",
         pdf_sensitive_metadata,
-        name="pdf-sensitive-metadata"
+        name="pdf-sensitive-metadata",
     ),
-    
     # POST /api/media/pdfs/<pk>/sensitive-metadata/verify/
     # Update verification state (dob_verified, names_verified)
     path(
         "media/pdfs/<int:pk>/sensitive-metadata/verify/",
         pdf_sensitive_metadata_verify,
-        name="pdf-sensitive-metadata-verify"
+        name="pdf-sensitive-metadata-verify",
     ),
-    
     # List Endpoints (Collection-Level)
     # GET /api/media/sensitive-metadata/
     # List all sensitive metadata (combined PDFs and Videos)
@@ -203,25 +242,27 @@ urlpatterns = [
     path(
         "media/sensitive-metadata/",
         sensitive_metadata_list,
-        name="sensitive-metadata-list"
+        name="sensitive-metadata-list",
     ),
-    
     # GET /api/media/pdfs/sensitive-metadata/
     # List sensitive metadata for PDFs only
     # Replaces legacy /api/pdf/sensitivemeta/list/
     path(
         "media/pdfs/sensitive-metadata/",
         pdf_sensitive_metadata_list,
-        name="pdf-sensitive-metadata-list"
+        name="pdf-sensitive-metadata-list",
     ),
-
     # PDF media endpoints
     path("media/pdfs/", PdfMediaView.as_view(), name="pdf-list"),
     path("media/pdfs/<int:pk>/", PdfMediaView.as_view(), name="pdf-detail"),
-    path("media/pdfs/<int:pk>/stream/", PdfStreamView.as_view(), name="pdf-stream"),  # Support ?type=raw|anonymized params
+    path(
+        "media/pdfs/<int:pk>/stream/", PdfStreamView.as_view(), name="pdf-stream"
+    ),  # Support ?type=raw|anonymized params
     # PDF Re-import API endpoint (modern media framework)
     # POST /api/media/pdfs/<int:pk>/reimport/
     # Re-imports a PDF file to regenerate metadata when OCR failed or data is incomplete
-    path("media/pdfs/<int:pk>/reimport/", PdfReimportView.as_view(), name="pdf-reimport"),
+    path(
+        "media/pdfs/<int:pk>/reimport/", PdfReimportView.as_view(), name="pdf-reimport"
+    ),
 ]
-    # ---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------

endoreg_db/urls/root_urls.py

@@ -0,0 +1,29 @@
+# endoreg_db/urls/root_urls.py
+from django.contrib import admin
+from django.urls import path, include
+from django.http import HttpResponse
+from django.conf import settings
+from django.conf.urls.static import static
+
+def public_home(_request):
+    return HttpResponse("Public home – no login required.")
+
+urlpatterns = [
+    # Public landing page
+    path("", public_home, name="public_home"),
+
+    # Django admin (optional)
+    path("admin/", admin.site.urls),
+
+    # Mount ALL API routes under /api/
+    # This pulls the urlpatterns exported by endoreg_db/urls/__init__.py
+    path("api/", include("endoreg_db.urls")),
+
+    # Keycloak OIDC (mozilla-django-oidc provides /oidc/authenticate/ and /oidc/callback/)
+    path("oidc/", include("mozilla_django_oidc.urls")),
+]
+
+# Serve static/media in DEBUG at the root (NOT under /api/)
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

endoreg_db/utils/__init__.py

@@ -4,6 +4,7 @@
 
 # dataloader
 from endoreg_db.utils.video.ffmpeg_wrapper import assemble_video_from_frames, get_stream_info, transcode_video, transcode_videofile_if_required
+
 from .dataloader import load_model_data_from_yaml
 
 # dates
@@ -40,18 +41,23 @@ from .paths import data_paths
 
 # pydantic_models
 from .pydantic_models import DbConfig
+from .storage import (
+    delete_field_file,
+    ensure_local_file,
+    save_local_file,
+)
+from .storage import (
+    file_exists as storage_file_exists,
+)
 
 # validate_endo_roi
 from .validate_endo_roi import validate_endo_roi
+from .video import split_video
 
 # ffmpeg_wrapper
 from .video.ffmpeg_wrapper import (
     extract_frames,
 )
-from .video import (
-    split_video
-)
-
 
 # --- Exports ---
 
@@ -84,5 +90,9 @@ __all__ = [
     "transcode_video",
     "transcode_videofile_if_required",  # Added
     "extract_frames",  # Added
+    "split_video",
+    "delete_field_file",
+    "ensure_local_file",
+    "save_local_file",
+    "storage_file_exists",
 ]
-

endoreg_db/utils/ai/multilabel_classification_net.py

@@ -1,10 +1,22 @@
+import logging
+from pathlib import Path
+
 import torch
 from torchvision import models
 import torch.nn as nn
 from pytorch_lightning import LightningModule
 import numpy as np
+from safetensors.torch import load_file
 from sklearn.metrics import precision_score, recall_score, f1_score
 
+try:  # Torchvision >= 0.13 exposes explicit weight enums
+    from torchvision.models import EfficientNet_B4_Weights, RegNet_X_800MF_Weights
+except ImportError:  # pragma: no cover - compatibility with older torchvision
+    EfficientNet_B4_Weights = None
+    RegNet_X_800MF_Weights = None
+
+logger = logging.getLogger(__name__)
+
 METRICS_ON_STEP = False
 
 
@@ -41,6 +53,29 @@ def calculate_metrics(pred, target, threshold=0.5):
     }
 
 
+def _load_torchvision_backbone(factory, *, weights_enum=None, load_pretrained=False):
+    """Instantiate a torchvision model without triggering unwanted downloads."""
+    if weights_enum is not None:
+        try:
+            weights = weights_enum.DEFAULT if load_pretrained else None
+            return factory(weights=weights)
+        except (TypeError, AttributeError):
+            # Fall back to legacy keyword on older torchvision versions
+            pass
+
+    try:
+        return factory(pretrained=load_pretrained)
+    except TypeError:
+        # Newer torchvision versions removed the pretrained kwarg; call without hints
+        try:
+            return factory()
+        except Exception as exc:  # pragma: no cover - surfaced to caller for visibility
+            raise RuntimeError(
+                "Failed to instantiate torchvision backbone with load_pretrained="
+                f"{load_pretrained}."
+            ) from exc
+
+
 class MultiLabelClassificationNet(LightningModule):
     def __init__(
         self,
@@ -49,26 +84,40 @@ class MultiLabelClassificationNet(LightningModule):
         weight_decay=0.001,
         pos_weight=2,
         model_type="EfficientNetB4",
+        load_imagenet_weights: bool = False,
+        track_hparams: bool = True,
     ):
         super().__init__()
-        self.save_hyperparameters()
-        self.model_type = "RegNetX800MF"  # model_type
-        self.labels = labels
-        self.n_classes = len(labels)
-        self.val_preds = []
-        self.val_targets = []
+        if track_hparams:
+            self.save_hyperparameters()
+        if labels is None:
+            raise ValueError("labels must be provided to initialize MultiLabelClassificationNet")
+
+        self.model_type = model_type
+        self.labels = list(labels)
+        self.n_classes = len(self.labels)
+        self.val_preds: list[np.ndarray] = []
+        self.val_targets: list[np.ndarray] = []
         self.pos_weight = pos_weight
         self.weight_decay = weight_decay
         self.lr = lr
         self.sigm = nn.Sigmoid()
 
         if model_type == "EfficientNetB4":
-            self.model = models.efficientnet_b4(pretrained=True)
+            self.model = _load_torchvision_backbone(
+                models.efficientnet_b4,
+                weights_enum=EfficientNet_B4_Weights,
+                load_pretrained=load_imagenet_weights,
+            )
             num_ftrs = self.model.classifier[1].in_features
             self.model.classifier[1] = nn.Linear(num_ftrs, len(labels))
 
         elif model_type == "RegNetX800MF":
-            self.model = models.regnet_x_800mf(pretrained=True)
+            self.model = _load_torchvision_backbone(
+                models.regnet_x_800mf,
+                weights_enum=RegNet_X_800MF_Weights,
+                load_pretrained=load_imagenet_weights,
+            )
             num_ftrs = self.model.fc.in_features
             self.model.fc = nn.Linear(num_ftrs, len(labels))
 
@@ -78,10 +127,47 @@ class MultiLabelClassificationNet(LightningModule):
 
     @classmethod
     def load_from_checkpoint(cls, checkpoint_path, *args, **kwargs):
-        instance = super(MultiLabelClassificationNet, cls).load_from_checkpoint(
+        path = Path(checkpoint_path)
+        suffix = path.suffix.lower()
+
+        if suffix == ".safetensors":
+            map_location = kwargs.pop("map_location", "cpu")
+            strict = kwargs.pop("strict", True)
+            labels = kwargs.pop("labels", None)
+            if not labels:
+                raise ValueError("labels must be provided when loading .safetensors checkpoints")
+            model_type = kwargs.pop("model_type", None) or "EfficientNetB4"
+            load_imagenet = kwargs.pop("load_imagenet_weights", False)
+
+            device = torch.device(map_location) if map_location is not None else torch.device("cpu")
+            if isinstance(device, torch.device):
+                device_hint = f"{device.type}:{device.index}" if device.index is not None else device.type
+            else:
+                device_hint = device
+
+            state_dict = load_file(path, device=device_hint)
+
+            instance = cls(
+                labels=labels,
+                model_type=model_type,
+                load_imagenet_weights=load_imagenet,
+                track_hparams=False,
+                *args,
+                **kwargs,
+            )
+            missing, unexpected = instance.load_state_dict(state_dict, strict=strict)
+
+            if missing:
+                logger.warning("Missing parameters when loading %s: %s", path, missing)
+            if unexpected:
+                logger.warning("Unexpected parameters when loading %s: %s", path, unexpected)
+
+            instance.to(device)
+            return instance
+
+        return super(MultiLabelClassificationNet, cls).load_from_checkpoint(
             checkpoint_path, *args, **kwargs
         )
-        return instance
 
     def forward(self, x):  # pylint: disable=arguments-differ
         x = self.model(x)
@@ -113,18 +199,24 @@ class MultiLabelClassificationNet(LightningModule):
 
     def validation_epoch_end(self, _outputs):
         """Called at the end of validation to aggregate outputs"""
-        self.val_preds = np.concatenate([_ for _ in self.val_preds])
-        self.val_targets = np.concatenate([_ for _ in self.val_targets])
-
-        metrics = calculate_metrics(self.val_preds, self.val_targets, threshold=0.5)
-        for key, value in metrics.items():
-            value = value.tolist()
-            if isinstance(value, list):
-                for i, _value in enumerate(value):
+        val_preds_np = np.concatenate(self.val_preds)
+        val_targets_np = np.concatenate(self.val_targets)
+
+        metrics = calculate_metrics(val_preds_np, val_targets_np, threshold=0.5)
+        for key, metric_value in metrics.items():
+            if isinstance(metric_value, np.ndarray):
+                processed_value = metric_value.tolist()
+            elif isinstance(metric_value, (list, tuple)):
+                processed_value = list(metric_value)
+            else:
+                processed_value = float(metric_value)
+
+            if isinstance(processed_value, list):
+                for i, single_value in enumerate(processed_value):
                     name = "val/" + f"{key}/{self.labels[i]}"
                     self.log(
                         name,
-                        _value,
+                        float(single_value),
                         on_epoch=True,
                         on_step=METRICS_ON_STEP,
                         prog_bar=False,
@@ -132,7 +224,11 @@ class MultiLabelClassificationNet(LightningModule):
             else:
                 name = "val/" + f"{key}"
                 self.log(
-                    name, value, on_epoch=True, on_step=METRICS_ON_STEP, prog_bar=True
+                    name,
+                    float(processed_value),
+                    on_epoch=True,
+                    on_step=METRICS_ON_STEP,
+                    prog_bar=True,
                 )
 
         self.val_preds = []