rapidata 1.8.3__py3-none-any.whl → 2.44.4__py3-none-any.whl

rapidata/rapidata_client/simple_builders/simple_free_text_builders.py

@@ -1,180 +0,0 @@
-from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
-from rapidata.rapidata_client.selection.base_selection import Selection
-from rapidata.rapidata_client.workflow import FreeTextWorkflow
-from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
-from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
-from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.assets import MediaAsset, TextAsset, BaseAsset
-from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
-from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
-
-class FreeTextOrderBuilder:
-    def __init__(self, 
-                 name: str, 
-                 question: str, 
-                 media_assets: list[BaseAsset], 
-                 openapi_service: OpenAPIService, 
-                 time_effort: int):
-        self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
-        self._question = question
-        self._media_assets = media_assets
-        self._referee = NaiveReferee()
-        self._settings = Settings()
-        self._filters: list[Filter] = []
-        self._time_effort = time_effort
-
-    def responses(self, responses_required: int) -> 'FreeTextOrderBuilder':
-        """Set the number of responses required per datapoint for the free text order. Will default to 10."""
-        self._referee = NaiveReferee(responses=responses_required)
-        return self
-    
-    def minimum_characters(self, minimum_characters: int) -> 'FreeTextOrderBuilder':
-        """Set the minimum number of characters for the free text."""
-        self._settings.free_text_minimum_characters(minimum_characters)
-        return self
-    
-    def countries(self, country_codes: list[str]) -> 'FreeTextOrderBuilder':
-        """Set the countries where order will be shown as country codes."""
-        self._filters.append(CountryFilter(country_codes))
-        return self
-    
-    def languages(self, language_codes: list[str]) -> 'FreeTextOrderBuilder':
-        """Set the languages where order will be shown as language codes."""
-        self._filters.append(LanguageFilter(language_codes))
-        return self
-    
-    def translation(self, disable: bool = False, show_both: bool = False) -> 'FreeTextOrderBuilder':
-        """Disable the translation of the order.
-        Only the question will be translated.
-        
-        Args:
-            disable (bool): Whether to disable the translation. Defaults to False.
-            show_both (bool): Whether to show the original text alongside the translation. Defaults to False.
-                ATTENTION: this can lead to cluttering of the UI if the texts are long, leading to bad results."""
-
-        if not isinstance(disable, bool) or not isinstance(show_both, bool):
-            raise ValueError("disable and show_both must be booleans.")
-        
-        if disable and show_both:
-            raise ValueError("You can't disable the translation and show both at the same time.")
-        
-        if show_both:
-            self._settings.translation_behaviour(TranslationBehaviour.BOTH)
-            return self
-        
-        if disable:
-            self._settings.translation_behaviour(TranslationBehaviour.ONLY_ORIGINAL)
-
-        else:
-            self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
-
-        return self
-
-    def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
-        """Run the free text order.
-        
-        Args:
-            submit (bool): Whether to submit the order. Defaults to True. \
-                Set this to False if you first want to see the order on your dashboard before running it.
-            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
-            
-        Returns:
-            RapidataOrder: The created free text order."""
-        
-        if MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort < 1:
-            raise ValueError(f"The Labelers only have {MAX_TIME_IN_SECONDS_FOR_ONE_SESSION} seconds to do the task. \
-                             Your taks is too complex. Try to break it down into simpler tasks.")
-
-        selection: list[Selection] = [LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort)]
-
-        order = (self._order_builder
-            .workflow(
-                FreeTextWorkflow(
-                    question=self._question
-                )
-            )
-            .referee(self._referee)
-            .media(self._media_assets)
-            .selections(selection)
-            .settings(self._settings)
-            .filters(self._filters)
-            .create(submit=submit, disable_link=disable_link))
-
-        return order 
-
-
-class FreeTextMediaBuilder:
-    def __init__(self, name: str, question: str, openapi_service: OpenAPIService):
-        self._openapi_service = openapi_service
-        self._name = name
-        self._question = question
-        self._media_assets: list[BaseAsset] = []
-        self._time_effort = 20
-
-    def media(self, media_paths: list[str], time_effort: int = 20) -> FreeTextOrderBuilder:
-        """Set the media assets for the free text order by providing the local paths to the files or a link.
-
-        Args:
-            media_paths (list[str]): Either a local file path or a link.
-            time_effort (int): Estimated time in seconds to solve one free text task for the first time. Defaults to 20.
-            
-        Returns:
-            FreeTextOrderBuilder: The free text order builder instance.
-        
-        Raises:
-            ValueError: If the media paths are not a list of strings."""
-        
-        if not isinstance(media_paths, list) or not all(isinstance(path, str) for path in media_paths):
-            raise ValueError("Media paths must be a list of strings, the strings being file paths or image links.")
-        
-        invalid_paths: list[str] = []
-        for path in media_paths:
-            try:
-                self._media_assets.append(MediaAsset(path))
-            except FileNotFoundError:
-                invalid_paths.append(path)
-
-        if invalid_paths:
-            raise FileNotFoundError(f"Could not find the following files: {invalid_paths}")
-        
-        self._time_effort = time_effort
-        return self._build()
-    
-    def text(self, texts: list[str], time_effort: int = 20) -> FreeTextOrderBuilder:
-        """Set the text assets for the free text order by.
-
-        Args:
-            texts (list[str]): The texts to be shown.
-            time_effort (int): Estimated time in seconds to solve one free text task for the first time. Defaults to 20.
-            
-        Returns:
-            FreeTextOrderBuilder: The free text order builder instance."""
-        for text in texts:
-            self._media_assets.append(TextAsset(text))
-        self._time_effort = time_effort
-        return self._build()
-
-    def _build(self) -> FreeTextOrderBuilder:
-        if not self._media_assets:
-            raise ValueError("Please provide either a text or an media to be shown with the question")
-        return FreeTextOrderBuilder(self._name, self._question, self._media_assets, openapi_service=self._openapi_service, time_effort=self._time_effort)
-
-
-class FreeTextQuestionBuilder:
-    def __init__(self, name: str, openapi_service: OpenAPIService):
-        self._openapi_service = openapi_service
-        self._name = name
-        self._question = None
-
-    def question(self, question: str) -> FreeTextMediaBuilder:
-        """Set the question for the free text order."""
-        self._question = question
-        return self._build()
-
-    def _build(self) -> FreeTextMediaBuilder:
-        if self._question is None:
-            raise ValueError("Question is required")
-        return FreeTextMediaBuilder(self._name, self._question, self._openapi_service)

