sinapsis-data-tools 0.1.0__py3-none-any.whl

sinapsis_data_readers/src/sinapsis_data_readers/helpers/coco_dataclasses.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from pydantic.dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CocoJsonKeys:
+    """
+    Keys to access the annotations dictionary in coco format
+        IMAGES (str): Key to access the 'images' entry.
+        FILE_NAME (str): Key to access the 'file_name' entry.
+        IMAGE_ID (str): Key to access the 'image_id' entry.
+        COCO_LICENSE (str): Key to access the 'coco_license' entry.
+        COCO_URL (str): Key to access the 'coco_url' entry.
+        HEIGHT (str): Key to access the 'height' entry.
+        WIDTH (str): Key to access the 'width' entry.
+        DATE (str): Key to access the 'date' entry.
+        ANNOTATIONS (str): Key to access the 'annotations' entry.
+    """
+
+    IMAGES: str = "images"
+    FILE_NAME: str = "file_name"
+    IMAGE_ID: str = "id"
+    COCO_LICENSE: str = "license"
+    COCO_URL: str = "coco_url"
+    HEIGHT: str = "height"
+    WIDTH: str = "width"
+    DATE: str = "date_captured"
+    ANNOTATIONS: str = "annotations"
+
+
+@dataclass(frozen=True)
+class CocoAnnotationsKeys:
+    """
+    Keys to access the annotations fields in the coco-format annotations
+        IMAGE_ID (str): key to access the 'image_id' field.
+        SEGMENTATIONS (str): key to access the 'segmentations' field.
+        BBOX (str): key to access the 'bbox' field.
+        ORIENTED_BBOX (str): key to access the 'oriented_bbox' field.
+        ANNOTATION_ID (str): key to access the 'annotation_id' field.
+        AREA (str): key to access the 'area' field.
+        CATEGORY_ID (str): key to access the 'category_id' field.
+        IS_CROWD (str): key to access the 'is_crowd' field.
+        NUM_KEYPOINTS (str): key to access the 'num_keypoints' field.
+        KEYPOINTS (str): key to access the 'keypoints' field.
+        SEGMENTS_INFO (str): key to access the 'segments_info' field.
+        SCORE (str): key to access the 'score' field.
+    """
+
+    IMAGE_ID: str = "image_id"
+    SEGMENTATIONS: str = "segmentation"
+    BBOX: str = "bbox"
+    ORIENTED_BBOX: str = "oriented_bbox"
+    ANNOTATION_ID: str = "id"
+    AREA: str = "area"
+    CATEGORY_ID: str = "category_id"
+    IS_CROWD: str = "iscrowd"
+    NUM_KEYPOINTS: str = "num_keypoints"
+    KEYPOINTS: str = "keypoints"
+    SEGMENTS_INFO: str = "segments_info"
+    SCORE: str = "score"

sinapsis_data_readers/src/sinapsis_data_readers/helpers/file_path_helpers.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+
+
+def is_regex(fpath: str) -> bool:
+    """
+    Determine if the fiven path contains the character (*) indicating that it might be a regular
+    expresion or a glob pattern.
+    Args:
+        fpath (str): the file path to check
+    Returns
+        (bool): True if the character is in the pattern, false otherwise.
+
+    """
+    return "*" in fpath
+
+
+SUPPORTED_VIDEO_TYPE_EXT = ["mp4", "wav", "mov"]
+
+
+def process_single_path(single_path: str) -> list[str]:
+    """Determines all the paths to be visited according to the single
+    path provided
+
+    Args:
+        single_path (str): single path provided
+
+    Returns:
+        list[str]: List of all the paths to be visited when processing the data
+    """
+    video_file_paths: list[str] = []
+
+    if is_regex(single_path):
+        search_pattern_start = single_path.find("*")
+        search_pattern_end = single_path.rfind("*")
+        root_dir = single_path[0:search_pattern_start]
+        pattern = single_path[search_pattern_end:]
+        video_file_paths += [str(f.resolve()) for f in Path(root_dir).glob(pattern)]
+
+    elif "." in single_path and single_path.split(".")[-1].lower() in SUPPORTED_VIDEO_TYPE_EXT:
+        video_file_paths = [single_path]
+
+    elif Path(single_path).is_dir():
+        for vid_type in SUPPORTED_VIDEO_TYPE_EXT:
+            video_file_paths += [str(f.resolve()) for f in Path(single_path).glob(f"**/*{vid_type}")]
+
+    return video_file_paths
+
+
+def parse_file_paths(file_paths: str | list[str]) -> list[str]:
+    """
+    Check if the path provided is a single path or a list of paths.
+    If it's a single path, parse the content inside.
+    If it's a list of paths, loop though the list and parse each of them.
+
+    Args:
+        file_paths (str | list[str]): path or list of paths to parse.
+
+    Returns:
+        list[str]: list of complete paths to process
+    """
+    return_file_paths: list[str] = []
+    if isinstance(file_paths, str):
+        return_file_paths += process_single_path(file_paths)
+    elif isinstance(file_paths, list):
+        for file_path in file_paths:
+            return_file_paths += process_single_path(file_path)
+    return return_file_paths

