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

endoreg_db/urls/report.py

@@ -1,48 +0,0 @@
-from django.urls import path
-from endoreg_db.views import (
-    ReportListView,
-    ReportWithSecureUrlView,
-    ReportFileMetadataView,
-)
-
-url_patterns = [        # ---------------------------------------------------------------------------------------
-        # REPORT SERVICE ENDPOINTS
-        #
-        # Neue API-Endpunkte für den Report-Service mit sicheren URLs
-        #
-        # Diese Endpunkte ermöglichen es dem Frontend (UniversalReportViewer), 
-        # Reports mit zeitlich begrenzten, sicheren URLs zu laden und anzuzeigen.
-        #
-        # Verwendung im Frontend:
-        #   - loadReportWithSecureUrl(reportId) 
-        #   - generateSecureUrl(reportId, fileType)
-        #   - validateCurrentUrl()
-        #
-        # ---------------------------------------------------------------------------------------
-
-        # API-Endpunkt für paginierte Report-Listen mit Filterung
-        # GET /api/reports/?page=1&page_size=20&status=pending&file_type=pdf&patient_name=John
-        # Lädt eine paginierte Liste aller Reports mit optionalen Filtern
-        path('reports/', 
-            ReportListView.as_view(), 
-            name='report_list'
-        ),
-
-        # API-Endpunkt für Reports mit automatischer sicherer URL-Generierung
-        # GET /api/reports/{report_id}/with-secure-url/
-        # Lädt Report-Daten inklusive Metadaten und generiert automatisch eine sichere URL
-        path(
-            'reports/<int:report_id>/with-secure-url/', 
-            ReportWithSecureUrlView.as_view(), 
-            name='report_with_secure_url'
-        ),
-
-        # API-Endpunkt für Report-Datei-Metadaten
-        # GET /api/reports/{report_id}/file-metadata/
-        # Gibt Datei-Metadaten zurück (Größe, Typ, Datum, etc.)
-        path(
-            'reports/<int:report_id>/file-metadata/', 
-            ReportFileMetadataView.as_view(), 
-            name='report_file_metadata'
-        ),
-]

endoreg_db/urls/video.py

@@ -1,61 +0,0 @@
-from django.urls import path
-
-from endoreg_db.views import (
-    SensitiveMetaDetailView,
-    VideoLabelView,
-    # Note: VideoStreamView moved to modern media framework. See: endoreg_db/urls/media.py
-    # Note: All Video Correction Views moved to modern media framework. See: endoreg_db/urls/media.py
-)
-
-url_patterns = [
-    # Video Label segments API endpoint
-    # GET /api/videos/<int:video_id>/labels/<str:label_name>/
-    # Retrieves time segments and frame predictions for a specific label on a video
-    path(
-        'videos/<int:video_id>/labels/<str:label_name>/', 
-        VideoLabelView.as_view(), 
-        name='video_label_segments'
-    ),
-    
-    # ---------------------------------------------------------------------------------------
-    # VIDEO STREAMING - MOVED TO MODERN MEDIA FRAMEWORK
-    #
-    # Video streaming endpoint has been migrated to the media framework
-    # as of October 14, 2025. Please use the new endpoints:
-    #
-    # OLD → NEW:
-    # GET /api/videostream/<pk>/              → GET /api/media/videos/<pk>/
-    # GET /api/videostream/<pk>/              → GET /api/media/videos/<pk>/stream/
-    #
-    # See: endoreg_db/urls/media.py for new URL registrations
-    # ---------------------------------------------------------------------------------------
-    
-    # Note: Video Re-import moved to modern media framework
-    # See: endoreg_db/urls/media.py - POST /api/media/videos/<int:pk>/reimport/
-    
-    # Video Sensitive Meta endpoints (for video anonymization)
-    # GET /api/video/sensitivemeta/<int:sensitive_meta_id>/
-    # PATCH /api/video/sensitivemeta/<int:sensitive_meta_id>/
-    path(
-        'video/sensitivemeta/<int:sensitive_meta_id>/', 
-        SensitiveMetaDetailView.as_view(), 
-        name='video_sensitive_meta_detail'
-    ),
-    
-    # ---------------------------------------------------------------------------------------
-    # VIDEO CORRECTION API ENDPOINTS - MOVED TO MODERN MEDIA FRAMEWORK
-    #
-    # All video correction endpoints have been migrated to the modern media framework
-    # as of October 14, 2025. Please use the new endpoints:
-    #
-    # OLD → NEW:
-    # GET  /api/video-metadata/<id>/              → GET  /api/media/videos/<pk>/metadata/
-    # GET  /api/video-processing-history/<id>/    → GET  /api/media/videos/<pk>/processing-history/
-    # POST /api/video-analyze/<id>/               → POST /api/media/videos/<pk>/analyze/
-    # POST /api/video-apply-mask/<id>/            → POST /api/media/videos/<pk>/apply-mask/
-    # POST /api/video-remove-frames/<id>/         → POST /api/media/videos/<pk>/remove-frames/
-    # POST /api/video-reprocess/<id>/             → POST /api/media/videos/<pk>/reprocess/
-    #
-    # See: endoreg_db/urls/media.py for new URL registrations
-    # ---------------------------------------------------------------------------------------
-]