rapidata/rapidata_client/simple_builders/simple_transcription_builders.py

@@ -1,194 +0,0 @@
-from rapidata.constants import MAX_TIME_IN_SECONDS_FOR_ONE_SESSION
-from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
-from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
-from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
-from rapidata.rapidata_client.selection.base_selection import Selection
-from rapidata.rapidata_client.workflow import TranscriptionWorkflow
-from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
-from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
-from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.assets import MediaAsset, BaseAsset
-from rapidata.rapidata_client.filter import Filter, CountryFilter, LanguageFilter
-from rapidata.rapidata_client.metadata import TranscriptionMetadata
-from rapidata.rapidata_client.settings import Settings, TranslationBehaviour
-
-class TranscriptionOrderBuilder:
-    def __init__(self, 
-                 name: str, 
-                 instruction: str, 
-                 media_assets: list[BaseAsset], 
-                 transcription_texts: list[TranscriptionMetadata],
-                 openapi_service: OpenAPIService, 
-                 time_effort: int):
-        self._order_builder = RapidataOrderBuilder(name=name, openapi_service=openapi_service)
-        self._instruction = instruction
-        self._media_assets = media_assets
-        self._transcription_texts = transcription_texts
-        self._validation_set_id = None
-        self._referee = NaiveReferee()
-        self._settings = Settings()
-        self._filters: list[Filter] = []
-        self._time_effort = time_effort
-
-    def responses(self, responses_required: int) -> 'TranscriptionOrderBuilder':
-        """Set the number of responses required per datapoint for the transcription order. Will default to 10."""
-        self._referee = NaiveReferee(responses=responses_required)
-        return self
-
-    def validation_set(self, validation_set_id: str) -> 'TranscriptionOrderBuilder':
-        """Set the validation set for the transcription order."""
-        self._validation_set_id = validation_set_id
-        return self
-    
-    def countries(self, country_codes: list[str]) -> 'TranscriptionOrderBuilder':
-        """Set the countries where order will be shown as country codes."""
-        self._filters.append(CountryFilter(country_codes))
-        return self
-    
-    def languages(self, language_codes: list[str]) -> 'TranscriptionOrderBuilder':
-        """Set the languages where order will be shown as language codes."""
-        self._filters.append(LanguageFilter(language_codes))
-        return self
-    
-    def wait_for_video_to_finish(self, offset: int = 0) -> 'TranscriptionOrderBuilder':
-        """Allows labeler to only answer once the video has finished playing.
-        The offset gets added on top. Can be negative to allow answers before the video ends."""
-        self._settings.play_video_until_the_end(offset)
-        return self
-    
-    def translation(self, disable: bool = False, show_both: bool = False) -> 'TranscriptionOrderBuilder':
-        """Disable the translation of the order.
-        Only the instruction will be translated.
-        
-        Args:
-            disable (bool): Whether to disable the translation. Defaults to False.
-            show_both (bool): Whether to show the original text alongside the translation. Defaults to False.
-                ATTENTION: this can lead to cluttering of the UI if the texts are long, leading to bad results."""
-
-        if not isinstance(disable, bool) or not isinstance(show_both, bool):
-            raise ValueError("disable and show_both must be booleans.")
-        
-        if disable and show_both:
-            raise ValueError("You can't disable the translation and show both at the same time.")
-        
-        if show_both:
-            self._settings.translation_behaviour(TranslationBehaviour.BOTH)
-            return self
-        
-        if disable:
-            self._settings.translation_behaviour(TranslationBehaviour.ONLY_ORIGINAL)
-
-        else:
-            self._settings.translation_behaviour(TranslationBehaviour.ONLY_TRANSLATED)
-
-        return self
-
-    def run(self, submit: bool = True, disable_link: bool = False) -> 'RapidataOrder':
-        """Run the transcription order.
-        
-        Args:
-            submit (bool): Whether to submit the order. Defaults to True. \
-                Set this to False if you first want to see the order on your dashboard before running it.
-            disable_link (bool): Whether to disable the printing of the link to the order. Defaults to False.
-            
-        Returns:
-            RapidataOrder: The created transcription order."""
-        
-        if (self._validation_set_id and MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1 < 1) or (MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort < 1):
-            raise ValueError(f"The Labelers only have {MAX_TIME_IN_SECONDS_FOR_ONE_SESSION} seconds to do the task. \
-                             Your taks is too complex. Try to break it down into simpler tasks.\
-                             {'Alternatively remove the validation task' if self._validation_set_id else ''}")
-
-        selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), 
-                                       LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort - 1)] 
-                     if self._validation_set_id 
-                     else [LabelingSelection(amount=MAX_TIME_IN_SECONDS_FOR_ONE_SESSION//self._time_effort)])
-
-        order = (self._order_builder
-            .workflow(
-                TranscriptionWorkflow(
-                    instruction=self._instruction
-                )
-            )
-            .referee(self._referee)
-            .media(self._media_assets, metadata=self._transcription_texts)
-            .selections(selection)
-            .settings(self._settings)
-            .filters(self._filters)
-            .create(submit=submit, disable_link=disable_link))
-
-        return order 
-
-
-class TranscriptionMediaBuilder:
-    def __init__(self, name: str, instruction: str, openapi_service: OpenAPIService):
-        self._openapi_service = openapi_service
-        self._name = name
-        self._instruction = instruction
-        self._media_assets: list[BaseAsset] = []
-        self._transcription_texts: list[TranscriptionMetadata] = []
-        self._time_effort = 20
-
-    def media(self, media_paths: list[str], transcription_texts: list[str], time_effort: int = 20) -> TranscriptionOrderBuilder:
-        """Set the media assets for the transcription order by providing the local paths to the audio / video files.
-
-        Args:
-            media_paths (list[str]): A local file path.
-            time_effort (int): Estimated time in seconds to solve one transcription task for the first time. Defaults to 20.
-            
-        Returns:
-            TranscriptionOrderBuilder: The transcription order builder instance.
-        
-        Raises:
-            ValueError: If the media paths are not a list of strings."""
-        
-        if not isinstance(media_paths, list) or not all(isinstance(path, str) for path in media_paths):
-            raise ValueError("Media paths must be a list of strings, the strings being file paths.")
-        
-        if not isinstance(transcription_texts, list) or not all(isinstance(text, str) for text in transcription_texts):
-            raise ValueError("Transcription texts must be a list of strings.")
-        
-        if not len(media_paths) == len(transcription_texts):
-            raise ValueError("The number of media paths and transcription texts must be the same.")
-
-        invalid_paths: list[str] = []
-        for path in media_paths:
-            try:
-                self._media_assets.append(MediaAsset(path))
-            except FileNotFoundError:
-                invalid_paths.append(path)
-
-        if invalid_paths:
-            raise FileNotFoundError(f"Could not find the following files: {invalid_paths}")
-        
-        self._transcription_texts = [TranscriptionMetadata(text) for text in transcription_texts]
-
-        self._time_effort = time_effort
-        return self._build()
-
-    def _build(self) -> TranscriptionOrderBuilder:
-        if not self._media_assets:
-            raise ValueError("Please provide either a text or an media to be shown with the question")
-        return TranscriptionOrderBuilder(self._name, 
-                                         self._instruction, 
-                                         self._media_assets, 
-                                         self._transcription_texts, 
-                                         openapi_service=self._openapi_service, 
-                                         time_effort=self._time_effort)
-
-
-class TranscriptionInstructionBuilder:
-    def __init__(self, name: str, openapi_service: OpenAPIService):
-        self._openapi_service = openapi_service
-        self._name = name
-        self._instruction = None
-
-    def instruction(self, instruction: str) -> TranscriptionMediaBuilder:
-        """Set the instruction for the transcription order."""
-        self._instruction = instruction
-        return self._build()
-
-    def _build(self) -> TranscriptionMediaBuilder:
-        if self._instruction is None:
-            raise ValueError("Instruction is required")
-        return TranscriptionMediaBuilder(self._name, self._instruction, self._openapi_service)

rapidata/rapidata_client/workflow/base_workflow.py

@@ -1,42 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
-from rapidata.api_client.models.compare_workflow_model import CompareWorkflowModel
-from rapidata.rapidata_client.settings import Settings
-from rapidata.rapidata_client.referee.base_referee import Referee
-
-
-class Workflow(ABC):
-
-    def __init__(self, type: str):
-        self._type = type
-        self._target_country_codes: list[str] = []
-        self._feature_flags: Settings = Settings()
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "_t": self._type,
-            "referee": self._referee.to_dict(),
-            "targetCountryCodes": self._target_country_codes,
-            "featureFlags": self._feature_flags.to_list(),
-        }
-
-    @abstractmethod
-    def to_model(
-        self,
-    ) -> SimpleWorkflowModel | CompareWorkflowModel | EvaluationWorkflowModel:
-        pass
-
-    def referee(self, referee: Referee):
-        self._referee = referee
-        return self
-
-    def target_country_codes(self, target_country_codes: list[str]):
-        self._target_country_codes = target_country_codes
-        return self
-
-    def feature_flags(self, feature_flags: Settings):
-        self._feature_flags = feature_flags
-        return self

rapidata/rapidata_client/workflow/classify_workflow.py

@@ -1,49 +0,0 @@
-from typing import Any
-from rapidata.api_client.models.attach_category_rapid_blueprint import AttachCategoryRapidBlueprint
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.rapidata_client.workflow import Workflow
-
-
-class ClassifyWorkflow(Workflow):
-    """
-    A workflow for classification tasks.
-
-    This class represents a classification workflow where a question is presented
-    along with a list of possible options for classification.
-
-    Args:
-        question (str): The classification question to be presented.
-        options (list[str]): A list of possible classification options.
-
-    Attributes:
-        _question (str): The classification question.
-        _options (list[str]): The list of classification options.
-    """
-
-    def __init__(self, question: str, options: list[str]):
-        super().__init__(type="SimpleWorkflowConfig")
-        self._question = question
-        self._options = options
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            **super().to_dict(),
-            "blueprint": {
-                "_t": "ClassifyBlueprint",
-                "title": self._question,
-                "possibleCategories": self._options,
-            }
-        }
-
-    def to_model(self) -> SimpleWorkflowModel:
-        blueprint = AttachCategoryRapidBlueprint(
-            _t="ClassifyBlueprint",
-            title=self._question,
-            possibleCategories=self._options,
-        )
-
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint),
-        )