sinapsis_data_readers/src/sinapsis_data_readers/helpers/image_color_space_converter.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+from enum import Enum
+
+import cv2
+from sinapsis_core.data_containers.data_packet import ImageColor, ImagePacket
+from sinapsis_core.utils.logging_utils import sinapsis_logger
+
+color_mapping = {
+    (ImageColor.RGB, ImageColor.BGR): cv2.COLOR_RGB2BGR,
+    (ImageColor.RGB, ImageColor.GRAY): cv2.COLOR_RGB2GRAY,
+    (ImageColor.RGB, ImageColor.RGBA): cv2.COLOR_RGB2RGBA,
+    (ImageColor.BGR, ImageColor.RGB): cv2.COLOR_BGR2RGB,
+    (ImageColor.BGR, ImageColor.GRAY): cv2.COLOR_BGR2GRAY,
+    (ImageColor.BGR, ImageColor.RGBA): cv2.COLOR_BGR2RGBA,
+    (ImageColor.GRAY, ImageColor.RGB): cv2.COLOR_GRAY2RGB,
+    (ImageColor.GRAY, ImageColor.BGR): cv2.COLOR_GRAY2BGR,
+    (ImageColor.GRAY, ImageColor.RGBA): cv2.COLOR_GRAY2RGBA,
+    (ImageColor.RGBA, ImageColor.RGB): cv2.COLOR_RGBA2RGB,
+    (ImageColor.RGBA, ImageColor.BGR): cv2.COLOR_RGBA2BGR,
+    (ImageColor.RGBA, ImageColor.GRAY): cv2.COLOR_RGBA2GRAY,
+}
+
+
+def convert_color_space_cv(image: ImagePacket, desired_color_space: Enum) -> ImagePacket:
+    """Converts an image from one color space to another, provided
+        they are in the color mapping options.
+
+    Args:
+        image (ImagePacket): Image packet to apply the conversion
+        desired_color_space (Enum): Color space to convert the image
+
+    Returns:
+        ImagePacket: Updated ImagePacket with content converted into the new color space
+        
+    Raises:
+         ValueError: If the conversion is not possible, return an error.
+
+    """
+    current_color_space = image.color_space
+
+    if (current_color_space, desired_color_space) in color_mapping:
+        conversion_code = color_mapping[(current_color_space, desired_color_space)]
+        try:
+            image.content = cv2.cvtColor(image.content, conversion_code)
+            image.color_space = desired_color_space
+
+        except cv2.error:
+            sinapsis_logger.error(f"Invalid conversion between {current_color_space} and {desired_color_space}")
+
+    else:
+        raise ValueError(f"Conversion from {current_color_space} to {desired_color_space} is not supported.")
+
+    return image

sinapsis_data_readers/src/sinapsis_data_readers/helpers/sklearn_dataset_subset.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+from typing import Callable
+
+from sklearn import datasets
+
+_sklearn_supported_loaders = {
+    name: getattr(datasets, name) for name in dir(datasets) if name.startswith(("load", "fetch"))
+}
+
+
+def __getattr__(name: str) -> Callable:
+    if name in _sklearn_supported_loaders:
+        return _sklearn_supported_loaders[name]
+    raise AttributeError(f"Function `{name}` not found in sklearn.datasets.")
+
+
+__all__ = list(_sklearn_supported_loaders.keys())