endoreg_db/utils/case_generator/case_generator.py

@@ -1,159 +0,0 @@
-from endoreg_db.models import CaseTemplate, CaseTemplateRule, CaseTemplateRuleType
-from endoreg_db.case_generator.lab_sample_factory import LabSampleFactory
-
-DEFAULT_CASE_TEMPLATE_NAME = "pre_default_screening_colonoscopy"
-
-class CaseGenerator:
-    """
-    Provides methods to generate cases based on a template.
-    """
-
-    def __init__(self, template: CaseTemplate = None):
-        """
-        Initializes the CaseGenerator with a template.
-
-        Args:
-            template (CaseTemplate, optional): The template to use for case generation. Defaults to the predefined template.
-        """
-        self.template = template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
-        self.lab_sample_factory = LabSampleFactory()
-
-        # Define available rule types
-        rule_type_names = [
-            "create-object",
-            "set-field-default",
-            "set-field-by-distribution",
-            "set-field-by-value",
-            "set-field-single-choice",
-            "set-field-multiple-choice",
-        ]
-        self.available_rule_types = CaseTemplateRuleType.objects.filter(name__in=rule_type_names)
-
-    def _validate_rule_type(self, rule_type: CaseTemplateRuleType):
-        """
-        Validates if the rule type is supported.
-
-        Args:
-            rule_type (CaseTemplateRuleType): The rule type to validate.
-
-        Raises:
-            ValueError: If the rule type is not supported.
-        """
-        if rule_type not in self.available_rule_types:
-            raise ValueError(f"Rule type {rule_type} is not supported.")
-
-    def _apply_create_object(self, rule: CaseTemplateRule, parent=None):
-        """
-        Applies a create-object rule to generate a model instance.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Optional[Model]): The parent object for the rule.
-
-        Returns:
-            Model: The created model instance.
-        """
-        target_model = rule.get_target_model()
-        extra_params = rule.extra_parameters or {}
-        create_method_info = extra_params.get("create_method", {})
-
-        assert create_method_info, "Create method must be set for a create-object rule."
-
-        create_method = getattr(target_model, create_method_info["name"])
-        kwargs = create_method_info.get("kwargs", {})
-
-        if parent:
-            kwargs[rule.parent_field] = parent
-
-        target_instance = create_method(**kwargs)
-        target_instance.save()
-
-        for action in extra_params.get("actions", []):
-            action_method = getattr(target_instance, action["name"])
-            action_kwargs = action.get("kwargs", {})
-            action_method(**action_kwargs)
-
-        for chained_rule in rule.chained_rules.all():
-            self.apply_rule(chained_rule, parent=target_instance)
-
-        return target_instance
-
-    def _apply_set_field_by_distribution(self, rule: CaseTemplateRule, parent):
-        """
-        Applies a set-field-by-distribution rule.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Model): The parent object for the rule.
-
-        Returns:
-            Model: The updated parent object.
-        """
-        assert parent, "Parent must be provided for set-field-by-distribution rules."
-        assert rule.target_field, "Target field must be specified for the rule."
-
-        distribution = rule.get_distribution()
-        value = distribution.generate_value()
-
-        setattr(parent, rule.target_field, value)
-        parent.save()
-        return parent
-
-    def apply_rule(self, rule: CaseTemplateRule, parent=None):
-        """
-        Applies a rule based on its type to generate a case.
-
-        Args:
-            rule (CaseTemplateRule): The rule to apply.
-            parent (Optional[Model]): The parent object for the rule.
-
-        Returns:
-            Model: The case by applying the rule.
-        """
-        self._validate_rule_type(rule.rule_type)
-
-        if rule.rule_type.name == "create-object":
-            return self._apply_create_object(rule, parent)
-
-        if rule.rule_type.name == "set-field-by-distribution":
-            return self._apply_set_field_by_distribution(rule, parent)
-
-        raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
-
-    def generate_case(self, case_template: CaseTemplate = None):
-        """
-        Generates a case based on the provided or default template.
-
-        Args:
-            case_template (CaseTemplate, optional): The template to use for case generation. Defaults to None.
-
-        Returns:
-            Tuple[Model, Model]: The generated patient and medication schedule.
-        """
-        case_template = case_template or CaseTemplate.objects.get(name=DEFAULT_CASE_TEMPLATE_NAME)
-
-        create_patient_rule = case_template.get_create_patient_rule()
-        patient = self.apply_rule(create_patient_rule)
-
-        medication_schedule_rule = case_template.get_create_patient_medication_schedule_rule()
-        medication_schedule = self.apply_rule(medication_schedule_rule, parent=patient)
-
-        return patient, medication_schedule
-
-        # if not create_new_patient:
-        #     raise NotImplementedError("Only new patients are supported at the moment.")
-        # else:
-        #     # TODO Implement patient rules
-        #     patient_rules = None # all rules of type "create_patient"
-        #     patient = self.generate_patient(patient_rules)
-
-        # # Generate case based on template
-        # rules = self.template.get_rules()
-        # chained_rules = set()
-
-        # for rule in rules:
-        #     rule_chain = rule.get_all_downward_chained_rules()
-        #     chained_rules.add(rule)
-        #     chained_rules.update(rule_chain)
-
-        # return chained_rules