rapidata/rapidata_client/workflow/compare_workflow.py

@@ -1,47 +0,0 @@
-from typing import Any
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.rapidata_client.workflow import Workflow
-from rapidata.api_client.models.compare_rapid_blueprint import CompareRapidBlueprint
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-
-
-class CompareWorkflow(Workflow):
-    """
-    A workflow for comparison tasks.
-
-    This class represents a comparison workflow where items are compared based on
-    specified criteria.
-
-    Attributes:
-        _criteria (str): The criteria used for comparison.
-
-    Args:
-        criteria (str): The criteria to be used for comparison.
-    """
-
-    def __init__(self, criteria: str):
-        """
-        Initialize a CompareWorkflow instance.
-
-        Args:
-            criteria (str): The criteria to be used for comparison.
-        """
-        super().__init__(type="CompareWorkflowConfig")
-        self._criteria = criteria
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            **super().to_dict(),
-            "criteria": self._criteria,
-        }
-
-    def to_model(self) -> SimpleWorkflowModel:
-        blueprint = CompareRapidBlueprint(
-            _t="CompareBlueprint",
-            criteria=self._criteria,
-        )
-
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint),
-        )

rapidata/rapidata_client/workflow/evaluation_workflow.py

@@ -1,15 +0,0 @@
-from rapidata.api_client.models.evaluation_workflow_model import EvaluationWorkflowModel
-from rapidata.rapidata_client.workflow.base_workflow import Workflow
-
-
-class EvaluationWorkflow(Workflow):
-    """Workflow to run evaluation orders. This is used internally only and should not be necessary to be used by clients."""
-
-    def __init__(self, validation_set_id: str):
-        super().__init__("EvaluationWorkflow")
-        self.validation_set_id = validation_set_id
-
-    def to_model(self):
-        return EvaluationWorkflowModel(
-            _t="EvaluationWorkflow", validationSetId=self.validation_set_id
-        )