sinapsis_data_readers/src/sinapsis_data_readers/helpers/text_input_helpers.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+"""Module for processing text input from TextPacket objects."""
+
+from sinapsis_core.data_containers.data_packet import TextPacket
+
+
+def load_input_text(input_data: list[TextPacket]) -> str:
+    """Loads and concatenates the text content of all TextPacket objects into a single string.
+
+    Args:
+        input_data (list[TextPacket]): A list of TextPacket objects containing text content.
+
+    Returns:
+        str: A single string containing the concatenated text from all TextPacket objects.
+    """
+    return "".join(t.content for t in input_data)

sinapsis_data_readers/src/sinapsis_data_readers/templates/__init__.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+import importlib
+from typing import Callable
+
+from sinapsis.templates import _import_template_package
+
+_root_lib_path = "sinapsis_data_readers.templates"
+
+_template_lookup = {
+    "AudioReaderPydub": f"{_root_lib_path}.audio_readers.audio_reader_pydub",
+    "AudioReaderSoundfile": f"{_root_lib_path}.audio_readers.audio_reader_soundfile",
+    "AudioReaderToBytes": f"{_root_lib_path}.audio_readers.audio_reader_to_bytes",
+    "CSVImageDataset": f"{_root_lib_path}.image_readers.csv_dataset_reader",
+    "CocoDetectionDatasetCV2": f"{_root_lib_path}.image_readers.coco_dataset_reader",
+    "CocoKeypointsDatasetCV2": f"{_root_lib_path}.image_readers.coco_dataset_reader",
+    "CocoSegmentationDatasetCV2": f"{_root_lib_path}.image_readers.coco_dataset_reader",
+    "ExecuteNTimesAudioReaderPydub": f"{_root_lib_path}.audio_readers.audio_reader_pydub",
+    "ExecuteNTimesAudioReaderSoundfile": f"{_root_lib_path}.audio_readers.audio_reader_soundfile",
+    "ExecuteNTimesLazyAudioReaderPydub": f"{_root_lib_path}.audio_readers.audio_reader_pydub",
+    "ExecuteNTimesLazyAudioReaderSoundfile": f"{_root_lib_path}.audio_readers.audio_reader_soundfile",
+    "FolderImageDatasetCV2": f"{_root_lib_path}.image_readers.image_folder_reader_cv2",
+    "ImageDatasetSplitter": f"{_root_lib_path}.datasets_readers.dataset_splitter",
+    "LazyAudioReaderPydub": f"{_root_lib_path}.audio_readers.audio_reader_pydub",
+    "LazyAudioReaderSoundfile": f"{_root_lib_path}.audio_readers.audio_reader_soundfile",
+    "MultiVideoReaderCV2": f"{_root_lib_path}.video_readers.video_reader_cv2",
+    "MultiVideoReaderDali": f"{_root_lib_path}.video_readers.video_reader_dali",
+    "MultiVideoReaderDaliPytorch": f"{_root_lib_path}.video_readers.video_reader_dali",
+    "MultiVideoReaderFFMPEG": f"{_root_lib_path}.video_readers.video_reader_ffmpeg",
+    "MultiVideoReaderTorchCodec": f"{_root_lib_path}.video_readers.video_reader_torchcodec",
+    "TabularDatasetSplitter": f"{_root_lib_path}.datasets_readers.dataset_splitter",
+    "TextInput": f"{_root_lib_path}.text_readers.text_input",
+    "VideoReaderCV2": f"{_root_lib_path}.video_readers.video_reader_cv2",
+    "VideoReaderDali": f"{_root_lib_path}.video_readers.video_reader_dali",
+    "VideoReaderDaliPytorch": f"{_root_lib_path}.video_readers.video_reader_dali",
+    "VideoReaderFFMPEG": f"{_root_lib_path}.video_readers.video_reader_ffmpeg",
+    "VideoReaderTorchCodec": f"{_root_lib_path}.video_readers.video_reader_torchcodec",
+}
+
+
+_ADDITIONAL_TEMPLATE_MODULES = [
+    f"{_root_lib_path}.datasets_readers.sklearn_datasets",
+    f"{_root_lib_path}.datasets_readers.sktime_datasets",
+]
+for t_module in _ADDITIONAL_TEMPLATE_MODULES:
+    _template_lookup |= _import_template_package(t_module)
+
+
+def __getattr__(name: str) -> Callable:
+    if name in _template_lookup:
+        module = importlib.import_module(_template_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"template `{name}` not found in {_root_lib_path}")
+
+
+__all__ = list(_template_lookup.keys())