endoreg_db/utils/case_generator/utils.py

@@ -1,30 +0,0 @@
-from endoreg_db.models import CaseTemplate
-from endoreg_db.case_generator.case_generator import CaseGenerator
-
-# TEMPLATE_NAME = "pre_endo-anticoagulation-af-low_risk"
-TEMPLATE_NAME = "pre_default_screening_colonoscopy"
-
-def fetch_template(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseTemplate:
-    """
-    Fetches a CaseTemplate by name.
-
-    Args:
-        template_name (str): The name of the template to fetch. Defaults to DEFAULT_TEMPLATE_NAME.
-
-    Returns:
-        CaseTemplate: The fetched CaseTemplate instance.
-    """
-    return CaseTemplate.objects.get(name=template_name)
-
-def initialize_case_generator(template_name: str = DEFAULT_TEMPLATE_NAME) -> CaseGenerator:
-    """
-    Initializes a CaseGenerator with the specified template.
-
-    Args:
-        template_name (str): The name of the template to use. Defaults to DEFAULT_TEMPLATE_NAME.
-
-    Returns:
-        CaseGenerator: An instance of CaseGenerator initialized with the template.
-    """
-    template = fetch_template(template_name)
-    return CaseGenerator(template)

endoreg_db/utils/requirement_operator_logic/model_evaluators.py

@@ -1,368 +0,0 @@
-import datetime # Add import
-from datetime import timedelta # Add import
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from endoreg_db.utils.links.requirement_link import RequirementLinks
-    from endoreg_db.models.requirement.requirement import Requirement
-    # from endoreg_db.models import Unit # Potentially needed for dynamic unit handling
-
-
-# Helper function to check if a date is within the timeframe specified by a Requirement
-def _is_date_in_timeframe(date_to_check: datetime.date | None, requirement: "Requirement") -> bool:
-    """
-    Checks if a given date falls within the timeframe specified by a Requirement.
-
-    The timeframe is defined by `numeric_value_min` and `numeric_value_max` on the
-    Requirement, interpreted relative to the current date.
-
-    Currently, this function only supports timeframes specified in "days".
-    If the Requirement's unit is not "days", a NotImplementedError will be raised.
-
-    Args:
-        date_to_check: The date to evaluate. If None, returns False.
-        requirement: The Requirement instance containing timeframe definitions
-                     (unit, numeric_value_min, numeric_value_max).
-
-    Returns:
-        True if the date_to_check is within the defined timeframe, False otherwise.
-        Returns False if date_to_check is None or if the requirement lacks
-        necessary timeframe information (unit, min/max values).
-
-    Raises:
-        NotImplementedError: If the requirement.unit.name is not 'days' (case-insensitive).
-    """
-    if date_to_check is None:
-        return False
-    if not requirement.unit or requirement.numeric_value_min is None or requirement.numeric_value_max is None:
-        return False # Not enough information for timeframe evaluation
-
-    # For now, primarily supporting 'days'. Extend if other units are common.
-    if requirement.unit.name.lower() != "days":
-        raise NotImplementedError(
-            f"Timeframe unit '{requirement.unit.name}' is not supported. "
-            "Currently, only 'days' is implemented for timeframe checks."
-        )
-
-    today = datetime.date.today()
-    # numeric_value_min is typically negative for "days ago" (e.g., -30 for 30 days ago)
-    # numeric_value_max is typically 0 for "today"
-    timeframe_start_delta = int(requirement.numeric_value_min)
-    timeframe_end_delta = int(requirement.numeric_value_max)
-
-    start_date_bound = today + timedelta(days=timeframe_start_delta)
-    end_date_bound = today + timedelta(days=timeframe_end_delta)
-
-    return start_date_bound <= date_to_check <= end_date_bound
-
-
-def _evaluate_models_match_any(
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks",
-    **kwargs
-) -> bool:
-    """
-    Checks if the requirement_links matches any of the input_links.
-    
-    Args:
-        requirement_links: The reference set of requirement links to compare against.
-        input_links: The aggregated requirement links from the input objects.
-    
-    Returns:
-        True if the input set of requirement links matches according to requirement_links.match_any; otherwise, False.
-    """
-    return requirement_links.match_any(input_links)
-
-
-def _evaluate_models_match_any_in_timeframe(
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks",
-    requirement: "Requirement", # Explicitly pass Requirement
-    **kwargs # Keep for consistency, though 'requirement' is the main one used here
-) -> bool:
-    """
-    Checks if any relevant model in input_links matches a model specified in
-    requirement_links AND falls within the timeframe defined on the Requirement.
-
-    Currently focuses on PatientEvent instances and their dates.
-    """
-    active_req_links_dict = requirement_links.active()
-    if not active_req_links_dict:
-        # If the Requirement itself doesn't specify any models to match (e.g., requirement.events is empty),
-        # then it's vacuously true that "any" of these (non-existent) required models are matched.
-        # The timeframe aspect becomes irrelevant if no specific models are being checked.
-        return True
-
-    # --- Handle PatientEvents ---
-    # Check if the requirement is concerned with events
-    if requirement_links.events: # This list contains Event model instances
-        required_event_models = set(requirement_links.events) # Target Event models from the Requirement
-        
-        # input_links.patient_events contains PatientEvent instances provided as input
-        for patient_event_instance in input_links.patient_events:
-            # Check if the event of the current PatientEvent instance is one of the target events
-            if patient_event_instance.event in required_event_models:
-                # If it is, check if this PatientEvent's date is within the timeframe
-                if _is_date_in_timeframe(patient_event_instance.date, requirement):
-                    return True # Found a matching event within the timeframe
-
-    # --- Handle Other Model Types (Example: PatientLabValue) ---
-    # if requirement_links.lab_values:
-    #     required_lab_value_models = set(requirement_links.lab_values)
-    #     for plv_instance in input_links.patient_lab_values:
-    #         if plv_instance.lab_value in required_lab_value_models:
-    #             date_to_check = None
-    #             if hasattr(plv_instance, 'date_time_value') and plv_instance.date_time_value:
-    #                 date_to_check = plv_instance.date_time_value.date()
-    #             elif hasattr(plv_instance, 'date') and plv_instance.date: # If it had a simple date field
-    #                 date_to_check = plv_instance.date
-    #
-    #             if _is_date_in_timeframe(date_to_check, requirement):
-    #                 return True
-    
-    # If the code reaches here, no matching model within the timeframe was found
-    # for any of the categories specified in requirement_links.
-    return False
-
-
-def _evaluate_models_match_all(
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks",
-    **kwargs
-) -> bool:
-    """
-    Evaluates if all active links in requirement_links are present in input_links.
-
-    For each category of links in requirement_links (e.g., diseases, examinations),
-    all items specified in that category in requirement_links must be present in the
-    corresponding category in input_links.
-
-    Args:
-        requirement_links: The RequirementLinks object from the Requirement model.
-        input_links: The aggregated RequirementLinks object from the input arguments.
-        **kwargs: Additional keyword arguments (currently unused).
-
-    Returns:
-        True if all specified items in requirement_links are found in input_links,
-        False otherwise.
-    """
-    active_req_links = requirement_links.active() # Get dict of non-empty lists from requirement
-
-    if not active_req_links: # If the requirement specifies no actual items to link
-        return True # Vacuously true, as there are no conditions to fail
-
-    for link_category_name, req_items_list in active_req_links.items():
-        input_items_list = getattr(input_links, link_category_name, [])
-        
-        try:
-            set_input_items = set(input_items_list)
-            set_req_items = set(req_items_list)
-        except TypeError: 
-            for req_item in req_items_list:
-                if req_item not in input_items_list:
-                    return False 
-            continue 
-
-        if not set_req_items.issubset(set_input_items):
-            return False 
-            
-    return True
-
-def _evaluate_age_gte(
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks",
-    requirement: "Requirement",
-    **kwargs
-) -> bool:
-    """
-    Checks if any patient in the input has an age greater than or equal to the requirement's numeric_value.
-    
-    Args:
-        requirement_links: The RequirementLinks object from the Requirement model (not used for age checks).
-        input_links: The aggregated RequirementLinks object from the input arguments.
-        requirement: The Requirement instance containing the minimum age in numeric_value.
-        **kwargs: Additional keyword arguments, should contain 'original_input_args' with the original Patient instances.
-    
-    Returns:
-        True if any patient in the input has an age >= requirement.numeric_value, False otherwise.
-    """
-    from endoreg_db.models.administration.person.patient import Patient
-    import logging
-    
-    logger = logging.getLogger(__name__)
-    
-    if requirement.numeric_value is None:
-        logger.debug("age_gte: requirement.numeric_value is None, returning False")
-        return False  # Cannot evaluate without a minimum age requirement
-    
-    min_age = requirement.numeric_value
-    logger.debug(f"age_gte: Checking if any patient has age >= {min_age}")
-    
-    # Check if we have Patient instances in the original_input_args
-    original_args = kwargs.get('original_input_args', [])
-    logger.debug(f"age_gte: Found {len(original_args)} original input arguments: {[type(arg).__name__ for arg in original_args]}")
-    
-    for i, arg in enumerate(original_args):
-        logger.debug(f"age_gte: Checking argument {i}: {type(arg).__name__}")
-        if isinstance(arg, Patient):
-            patient_age = arg.age()
-            logger.debug(f"age_gte: Patient {arg} has age {patient_age}, comparing with min_age {min_age}")
-            if patient_age is not None and patient_age >= min_age:
-                logger.debug(f"age_gte: Patient age {patient_age} >= {min_age}, returning True")
-                return True
-            else:
-                logger.debug(f"age_gte: Patient age {patient_age} < {min_age} or is None")
-        # Handle QuerySets of patients
-        elif hasattr(arg, 'model') and issubclass(arg.model, Patient):
-            logger.debug(f"age_gte: Found Patient QuerySet with {arg.count()} patients")
-            for patient in arg:
-                patient_age = patient.age()
-                logger.debug(f"age_gte: Patient {patient} has age {patient_age}, comparing with min_age {min_age}")
-                if patient_age is not None and patient_age >= min_age:
-                    logger.debug(f"age_gte: Patient age {patient_age} >= {min_age}, returning True")
-                    return True
-        else:
-            logger.debug(f"age_gte: Argument {i} is not a Patient or Patient QuerySet: {type(arg)}")
-    
-    logger.debug(f"age_gte: No patient found with age >= {min_age}, returning False")
-    return False
-
-
-def _evaluate_age_lte(
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks", 
-    requirement: "Requirement",
-    **kwargs
-) -> bool:
-    """
-    Checks if any patient in the input has an age less than or equal to the requirement's numeric_value.
-    
-    Args:
-        requirement_links: The RequirementLinks object from the Requirement model (not used for age checks).
-        input_links: The aggregated RequirementLinks object from the input arguments.
-        requirement: The Requirement instance containing the maximum age in numeric_value.
-        **kwargs: Additional keyword arguments, should contain 'original_input_args' with the original Patient instances.
-    
-    Returns:
-        True if any patient in the input has an age <= requirement.numeric_value, False otherwise.
-    """
-    from endoreg_db.models.administration.person.patient import Patient
-    
-    if requirement.numeric_value is None:
-        return False  # Cannot evaluate without a maximum age requirement
-    
-    max_age = requirement.numeric_value
-    
-    # Check if we have Patient instances in the original_input_args
-    original_args = kwargs.get('original_input_args', [])
-    for arg in original_args:
-        if isinstance(arg, Patient):
-            patient_age = arg.age()
-            if patient_age is not None and patient_age <= max_age:
-                return True
-        # Handle QuerySets of patients
-        elif hasattr(arg, 'model') and issubclass(arg.model, Patient):
-            for patient in arg:
-                patient_age = patient.age()
-                if patient_age is not None and patient_age <= max_age:
-                    return True
-    
-    return False
-
-
-def dispatch_operator_evaluation(
-    operator_name: str,
-    requirement_links: "RequirementLinks",
-    input_links: "RequirementLinks",
-    **kwargs
-) -> bool:
-    """
-    Dispatches the evaluation to the appropriate function based on the operator name.
-    
-    Args:
-        operator_name: The name of the operator to evaluate.
-        requirement_links: The RequirementLinks object from the Requirement model.
-        input_links: The aggregated RequirementLinks object from the input arguments.
-        **kwargs: Additional keyword arguments for specific operator logic.
-                    For lab value operators, this includes 'requirement' (the Requirement model instance).
-
-    Returns:
-        True if the condition defined by the operator is met, False otherwise.
-        
-    Raises:
-        NotImplementedError: If the evaluation logic for the operator's name is not implemented.
-    """
-    from .lab_value_operators import LAB_VALUE_OPERATOR_FUNCTIONS
-    from endoreg_db.models.requirement.requirement import Requirement # Runtime import for isinstance
-
-    eval_func = None
-    requirement = kwargs.get("requirement") # Get requirement for operators that need it
-
-    if operator_name == "models_match_any":
-        eval_func = _evaluate_models_match_any
-        return eval_func(
-            requirement_links=requirement_links,
-            input_links=input_links,
-            **kwargs
-        )
-    elif operator_name == "models_match_all":
-        eval_func = _evaluate_models_match_all
-        return eval_func(
-            requirement_links=requirement_links,
-            input_links=input_links,
-            **kwargs
-        )
-    elif operator_name == "models_match_any_in_timeframe":
-        # 'requirement' is already extracted from kwargs via requirement = kwargs.get("requirement")
-        if not isinstance(requirement, Requirement): # Ensure requirement is present and correct type
-            raise ValueError("models_match_any_in_timeframe operator requires a valid 'requirement' instance in kwargs.")
-        
-        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice,
-        # as it's already an explicit parameter for _evaluate_models_match_any_in_timeframe.
-        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
-        
-        eval_func = _evaluate_models_match_any_in_timeframe
-        return eval_func(
-            requirement_links=requirement_links,
-            input_links=input_links,
-            requirement=requirement, # Pass the requirement instance explicitly
-            **kwargs_for_eval      # Pass the remaining kwargs
-        )
-    elif operator_name in LAB_VALUE_OPERATOR_FUNCTIONS:
-        if not isinstance(requirement, Requirement): # Ensure requirement is present and correct type
-            raise ValueError(f"Lab value operator \'{operator_name}\' requires a valid 'requirement' instance in kwargs.")
-        
-        eval_func = LAB_VALUE_OPERATOR_FUNCTIONS[operator_name]
-        return eval_func(
-            input_links=input_links,
-            requirement=requirement, 
-            operator_kwargs=kwargs
-        )
-    elif operator_name == "age_gte":
-        if not isinstance(requirement, Requirement):
-            raise ValueError("age_gte operator requires a valid 'requirement' instance in kwargs.")
-        
-        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice
-        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
-        
-        return _evaluate_age_gte(
-            requirement_links=requirement_links,
-            input_links=input_links,
-            requirement=requirement,
-            **kwargs_for_eval
-        )
-    elif operator_name == "age_lte":
-        if not isinstance(requirement, Requirement):
-            raise ValueError("age_lte operator requires a valid 'requirement' instance in kwargs.")
-        
-        # Create a new kwargs dict for the call, excluding 'requirement' to avoid passing it twice
-        kwargs_for_eval = {k: v for k, v in kwargs.items() if k != 'requirement'}
-        
-        return _evaluate_age_lte(
-            requirement_links=requirement_links,
-            input_links=input_links,
-            requirement=requirement,
-            **kwargs_for_eval
-        )
-    else:
-        raise NotImplementedError(f"Evaluation logic for operator '{operator_name}' is not implemented.")

endoreg_db/views/label/__init__.py

@@ -1,5 +0,0 @@
-from .label import LabelViewSet
-
-__all__ = [
-    "LabelViewSet",
-]