rapidata/rapidata_client/workflow/free_text_workflow.py

@@ -1,50 +0,0 @@
-from typing import Any
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.rapidata_client.workflow import Workflow
-from rapidata.api_client.models.free_text_rapid_blueprint import FreeTextRapidBlueprint
-
-
-class FreeTextWorkflow(Workflow):
-    """
-    A workflow for free text input tasks.
-
-    This class represents a workflow where users can provide free-form text responses
-    to a given question.
-
-    Attributes:
-        _question (str): The question to be answered with free text.
-
-    Args:
-        question (str): The question to be presented for free text input.
-    """
-
-    def __init__(self, question: str):
-        """
-        Initialize a FreeTextWorkflow instance.
-
-        Args:
-            question (str): The question to be presented for free text input.
-        """
-        super().__init__(type="SimpleWorkflowConfig")
-        self._question = question
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            **super().to_dict(),
-            "blueprint": {
-                "_t": "FreeTextBlueprint",
-                "question": self._question,
-            },
-        }
-
-    def to_model(self) -> SimpleWorkflowModel:
-        blueprint = FreeTextRapidBlueprint(
-            _t="FreeTextBlueprint",
-            question=self._question,
-        )
-
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint),
-        )

rapidata/rapidata_client/workflow/transcription_workflow.py