sinapsis_data_readers/src/sinapsis_data_readers/templates/audio_readers/audio_reader_pydub.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+
+import io
+import os
+from typing import cast
+
+import numpy as np
+from pydub import AudioSegment
+from sinapsis_core.data_containers.data_packet import AudioPacket, DataContainer
+from sinapsis_core.template_base.multi_execute_template import (
+    execute_template_n_times_wrapper,
+)
+
+from sinapsis_data_readers.templates.audio_readers.base_audio_reader import (
+    _AudioBaseReader,
+)
+
+
+class AudioReaderPydub(_AudioBaseReader):
+    """Audio reader for reading audio data directly from bytes or files using Pydub.
+
+    This class can read audio data from either a bytes object or a file path,
+    using the Pydub library.
+    When reading from bytes, it retains the data in byte format.
+    When reading from a file, it converts the audio data to a NumPy array.
+
+
+    Usage example:
+
+        agent:
+          name: my_test_agent
+        templates:
+        - template_name: InputTemplate
+          class_name: InputTemplate
+          attributes: {}
+        - template_name: AudioReaderPydub
+          class_name: AudioReaderPydub
+          template_input: InputTemplate
+          attributes:
+            audio_file_path: '/path/to/file.mp3'
+            source: 'source/of/file'
+            sample_rate_khz: 16
+            from_bytes: false
+    """
+
+    class AttributesBaseModel(_AudioBaseReader.AttributesBaseModel):
+        """Attributes for the AudioReaderAudioSegment.
+
+        Args:
+            sample_rate_khz (int):
+                Sample rate in khz for the processed audio. Defaults to 16hkz.
+            from_bytes (bool):
+                Flag to determine if the file is in bytes. Defaults to True
+
+
+        """
+
+        sample_rate_khz: int = 16
+        from_bytes: bool = True
+
+    def read_file(self) -> AudioPacket | None:
+        """Reads audio data from a file path or bytes and returns an AudioPacket.
+
+        If reading from bytes, it returns the audio data in bytes format.
+        If reading from a file, it returns audio data as a NumPy array.
+
+        Returns:
+            Optional[AudioPacket]: An AudioPacket containing the audio data,
+            sample rate, and metadata, or None if there was an error.
+        """
+
+        audio_data: bytes | np.ndarray
+        if self.attributes.from_bytes:
+            audio_bytes: bytes = cast(bytes, self.attributes.audio_file_path)
+            audio_segment = AudioSegment.from_file(io.BytesIO(audio_bytes))
+
+        else:
+            audio_file_path: str = cast(str, self.attributes.audio_file_path)
+            if os.path.exists(audio_file_path):
+                audio_segment = AudioSegment.from_file(audio_file_path, format="wav")
+
+            else:
+                self.logger.error("Invalid audio file path: %s", audio_file_path)
+                return None
+        audio_segment = audio_segment.set_frame_rate(self.attributes.sample_rate_khz * 1000)
+        audio_segment = audio_segment.set_channels(1)
+
+        audio_data = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+        audio_data = audio_data / (2**15)
+
+        audio_packet = AudioPacket(
+            source=self.attributes.source,
+            content=audio_data,
+            sample_rate=audio_segment.frame_rate,
+        )
+        return audio_packet
+
+
+@execute_template_n_times_wrapper
+class ExecuteNTimesAudioReaderPydub(AudioReaderPydub):
+    """
+    This template provides functionality to read multiple audios, each of them assigned to
+    its own DataContainer and to its own reader process.
+    Similar to its base class, it reads the audios using the Pydub library
+    """
+
+
+class LazyAudioReaderPydub(AudioReaderPydub):
+    """Reads an audio file using Pydub, obtaining the file path
+    from the generic_field of the DataContainer and setting is as the file_path in the attributes.
+
+    Usage example:
+
+        agent:
+          name: my_test_agent
+        templates:
+        - template_name: InputTemplate
+          class_name: InputTemplate
+          attributes: {}
+        - template_name: LazyAudioReaderPydub
+          class_name: LazyAudioReaderPydub
+          template_input: InputTemplate
+          attributes:
+            sample_rate_khz: 16
+            from_bytes: False
+    """
+
+    def get_file_path_from_generic_data(self, container: DataContainer) -> None:
+        """Method to retrieve the file path from the genetic data field of DataContainer.
+        The method extracts the file path from the generic field and sets as attribute
+        
+        Args:
+            container (DataContainer): The DataContainer to extract the file path from
+        """
+        file_path = container.generic_data.get("audio_path", "")
+        self.attributes.audio_file_path = file_path
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        self.get_file_path_from_generic_data(container)
+        if self.attributes.audio_file_path:
+            return super().execute(container)
+
+        return container
+
+
+@execute_template_n_times_wrapper
+class ExecuteNTimesLazyAudioReaderPydub(LazyAudioReaderPydub):
+    """
+    This template provides functionality to read multiple audios, each of them assigned to
+    its own DataContainer and to its own reader process.
+    Similar to its base class, it reads the file path from the generic field of the DataContainer
+    """