@@ -1,40 +0,0 @@
-from rapidata.api_client.models.simple_workflow_model import SimpleWorkflowModel
-from rapidata.api_client.models.simple_workflow_model_blueprint import SimpleWorkflowModelBlueprint
-from rapidata.api_client.models.transcription_rapid_blueprint import TranscriptionRapidBlueprint
-from rapidata.rapidata_client.workflow.base_workflow import Workflow
-
-
-class TranscriptionWorkflow(Workflow):
-    """
-    A workflow for transcription tasks.
-
-    This class represents a transcription workflow where audio or video content
-    is transcribed based on given instructions.
-
-    Attributes:
-        _instruction (str): The instruction for the transcription task.
-
-    Args:
-        instruction (str): The instruction to be provided for the transcription task.
-    """
-
-    def __init__(self, instruction: str):
-        """
-        Initialize a TranscriptionWorkflow instance.
-
-        Args:
-            instruction (str): The instruction to be provided for the transcription task.
-        """
-        super().__init__(type="SimpleWorkflowConfig")
-        self._instruction = instruction
-
-    def to_model(self) -> SimpleWorkflowModel:
-        blueprint = TranscriptionRapidBlueprint(
-            _t="TranscriptionBlueprint",
-            title=self._instruction
-        )
-
-        return SimpleWorkflowModel(
-            _t="SimpleWorkflow",
-            blueprint=SimpleWorkflowModelBlueprint(blueprint)
-        )

rapidata/service/local_file_service.py

@@ -1,25 +0,0 @@
-import os
-from PIL import Image
-
-class LocalFileService:
-    
-    def load_image(self, image_path: str) -> Image.Image:
-        self.check_file_exists(image_path)
-        return Image.open(image_path)
-    
-    def load_images(self, image_paths: list[str]) -> list[Image.Image]:
-        return [self.load_image(image_path) for image_path in image_paths]
-    
-    def load_video(self, video_path: str):
-        self.check_file_exists(video_path)
-        return open(video_path, 'rb')
-    
-    def load_videos(self, video_paths: list[str]):
-        return [self.load_video(video_path) for video_path in video_paths]
-    
-    def _file_exists(self, file_path: str) -> bool:
-        return os.path.exists(file_path)
-    
-    def check_file_exists(self, file_path: str):
-        if not self._file_exists(file_path):
-            raise FileNotFoundError(f"File {file_path} not found.")