sinapsis_data_readers/src/sinapsis_data_readers/templates/audio_readers/audio_reader_soundfile.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+
+import os
+from typing import cast
+
+import soundfile as sf
+from sinapsis_core.data_containers.data_packet import AudioPacket, DataContainer
+from sinapsis_core.template_base.multi_execute_template import (
+    execute_template_n_times_wrapper,
+)
+
+from sinapsis_data_readers.templates.audio_readers.base_audio_reader import (
+    _AudioBaseReader,
+)
+
+
+class AudioReaderSoundfile(_AudioBaseReader):
+    """Reads audio data from a file path using Soundfile.
+
+    This class utilizes the Soundfile library to read audio data from a specified file path.
+    It returns the audio data wrapped in an AudioPacket, which includes additional metadata
+    such as sample rate and source information.
+
+
+    Usage example:
+
+        agent:
+          name: my_test_agent
+        templates:
+        - template_name: InputTemplate
+          class_name: InputTemplate
+          attributes: {}
+        - template_name: AudioReaderSoundfile
+          class_name: AudioReaderSoundfile
+          template_input: InputTemplate
+          attributes:
+            audio_file_path: '/path/to/file.mp3'
+            source: 'source/of/file'
+            sample_rate_khz: 16
+            from_bytes: true
+
+    """
+
+    AttributesBaseModel = _AudioBaseReader.AttributesBaseModel
+
+    def read_file(self) -> AudioPacket | None:
+        """Reads audio data from a file path and returns an AudioPacket.
+
+        This method checks if the specified audio file exists and attempts to read
+        the audio data using the Soundfile library. If successful, it wraps the audio
+        data in an AudioPacket and returns it. If the file does not exist or if there
+        is an error during reading, it logs the error and returns None.
+
+        Returns:
+            AudioPacket|None: An AudioPacket containing the audio data and
+            sample rate, or None if the file could not be read or was invalid.
+        """
+        audio_path = cast(str, self.attributes.audio_file_path)
+        if os.path.exists(audio_path):
+            try:
+                audio_content, sample_rate = sf.read(audio_path)
+                audio_packet = AudioPacket(
+                    source=self.attributes.source,
+                    content=audio_content,
+                    sample_rate=sample_rate,
+                )
+                return audio_packet
+            except (ValueError, TypeError) as e:
+                self.logger.error("Error reading audio file: %s", e)
+                return None
+        else:
+            self.logger.error("Invalid audio file path: %s", audio_path)
+            return None
+
+
+@execute_template_n_times_wrapper
+class ExecuteNTimesAudioReaderSoundfile(AudioReaderSoundfile):
+    """
+    This template provides functionality to read multiple audios, each of them assigned to
+    its own DataContainer and to its own reader process.
+        Similar to its base class, it reads the audio using the Soundfile library
+    """
+
+
+class LazyAudioReaderSoundfile(AudioReaderSoundfile):
+    """Reads audio data from a file path using Soundfile.
+
+    This class utilizes the Soundfile library to read audio data from a specified file path.
+    It returns the audio data wrapped in an AudioPacket, which includes additional metadata
+    such as sample rate and source information.
+
+    Usage example:
+
+        agent:
+          name: my_test_agent
+        templates:
+        - template_name: InputTemplate
+          class_name: InputTemplate
+          attributes: {}
+        - template_name: LazyAudioReaderSoundfile
+          class_name: LazyAudioReaderSoundfile
+          template_input: InputTemplate
+          attributes:
+            sample_rate_khz: 16
+            from_bytes: true
+    """
+
+    def get_file_path_from_generic_data(self, container: DataContainer) -> None:
+        """Method to retrieve the file path from the genetic data field of DataContainer.
+        The method extracts the file path from the generic field and sets as attribute
+        
+        Args:
+            container (DataContainer): The DataContainer to extract the file path from
+        """
+        file_path = container.generic_data["audio_path"]
+        self.attributes.audio_file_path = file_path
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        self.get_file_path_from_generic_data(container)
+        return super().execute(container)
+
+
+@execute_template_n_times_wrapper
+class ExecuteNTimesLazyAudioReaderSoundfile(LazyAudioReaderSoundfile):
+    """
+    This template provides functionality to read multiple audios, each of them assigned to
+    its own DataContainer and to its own reader process.
+    Similar to its base class, it reads the audio using the Soundfile library
+    """

sinapsis_data_readers/src/sinapsis_data_readers/templates/audio_readers/audio_reader_to_bytes.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+from sinapsis_core.data_containers.data_packet import AudioPacket
+
+from sinapsis_data_readers.templates.audio_readers.base_audio_reader import (
+    _AudioBaseReader,
+)
+
+
+class AudioReaderToBytes(_AudioBaseReader):
+    """
+    AudioReader for Reading Audio Files and Converting to Bytes.
+    Usage example:
+
+        agent:
+          name: my_test_agent
+        templates:
+        - template_name: InputTemplate
+          class_name: InputTemplate
+          attributes: {}
+        - template_name: AudioReaderToBytes
+          class_name: AudioReaderToBytes
+          template_input: InputTemplate
+          attributes:
+            audio_file_path: '/path/to/file.mp3'
+            source: 'source/of/file'
+            from_bytes: true
+    """
+
+    def read_file(self) -> AudioPacket | None:
+        """
+        Reads an audio file from the specified path and converts it into an `AudioPacket`.
+        
+        Returns:
+            AudioPacket: An `AudioPacket` object containing the audio data.
+            
+        Raises:
+            FileNotFoundError: If the specified audio file does not exist.
+            IOError: If there is an error reading the audio file.
+        """
+
+        try:
+            with open(self.attributes.audio_file_path, "rb") as audio_file:
+                audio_content = audio_file.read()
+
+            audio_file.close()
+            audio_packet = AudioPacket(
+                source=self.attributes.audio_file_path,
+                content=audio_content,
+            )
+            return audio_packet
+        except FileNotFoundError:
+            self.logger.error(f"Audio file not found: {self.attributes.audio_file_path}")
+            return None
+        except IOError as e:
+            self.logger.error(f"Error reading audio file: {e}")
+            return None

sinapsis_data_readers/src/sinapsis_data_readers/templates/audio_readers/base_audio_reader.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+import abc
+from uuid import uuid4
+
+from sinapsis_core.data_containers.data_packet import AudioPacket, DataContainer
+from sinapsis_core.template_base import TemplateAttributes
+
+from sinapsis_data_readers.templates.base_file_data_loader import _BaseDataReader
+
+
+class _AudioBaseReader(_BaseDataReader):
+    PACKET_ATT_NAME = "audios"
+
+    class AttributesBaseModel(TemplateAttributes):
+        """Attributes for the AudioBaseReader.
+
+        audio_file_path (str):
+            Path to the audio file to be read.
+
+        source (str):
+            The source identifier, defaults to "streamlit".
+        """
+
+        audio_file_path: str
+        source: str = str(uuid4())
+
+    @abc.abstractmethod
+    def read_file(self) -> AudioPacket | None:
+        """Abstract method to read the audio data.
+
+        This method must be implemented by subclasses to
+        read the audio data and return an AudioPacket with the content
+        of the audio.
+
+        Returns:
+            AudioPacket: The audio data wrapped in an AudioPacket.
+        """
+
+    def has_elements(self) -> bool:
+        """Flag to indicate if there is still content to process"""
+        return True
+
+    def append_packets_to_container(self, container: DataContainer) -> None:
+        """Adds a packet to the input container
+
+        Args:
+            container (DataContainer): container where data is to be appended
+        """
+        data_packets_to_add = [self.read_file()]
+        if data_packets_to_add:
+            data_packets_to_add += getattr(container, self.PACKET_ATT_NAME)
+        setattr(container, self.PACKET_ATT_NAME, data_packets_to_add)
+
+    def make_data_entries(self) -> list[AudioPacket]:
+        audio_packets: list[AudioPacket] = []
+        return audio_packets