Upload 29 files

.gitattributes

@@ -102,3 +102,6 @@ MLPY/Lib/site-packages/torch/lib/torch_cpu.lib filter=lfs diff=lfs merge=lfs -te
 MLPY/Lib/site-packages/torch/lib/torch_python.dll filter=lfs diff=lfs merge=lfs -text
 MLPY/Lib/site-packages/torch/lib/XNNPACK.lib filter=lfs diff=lfs merge=lfs -text
 MLPY/Lib/site-packages/torchaudio/lib/libtorchaudio.pyd filter=lfs diff=lfs merge=lfs -text
+MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg4.pyd filter=lfs diff=lfs merge=lfs -text
+MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg5.pyd filter=lfs diff=lfs merge=lfs -text
+MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg6.pyd filter=lfs diff=lfs merge=lfs -text

MLPY/Lib/site-packages/torio/__init__.py

@@ -0,0 +1,8 @@
+from . import _extension  # noqa  # usort: skip
+from . import io, utils
+
+
+__all__ = [
+    "io",
+    "utils",
+]

MLPY/Lib/site-packages/torio/_extension/__init__.py

@@ -0,0 +1,13 @@
+from .utils import _init_ffmpeg, _LazyImporter
+
+
+_FFMPEG_EXT = None
+
+
+def lazy_import_ffmpeg_ext():
+    """Load FFmpeg integration based on availability in lazy manner"""
+
+    global _FFMPEG_EXT
+    if _FFMPEG_EXT is None:
+        _FFMPEG_EXT = _LazyImporter("_torio_ffmpeg", _init_ffmpeg)
+    return _FFMPEG_EXT

MLPY/Lib/site-packages/torio/_extension/utils.py

@@ -0,0 +1,147 @@
+import importlib
+import logging
+import os
+import types
+from pathlib import Path
+
+import torch
+
+_LG = logging.getLogger(__name__)
+_LIB_DIR = Path(__file__).parent.parent / "lib"
+
+
+class _LazyImporter(types.ModuleType):
+    """Lazily import module/extension."""
+
+    def __init__(self, name, import_func):
+        super().__init__(name)
+        self.import_func = import_func
+        self.module = None
+
+    # Note:
+    # Python caches what was retrieved with `__getattr__`, so this method will not be
+    # called again for the same item.
+    def __getattr__(self, item):
+        self._import_once()
+        return getattr(self.module, item)
+
+    def __repr__(self):
+        if self.module is None:
+            return f"<module '{self.__module__}.{self.__class__.__name__}(\"{self.name}\")'>"
+        return repr(self.module)
+
+    def __dir__(self):
+        self._import_once()
+        return dir(self.module)
+
+    def _import_once(self):
+        if self.module is None:
+            self.module = self.import_func()
+            # Note:
+            # By attaching the module attributes to self,
+            # module attributes are directly accessible.
+            # This allows to avoid calling __getattr__ for every attribute access.
+            self.__dict__.update(self.module.__dict__)
+
+    def is_available(self):
+        try:
+            self._import_once()
+        except Exception:
+            return False
+        return True
+
+
+def _get_lib_path(lib: str):
+    suffix = "pyd" if os.name == "nt" else "so"
+    path = _LIB_DIR / f"{lib}.{suffix}"
+    return path
+
+
+def _load_lib(lib: str) -> bool:
+    """Load extension module
+
+    Note:
+        In case `torio` is deployed with `pex` format, the library file
+        is not in a standard location.
+        In this case, we expect that `libtorio` is available somewhere
+        in the search path of dynamic loading mechanism, so that importing
+        `_torio` will have library loader find and load `libtorio`.
+        This is the reason why the function should not raising an error when the library
+        file is not found.
+
+    Returns:
+        bool:
+            True if the library file is found AND the library loaded without failure.
+            False if the library file is not found (like in the case where torio
+            is deployed with pex format, thus the shared library file is
+            in a non-standard location.).
+            If the library file is found but there is an issue loading the library,
+            (such as missing dependency) then this function raises the exception as-is.
+
+    Raises:
+        Exception:
+            If the library file is found, but there is an issue loading the library file,
+            (when underlying `ctype.DLL` throws an exception), this function will pass
+            the exception as-is, instead of catching it and returning bool.
+            The expected case is `OSError` thrown by `ctype.DLL` when a dynamic dependency
+            is not found.
+            This behavior was chosen because the expected failure case is not recoverable.
+            If a dependency is missing, then users have to install it.
+    """
+    path = _get_lib_path(lib)
+    if not path.exists():
+        return False
+    torch.ops.load_library(path)
+    return True
+
+
+_FFMPEG_VERS = ["6", "5", "4", ""]
+
+
+def _find_versionsed_ffmpeg_extension(version: str):
+    ext = f"torio.lib._torio_ffmpeg{version}"
+    lib = f"libtorio_ffmpeg{version}"
+
+    if not importlib.util.find_spec(ext):
+        raise RuntimeError(f"FFmpeg{version} extension is not available.")
+
+    _load_lib(lib)
+    return importlib.import_module(ext)
+
+
+def _find_ffmpeg_extension(ffmpeg_vers):
+    for ffmpeg_ver in ffmpeg_vers:
+        _LG.debug("Loading FFmpeg%s", ffmpeg_ver)
+        try:
+            ext = _find_versionsed_ffmpeg_extension(ffmpeg_ver)
+            _LG.debug("Successfully loaded FFmpeg%s", ffmpeg_ver)
+            return ext
+        except Exception:
+            _LG.debug("Failed to load FFmpeg%s extension.", ffmpeg_ver, exc_info=True)
+            continue
+    raise ImportError(
+        f"Failed to intialize FFmpeg extension. Tried versions: {ffmpeg_vers}. "
+        "Enable DEBUG logging to see more details about the error."
+    )
+
+
+def _get_ffmpeg_versions():
+    ffmpeg_vers = _FFMPEG_VERS
+    # User override
+    if (ffmpeg_ver := os.environ.get("TORIO_USE_FFMPEG_VERSION")) is not None:
+        if ffmpeg_ver not in ffmpeg_vers:
+            raise ValueError(
+                f"The FFmpeg version '{ffmpeg_ver}' (read from TORIO_USE_FFMPEG_VERSION) "
+                f"is not one of supported values. Possible values are {ffmpeg_vers}"
+            )
+        ffmpeg_vers = [ffmpeg_ver]
+    return ffmpeg_vers
+
+
+def _init_ffmpeg():
+    ffmpeg_vers = _get_ffmpeg_versions()
+    ext = _find_ffmpeg_extension(ffmpeg_vers)
+    ext.init()
+    if ext.get_log_level() > 8:
+        ext.set_log_level(8)
+    return ext

MLPY/Lib/site-packages/torio/io/__init__.py

@@ -0,0 +1,9 @@
+from ._streaming_media_decoder import StreamingMediaDecoder
+from ._streaming_media_encoder import CodecConfig, StreamingMediaEncoder
+
+
+__all__ = [
+    "StreamingMediaDecoder",
+    "CodecConfig",
+    "StreamingMediaEncoder",
+]

MLPY/Lib/site-packages/torio/io/_streaming_media_decoder.py

@@ -0,0 +1,978 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO, Dict, Iterator, Optional, Tuple, TypeVar, Union
+
+import torch
+import torio
+from torch.utils._pytree import tree_map
+
+ffmpeg_ext = torio._extension.lazy_import_ffmpeg_ext()
+
+__all__ = [
+    "StreamingMediaDecoder",
+]
+
+
+@dataclass
+class SourceStream:
+    """The metadata of a source stream, returned by :meth:`~torio.io.StreamingMediaDecoder.get_src_stream_info`.
+
+    This class is used when representing streams of media type other than `audio` or `video`.
+
+    When source stream is `audio` or `video` type, :class:`SourceAudioStream` and
+    :class:`SourceVideoStream`, which reports additional media-specific attributes,
+    are used respectively.
+    """
+
+    media_type: str
+    """The type of the stream.
+    One of ``"audio"``, ``"video"``, ``"data"``, ``"subtitle"``, ``"attachment"`` and empty string.
+
+    .. note::
+       Only audio and video streams are supported for output.
+    .. note::
+       Still images, such as PNG and JPEG formats are reported as video.
+    """
+    codec: str
+    """Short name of the codec. Such as ``"pcm_s16le"`` and ``"h264"``."""
+    codec_long_name: str
+    """Detailed name of the codec.
+
+    Such as "`PCM signed 16-bit little-endian`" and "`H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10`".
+    """
+    format: Optional[str]
+    """Media format. Such as ``"s16"`` and ``"yuv420p"``.
+
+    Commonly found audio values are;
+
+    - ``"u8"``, ``"u8p"``: Unsigned 8-bit unsigned interger.
+    - ``"s16"``, ``"s16p"``: 16-bit signed integer.
+    - ``"s32"``, ``"s32p"``: 32-bit signed integer.
+    - ``"flt"``, ``"fltp"``: 32-bit floating-point.
+
+    .. note::
+
+       `p` at the end indicates the format is `planar`.
+       Channels are grouped together instead of interspersed in memory.
+    """
+    bit_rate: Optional[int]
+    """Bit rate of the stream in bits-per-second.
+    This is an estimated values based on the initial few frames of the stream.
+    For container formats and variable bit rate, it can be 0.
+    """
+    num_frames: Optional[int]
+    """The number of frames in the stream"""
+    bits_per_sample: Optional[int]
+    """This is the number of valid bits in each output sample.
+    For compressed format, it can be 0.
+    """
+    metadata: Dict[str, str]
+    """Metadata attached to the source stream."""
+
+
+@dataclass
+class SourceAudioStream(SourceStream):
+    """The metadata of an audio source stream, returned by :meth:`~torio.io.StreamingMediaDecoder.get_src_stream_info`.
+
+    This class is used when representing audio stream.
+
+    In addition to the attributes reported by :class:`SourceStream`,
+    the following attributes are reported.
+    """
+
+    sample_rate: float
+    """Sample rate of the audio."""
+    num_channels: int
+    """Number of channels."""
+
+
+@dataclass
+class SourceVideoStream(SourceStream):
+    """The metadata of a video source stream, returned by :meth:`~torio.io.StreamingMediaDecoder.get_src_stream_info`.
+
+    This class is used when representing video stream.
+
+    In addition to the attributes reported by :class:`SourceStream`,
+    the following attributes are reported.
+    """
+
+    width: int
+    """Width of the video frame in pixel."""
+    height: int
+    """Height of the video frame in pixel."""
+    frame_rate: float
+    """Frame rate."""
+
+
+def _parse_si(i):
+    media_type = i.media_type
+    if media_type == "audio":
+        return SourceAudioStream(
+            media_type=i.media_type,
+            codec=i.codec_name,
+            codec_long_name=i.codec_long_name,
+            format=i.format,
+            bit_rate=i.bit_rate,
+            num_frames=i.num_frames,
+            bits_per_sample=i.bits_per_sample,
+            metadata=i.metadata,
+            sample_rate=i.sample_rate,
+            num_channels=i.num_channels,
+        )
+    if media_type == "video":
+        return SourceVideoStream(
+            media_type=i.media_type,
+            codec=i.codec_name,
+            codec_long_name=i.codec_long_name,
+            format=i.format,
+            bit_rate=i.bit_rate,
+            num_frames=i.num_frames,
+            bits_per_sample=i.bits_per_sample,
+            metadata=i.metadata,
+            width=i.width,
+            height=i.height,
+            frame_rate=i.frame_rate,
+        )
+    return SourceStream(
+        media_type=i.media_type,
+        codec=i.codec_name,
+        codec_long_name=i.codec_long_name,
+        format=None,
+        bit_rate=None,
+        num_frames=None,
+        bits_per_sample=None,
+        metadata=i.metadata,
+    )
+
+
+@dataclass
+class OutputStream:
+    """Output stream configured on :class:`StreamingMediaDecoder`,
+    returned by :meth:`~torio.io.StreamingMediaDecoder.get_out_stream_info`.
+    """
+
+    source_index: int
+    """Index of the source stream that this output stream is connected."""
+    filter_description: str
+    """Description of filter graph applied to the source stream."""
+    media_type: str
+    """The type of the stream. ``"audio"`` or ``"video"``."""
+    format: str
+    """Media format. Such as ``"s16"`` and ``"yuv420p"``.
+
+    Commonly found audio values are;
+
+    - ``"u8"``, ``"u8p"``: Unsigned 8-bit unsigned interger.
+    - ``"s16"``, ``"s16p"``: 16-bit signed integer.
+    - ``"s32"``, ``"s32p"``: 32-bit signed integer.
+    - ``"flt"``, ``"fltp"``: 32-bit floating-point.
+
+    .. note::
+
+       `p` at the end indicates the format is `planar`.
+       Channels are grouped together instead of interspersed in memory."""
+
+
+@dataclass
+class OutputAudioStream(OutputStream):
+    """Information about an audio output stream configured with
+    :meth:`~torio.io.StreamingMediaDecoder.add_audio_stream` or
+    :meth:`~torio.io.StreamingMediaDecoder.add_basic_audio_stream`.
+
+    In addition to the attributes reported by :class:`OutputStream`,
+    the following attributes are reported.
+    """
+
+    sample_rate: float
+    """Sample rate of the audio."""
+    num_channels: int
+    """Number of channels."""
+
+
+@dataclass
+class OutputVideoStream(OutputStream):
+    """Information about a video output stream configured with
+    :meth:`~torio.io.StreamingMediaDecoder.add_video_stream` or
+    :meth:`~torio.io.StreamingMediaDecoder.add_basic_video_stream`.
+
+    In addition to the attributes reported by :class:`OutputStream`,
+    the following attributes are reported.
+    """
+
+    width: int
+    """Width of the video frame in pixel."""
+    height: int
+    """Height of the video frame in pixel."""
+    frame_rate: float
+    """Frame rate."""
+
+
+def _parse_oi(i):
+    media_type = i.media_type
+    if media_type == "audio":
+        return OutputAudioStream(
+            source_index=i.source_index,
+            filter_description=i.filter_description,
+            media_type=i.media_type,
+            format=i.format,
+            sample_rate=i.sample_rate,
+            num_channels=i.num_channels,
+        )
+    if media_type == "video":
+        return OutputVideoStream(
+            source_index=i.source_index,
+            filter_description=i.filter_description,
+            media_type=i.media_type,
+            format=i.format,
+            width=i.width,
+            height=i.height,
+            frame_rate=i.frame_rate,
+        )
+    raise ValueError(f"Unexpected media_type: {i.media_type}({i})")
+
+
+def _get_afilter_desc(sample_rate: Optional[int], fmt: Optional[str], num_channels: Optional[int]):
+    descs = []
+    if sample_rate is not None:
+        descs.append(f"aresample={sample_rate}")
+    if fmt is not None or num_channels is not None:
+        parts = []
+        if fmt is not None:
+            parts.append(f"sample_fmts={fmt}")
+        if num_channels is not None:
+            parts.append(f"channel_layouts={num_channels}c")
+        descs.append(f"aformat={':'.join(parts)}")
+    return ",".join(descs) if descs else None
+
+
+def _get_vfilter_desc(frame_rate: Optional[float], width: Optional[int], height: Optional[int], fmt: Optional[str]):
+    descs = []
+    if frame_rate is not None:
+        descs.append(f"fps={frame_rate}")
+    scales = []
+    if width is not None:
+        scales.append(f"width={width}")
+    if height is not None:
+        scales.append(f"height={height}")
+    if scales:
+        descs.append(f"scale={':'.join(scales)}")
+    if fmt is not None:
+        descs.append(f"format=pix_fmts={fmt}")
+    return ",".join(descs) if descs else None
+
+
+# Base class for ChunkTensor
+# Based off of TrivialTensorViaComposition
+# https://github.com/albanD/subclass_zoo/blob/0eeb1d68fb59879029c610bc407f2997ae43ba0a/trivial_tensors.py#L83
+class ChunkTensorBase(torch.Tensor):
+    __torch_function__ = torch._C._disabled_torch_function_impl
+
+    @staticmethod
+    def __new__(cls, _elem, *_):
+        return super().__new__(cls, _elem)
+
+    @classmethod
+    def __torch_dispatch__(cls, func, _, args=(), kwargs=None):
+        def unwrap(t):
+            return t._elem if isinstance(t, cls) else t
+
+        return func(*tree_map(unwrap, args), **tree_map(unwrap, kwargs))
+
+
+@dataclass
+class ChunkTensor(ChunkTensorBase):
+    """Decoded media frames with metadata.
+
+    The instance of this class represents the decoded video/audio frames with
+    metadata, and the instance itself behave like :py:class:`~torch.Tensor`.
+
+    Client codes can pass instance of this class as-if it's
+    :py:class:`~torch.Tensor` class, or call the methods defined on
+    :py:class:`~torch.Tensor` class.
+
+    Example:
+        >>> # Define input streams
+        >>> reader = StreamingMediaDecoder(...)
+        >>> reader.add_audio_stream(frames_per_chunk=4000, sample_rate=8000)
+        >>> reader.add_video_stream(frames_per_chunk=7, frame_rate=28)
+        >>> # Decode the streams and fetch frames
+        >>> reader.fill_buffer()
+        >>> audio_chunk, video_chunk = reader.pop_chunks()
+
+        >>> # Access metadata
+        >>> (audio_chunk.pts, video_chunks.pts)
+        (0.0, 0.0)
+        >>>
+        >>> # The second time the PTS is different
+        >>> reader.fill_buffer()
+        >>> audio_chunk, video_chunk = reader.pop_chunks()
+        >>> (audio_chunk.pts, video_chunks.pts)
+        (0.5, 0.25)
+
+        >>> # Call PyTorch ops on chunk
+        >>> audio_chunk.shape
+        torch.Size([4000, 2]
+        >>> power = torch.pow(video_chunk, 2)
+        >>>
+        >>> # the result is a plain torch.Tensor class
+        >>> type(power)
+        <class 'torch.Tensor'>
+        >>>
+        >>> # Metadata is not available on the result
+        >>> power.pts
+        AttributeError: 'Tensor' object has no attribute 'pts'
+    """
+
+    # Keep it private for now
+    _elem: torch.Tensor
+
+    pts: float
+    """Presentation time stamp of the first frame in the chunk.
+
+    Unit: second.
+    """
+
+
+def _format_doc(**kwargs):
+    def decorator(obj):
+        obj.__doc__ = obj.__doc__.format(**kwargs)
+        return obj
+
+    return decorator
+
+
+_frames_per_chunk = """Number of frames returned as one chunk.
+                If the source stream is exhausted before enough frames are buffered,
+                then the chunk is returned as-is.
+
+                Providing ``-1`` disables chunking and :py:func:`pop_chunks` method
+                will concatenate all the buffered frames and return it."""
+
+_buffer_chunk_size = """Internal buffer size.
+                When the number of chunks buffered exceeds this number, old frames are
+                dropped. For example, if ``frames_per_chunk`` is 5 and ``buffer_chunk_size`` is
+                3, then frames older than ``15`` are dropped.
+                Providing ``-1`` disables this behavior.
+
+                Default: ``3``."""
+
+_audio_stream_index = """The source audio stream index.
+                If omitted, :py:attr:`default_audio_stream` is used."""
+
+
+_video_stream_index = """The source video stream index.
+                If omitted, :py:attr:`default_video_stream` is used."""
+
+_decoder = """The name of the decoder to be used.
+                When provided, use the specified decoder instead of the default one.
+
+                To list the available decoders, please use
+                :py:func:`~torio.utils.ffmpeg_utils.get_audio_decoders` for audio, and
+                :py:func:`~torio.utils.ffmpeg_utils.get_video_decoders` for video.
+
+                Default: ``None``."""
+
+_decoder_option = """Options passed to decoder.
+                Mapping from str to str. (Default: ``None``)
+
+                To list decoder options for a decoder, you can use
+                ``ffmpeg -h decoder=<DECODER>`` command.
+
+                |
+
+                In addition to decoder-specific options, you can also pass options related
+                to multithreading. They are effective only if the decoder support them.
+                If neither of them are provided, StreamingMediaDecoder defaults to single thread.
+
+                ``"threads"``: The number of threads (in str).
+                Providing the value ``"0"`` will let FFmpeg decides based on its heuristics.
+
+                ``"thread_type"``: Which multithreading method to use.
+                The valid values are ``"frame"`` or ``"slice"``.
+                Note that each decoder supports different set of methods.
+                If not provided, a default value is used.
+
+                - ``"frame"``: Decode more than one frame at once.
+                  Each thread handles one frame.
+                  This will increase decoding delay by one frame per thread
+                - ``"slice"``: Decode more than one part of a single frame at once.
+
+                |
+                """
+
+
+_hw_accel = """Enable hardware acceleration.
+
+                When video is decoded on CUDA hardware, for example
+                `decoder="h264_cuvid"`, passing CUDA device indicator to `hw_accel`
+                (i.e. `hw_accel="cuda:0"`) will make StreamingMediaDecoder place the resulting
+                frames directly on the specified CUDA device as CUDA tensor.
+
+                If `None`, the frame will be moved to CPU memory.
+                Default: ``None``."""
+
+
+_format_audio_args = _format_doc(
+    frames_per_chunk=_frames_per_chunk,
+    buffer_chunk_size=_buffer_chunk_size,
+    stream_index=_audio_stream_index,
+    decoder=_decoder,
+    decoder_option=_decoder_option,
+)
+
+
+_format_video_args = _format_doc(
+    frames_per_chunk=_frames_per_chunk,
+    buffer_chunk_size=_buffer_chunk_size,
+    stream_index=_video_stream_index,
+    decoder=_decoder,
+    decoder_option=_decoder_option,
+    hw_accel=_hw_accel,
+)
+
+
+InputStreamTypes = TypeVar("InputStream", bound=SourceStream)
+OutputStreamTypes = TypeVar("OutputStream", bound=OutputStream)
+
+
+class StreamingMediaDecoder:
+    """Fetch and decode audio/video streams chunk by chunk.
+
+    For the detailed usage of this class, please refer to the tutorial.
+
+    Args:
+        src (str, path-like, bytes or file-like object): The media source.
+            If string-type, it must be a resource indicator that FFmpeg can
+            handle. This includes a file path, URL, device identifier or
+            filter expression. The supported value depends on the FFmpeg found
+            in the system.
+
+            If bytes, it must be an encoded media data in contiguous memory.
+
+            If file-like object, it must support `read` method with the signature
+            `read(size: int) -> bytes`.
+            Additionally, if the file-like object has `seek` method, it uses
+            the method when parsing media metadata. This improves the reliability
+            of codec detection. The signagure of `seek` method must be
+            `seek(offset: int, whence: int) -> int`.
+
+            Please refer to the following for the expected signature and behavior
+            of `read` and `seek` method.
+
+            - https://docs.python.org/3/library/io.html#io.BufferedIOBase.read
+            - https://docs.python.org/3/library/io.html#io.IOBase.seek
+
+        format (str or None, optional):
+            Override the input format, or specify the source sound device.
+            Default: ``None`` (no override nor device input).
+
+            This argument serves two different usecases.
+
+            1) Override the source format.
+               This is useful when the input data do not contain a header.
+
+            2) Specify the input source device.
+               This allows to load media stream from hardware devices,
+               such as microphone, camera and screen, or a virtual device.
+
+
+            .. note::
+
+               This option roughly corresponds to ``-f`` option of ``ffmpeg`` command.
+               Please refer to the ffmpeg documentations for the possible values.
+
+               https://ffmpeg.org/ffmpeg-formats.html#Demuxers
+
+               Please use :py:func:`~torio.utils.ffmpeg_utils.get_demuxers` to list the
+               demultiplexers available in the current environment.
+
+               For device access, the available values vary based on hardware (AV device) and
+               software configuration (ffmpeg build).
+
+               https://ffmpeg.org/ffmpeg-devices.html#Input-Devices
+
+               Please use :py:func:`~torio.utils.ffmpeg_utils.get_input_devices` to list
+               the input devices available in the current environment.
+
+        option (dict of str to str, optional):
+            Custom option passed when initializing format context (opening source).
+
+            You can use this argument to change the input source before it is passed to decoder.
+
+            Default: ``None``.
+
+        buffer_size (int):
+            The internal buffer size in byte. Used only when `src` is file-like object.
+
+            Default: `4096`.
+    """
+
+    def __init__(
+        self,
+        src: Union[str, Path, BinaryIO],
+        format: Optional[str] = None,
+        option: Optional[Dict[str, str]] = None,
+        buffer_size: int = 4096,
+    ):
+        self.src = src
+        if isinstance(src, bytes):
+            self._be = ffmpeg_ext.StreamingMediaDecoderBytes(src, format, option, buffer_size)
+        elif hasattr(src, "read"):
+            self._be = ffmpeg_ext.StreamingMediaDecoderFileObj(src, format, option, buffer_size)
+        else:
+            self._be = ffmpeg_ext.StreamingMediaDecoder(os.path.normpath(src), format, option)
+
+        i = self._be.find_best_audio_stream()
+        self._default_audio_stream = None if i < 0 else i
+        i = self._be.find_best_video_stream()
+        self._default_video_stream = None if i < 0 else i
+
+    @property
+    def num_src_streams(self):
+        """Number of streams found in the provided media source.
+
+        :type: int
+        """
+        return self._be.num_src_streams()
+
+    @property
+    def num_out_streams(self):
+        """Number of output streams configured by client code.
+
+        :type: int
+        """
+        return self._be.num_out_streams()
+
+    @property
+    def default_audio_stream(self):
+        """The index of default audio stream. ``None`` if there is no audio stream
+
+        :type: Optional[int]
+        """
+        return self._default_audio_stream
+
+    @property
+    def default_video_stream(self):
+        """The index of default video stream. ``None`` if there is no video stream
+
+        :type: Optional[int]
+        """
+        return self._default_video_stream
+
+    def get_metadata(self) -> Dict[str, str]:
+        """Get the metadata of the source media.
+
+        Returns:
+            dict
+        """
+        return self._be.get_metadata()
+
+    def get_src_stream_info(self, i: int) -> InputStreamTypes:
+        """Get the metadata of source stream
+
+        Args:
+            i (int): Stream index.
+        Returns:
+            InputStreamTypes:
+                Information about the source stream.
+                If the source stream is audio type, then
+                :class:`~torio.io._stream_reader.SourceAudioStream` is returned.
+                If it is video type, then
+                :class:`~torio.io._stream_reader.SourceVideoStream` is returned.
+                Otherwise :class:`~torio.io._stream_reader.SourceStream` class is returned.
+        """
+        return _parse_si(self._be.get_src_stream_info(i))
+
+    def get_out_stream_info(self, i: int) -> OutputStreamTypes:
+        """Get the metadata of output stream
+
+        Args:
+            i (int): Stream index.
+        Returns:
+            OutputStreamTypes
+                Information about the output stream.
+                If the output stream is audio type, then
+                :class:`~torio.io._stream_reader.OutputAudioStream` is returned.
+                If it is video type, then
+                :class:`~torio.io._stream_reader.OutputVideoStream` is returned.
+        """
+        info = self._be.get_out_stream_info(i)
+        return _parse_oi(info)
+
+    def seek(self, timestamp: float, mode: str = "precise"):
+        """Seek the stream to the given timestamp [second]
+
+        Args:
+            timestamp (float): Target time in second.
+            mode (str): Controls how seek is done.
+                Valid choices are;
+
+                * "key": Seek into the nearest key frame before the given timestamp.
+                * "any": Seek into any frame (including non-key frames) before the given timestamp.
+                * "precise": First seek into the nearest key frame before the given timestamp, then
+                  decode frames until it reaches the closes frame to the given timestamp.
+
+                Note:
+                   All the modes invalidate and reset the internal state of decoder.
+                   When using "any" mode and if it ends up seeking into non-key frame,
+                   the image decoded may be invalid due to lack of key frame.
+                   Using "precise" will workaround this issue by decoding frames from previous
+                   key frame, but will be slower.
+        """
+        modes = {
+            "key": 0,
+            "any": 1,
+            "precise": 2,
+        }
+        if mode not in modes:
+            raise ValueError(f"The value of mode must be one of {list(modes.keys())}. Found: {mode}")
+        self._be.seek(timestamp, modes[mode])
+
+    @_format_audio_args
+    def add_basic_audio_stream(
+        self,
+        frames_per_chunk: int,
+        buffer_chunk_size: int = 3,
+        *,
+        stream_index: Optional[int] = None,
+        decoder: Optional[str] = None,
+        decoder_option: Optional[Dict[str, str]] = None,
+        format: Optional[str] = "fltp",
+        sample_rate: Optional[int] = None,
+        num_channels: Optional[int] = None,
+    ):
+        """Add output audio stream
+
+        Args:
+            frames_per_chunk (int): {frames_per_chunk}
+
+            buffer_chunk_size (int, optional): {buffer_chunk_size}
+
+            stream_index (int or None, optional): {stream_index}
+
+            decoder (str or None, optional): {decoder}
+
+            decoder_option (dict or None, optional): {decoder_option}
+
+            format (str, optional): Output sample format (precision).
+
+                If ``None``, the output chunk has dtype corresponding to
+                the precision of the source audio.
+
+                Otherwise, the sample is converted and the output dtype is changed
+                as following.
+
+                - ``"u8p"``: The output is ``torch.uint8`` type.
+                - ``"s16p"``: The output is ``torch.int16`` type.
+                - ``"s32p"``: The output is ``torch.int32`` type.
+                - ``"s64p"``: The output is ``torch.int64`` type.
+                - ``"fltp"``: The output is ``torch.float32`` type.
+                - ``"dblp"``: The output is ``torch.float64`` type.
+
+                Default: ``"fltp"``.
+
+            sample_rate (int or None, optional): If provided, resample the audio.
+
+            num_channels (int, or None, optional): If provided, change the number of channels.
+        """
+        self.add_audio_stream(
+            frames_per_chunk,
+            buffer_chunk_size,
+            stream_index=stream_index,
+            decoder=decoder,
+            decoder_option=decoder_option,
+            filter_desc=_get_afilter_desc(sample_rate, format, num_channels),
+        )
+
+    @_format_video_args
+    def add_basic_video_stream(
+        self,
+        frames_per_chunk: int,
+        buffer_chunk_size: int = 3,
+        *,
+        stream_index: Optional[int] = None,
+        decoder: Optional[str] = None,
+        decoder_option: Optional[Dict[str, str]] = None,
+        format: Optional[str] = "rgb24",
+        frame_rate: Optional[int] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        hw_accel: Optional[str] = None,
+    ):
+        """Add output video stream
+
+        Args:
+            frames_per_chunk (int): {frames_per_chunk}
+
+            buffer_chunk_size (int, optional): {buffer_chunk_size}
+
+            stream_index (int or None, optional): {stream_index}
+
+            decoder (str or None, optional): {decoder}
+
+            decoder_option (dict or None, optional): {decoder_option}
+
+            format (str, optional): Change the format of image channels. Valid values are,
+
+                - ``"rgb24"``: 8 bits * 3 channels (R, G, B)
+                - ``"bgr24"``: 8 bits * 3 channels (B, G, R)
+                - ``"yuv420p"``: 8 bits * 3 channels (Y, U, V)
+                - ``"gray"``: 8 bits * 1 channels
+
+                Default: ``"rgb24"``.
+
+            frame_rate (int or None, optional): If provided, change the frame rate.
+
+            width (int or None, optional): If provided, change the image width. Unit: Pixel.
+
+            height (int or None, optional): If provided, change the image height. Unit: Pixel.
+
+            hw_accel (str or None, optional): {hw_accel}
+        """
+        self.add_video_stream(
+            frames_per_chunk,
+            buffer_chunk_size,
+            stream_index=stream_index,
+            decoder=decoder,
+            decoder_option=decoder_option,
+            filter_desc=_get_vfilter_desc(frame_rate, width, height, format),
+            hw_accel=hw_accel,
+        )
+
+    @_format_audio_args
+    def add_audio_stream(
+        self,
+        frames_per_chunk: int,
+        buffer_chunk_size: int = 3,
+        *,
+        stream_index: Optional[int] = None,
+        decoder: Optional[str] = None,
+        decoder_option: Optional[Dict[str, str]] = None,
+        filter_desc: Optional[str] = None,
+    ):
+        """Add output audio stream
+
+        Args:
+            frames_per_chunk (int): {frames_per_chunk}
+
+            buffer_chunk_size (int, optional): {buffer_chunk_size}
+
+            stream_index (int or None, optional): {stream_index}
+
+            decoder (str or None, optional): {decoder}
+
+            decoder_option (dict or None, optional): {decoder_option}
+
+            filter_desc (str or None, optional): Filter description.
+                The list of available filters can be found at
+                https://ffmpeg.org/ffmpeg-filters.html
+                Note that complex filters are not supported.
+
+        """
+        i = self.default_audio_stream if stream_index is None else stream_index
+        if i is None:
+            raise RuntimeError("There is no audio stream.")
+        self._be.add_audio_stream(
+            i,
+            frames_per_chunk,
+            buffer_chunk_size,
+            filter_desc,
+            decoder,
+            decoder_option or {},
+        )
+
+    @_format_video_args
+    def add_video_stream(
+        self,
+        frames_per_chunk: int,
+        buffer_chunk_size: int = 3,
+        *,
+        stream_index: Optional[int] = None,
+        decoder: Optional[str] = None,
+        decoder_option: Optional[Dict[str, str]] = None,
+        filter_desc: Optional[str] = None,
+        hw_accel: Optional[str] = None,
+    ):
+        """Add output video stream
+
+        Args:
+            frames_per_chunk (int): {frames_per_chunk}
+
+            buffer_chunk_size (int, optional): {buffer_chunk_size}
+
+            stream_index (int or None, optional): {stream_index}
+
+            decoder (str or None, optional): {decoder}
+
+            decoder_option (dict or None, optional): {decoder_option}
+
+            hw_accel (str or None, optional): {hw_accel}
+
+            filter_desc (str or None, optional): Filter description.
+                The list of available filters can be found at
+                https://ffmpeg.org/ffmpeg-filters.html
+                Note that complex filters are not supported.
+        """
+        i = self.default_video_stream if stream_index is None else stream_index
+        if i is None:
+            raise RuntimeError("There is no video stream.")
+        self._be.add_video_stream(
+            i,
+            frames_per_chunk,
+            buffer_chunk_size,
+            filter_desc,
+            decoder,
+            decoder_option or {},
+            hw_accel,
+        )
+
+    def remove_stream(self, i: int):
+        """Remove an output stream.
+
+        Args:
+            i (int): Index of the output stream to be removed.
+        """
+        self._be.remove_stream(i)
+
+    def process_packet(self, timeout: Optional[float] = None, backoff: float = 10.0) -> int:
+        """Read the source media and process one packet.
+
+        If a packet is read successfully, then the data in the packet will
+        be decoded and passed to corresponding output stream processors.
+
+        If the packet belongs to a source stream that is not connected to
+        an output stream, then the data are discarded.
+
+        When the source reaches EOF, then it triggers all the output stream
+        processors to enter drain mode. All the output stream processors
+        flush the pending frames.
+
+        Args:
+            timeout (float or None, optional): Timeout in milli seconds.
+
+                This argument changes the retry behavior when it failed to
+                process a packet due to the underlying media resource being
+                temporarily unavailable.
+
+                When using a media device such as a microphone, there are cases
+                where the underlying buffer is not ready.
+                Calling this function in such case would cause the system to report
+                `EAGAIN (resource temporarily unavailable)`.
+
+                * ``>=0``: Keep retrying until the given time passes.
+
+                * ``0<``: Keep retrying forever.
+
+                * ``None`` : No retrying and raise an exception immediately.
+
+                Default: ``None``.
+
+                Note:
+
+                    The retry behavior is applicable only when the reason is the
+                    unavailable resource. It is not invoked if the reason of failure is
+                    other.
+
+            backoff (float, optional): Time to wait before retrying in milli seconds.
+
+                This option is effective only when `timeout` is effective. (not ``None``)
+
+                When `timeout` is effective, this `backoff` controls how long the function
+                should wait before retrying. Default: ``10.0``.
+
+        Returns:
+            int:
+                ``0``
+                A packet was processed properly. The caller can keep
+                calling this function to buffer more frames.
+
+                ``1``
+                The streamer reached EOF. All the output stream processors
+                flushed the pending frames. The caller should stop calling
+                this method.
+        """
+        return self._be.process_packet(timeout, backoff)
+
+    def process_all_packets(self):
+        """Process packets until it reaches EOF."""
+        self._be.process_all_packets()
+
+    def is_buffer_ready(self) -> bool:
+        """Returns true if all the output streams have at least one chunk filled."""
+        return self._be.is_buffer_ready()
+
+    def pop_chunks(self) -> Tuple[Optional[ChunkTensor]]:
+        """Pop one chunk from all the output stream buffers.
+
+        Returns:
+            Tuple[Optional[ChunkTensor]]:
+                Buffer contents.
+                If a buffer does not contain any frame, then `None` is returned instead.
+        """
+        ret = []
+        for chunk in self._be.pop_chunks():
+            if chunk is None:
+                ret.append(None)
+            else:
+                ret.append(ChunkTensor(chunk.frames, chunk.pts))
+        return ret
+
+    def fill_buffer(self, timeout: Optional[float] = None, backoff: float = 10.0) -> int:
+        """Keep processing packets until all buffers have at least one chunk
+
+        Arguments:
+            timeout (float or None, optional): See
+                :py:func:`~StreamingMediaDecoder.process_packet`. (Default: ``None``)
+
+            backoff (float, optional): See
+                :py:func:`~StreamingMediaDecoder.process_packet`. (Default: ``10.0``)
+
+        Returns:
+            int:
+                ``0``
+                Packets are processed properly and buffers are
+                ready to be popped once.
+
+                ``1``
+                The streamer reached EOF. All the output stream processors
+                flushed the pending frames. The caller should stop calling
+                this method.
+        """
+        return self._be.fill_buffer(timeout, backoff)
+
+    def stream(
+        self, timeout: Optional[float] = None, backoff: float = 10.0
+    ) -> Iterator[Tuple[Optional[ChunkTensor], ...]]:
+        """Return an iterator that generates output tensors
+
+        Arguments:
+            timeout (float or None, optional): See
+                :py:func:`~StreamingMediaDecoder.process_packet`. (Default: ``None``)
+
+            backoff (float, optional): See
+                :py:func:`~StreamingMediaDecoder.process_packet`. (Default: ``10.0``)
+
+        Returns:
+            Iterator[Tuple[Optional[ChunkTensor], ...]]:
+                Iterator that yields a tuple of chunks that correspond to the output
+                streams defined by client code.
+                If an output stream is exhausted, then the chunk Tensor is substituted
+                with ``None``.
+                The iterator stops if all the output streams are exhausted.
+        """
+        if self.num_out_streams == 0:
+            raise RuntimeError("No output stream is configured.")
+
+        while True:
+            if self.fill_buffer(timeout, backoff):
+                break
+            yield self.pop_chunks()
+
+        while True:
+            chunks = self.pop_chunks()
+            if all(c is None for c in chunks):
+                return
+            yield chunks

MLPY/Lib/site-packages/torio/io/_streaming_media_encoder.py

@@ -0,0 +1,502 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO, Dict, Optional, Union
+
+import torch
+import torio
+
+ffmpeg_ext = torio._extension.lazy_import_ffmpeg_ext()
+
+
+@dataclass
+class CodecConfig:
+    """Codec configuration."""
+
+    bit_rate: int = -1
+    """Bit rate"""
+
+    compression_level: int = -1
+    """Compression level"""
+
+    qscale: Optional[int] = None
+    """Global quality factor. Enables variable bit rate. Valid values depend on encoder.
+
+    For example: MP3 takes ``0`` - ``9`` (https://trac.ffmpeg.org/wiki/Encode/MP3) while
+    libvorbis takes ``-1`` - ``10``.
+    """
+
+    gop_size: int = -1
+    """The number of pictures in a group of pictures, or 0 for intra_only"""
+
+    max_b_frames: int = -1
+    """maximum number of B-frames between non-B-frames."""
+
+
+def _convert_config(cfg: CodecConfig):
+    if cfg is None:
+        return None
+    # Convert the codecconfig to C++ compatible type.
+    # omitting the return type annotation so as not to access ffmpeg_ext here.
+    return ffmpeg_ext.CodecConfig(
+        cfg.bit_rate,
+        cfg.compression_level,
+        cfg.qscale,
+        cfg.gop_size,
+        cfg.max_b_frames,
+    )
+
+
+def _format_doc(**kwargs):
+    def decorator(obj):
+        obj.__doc__ = obj.__doc__.format(**kwargs)
+        return obj
+
+    return decorator
+
+
+_encoder = """The name of the encoder to be used.
+                When provided, use the specified encoder instead of the default one.
+
+                To list the available encoders, please use
+                :py:func:`~torio.utils.ffmpeg_utils.get_audio_encoders` for audio, and
+                :py:func:`~torio.utils.ffmpeg_utils.get_video_encoders` for video.
+
+                Default: ``None``."""
+
+
+_encoder_option = """Options passed to encoder.
+                Mapping from str to str.
+
+                To list encoder options for a encoder, you can use
+                ``ffmpeg -h encoder=<ENCODER>`` command.
+
+                Default: ``None``.
+
+                |
+
+                In addition to encoder-specific options, you can also pass options related
+                to multithreading. They are effective only if the encoder support them.
+                If neither of them are provided, StreamReader defaults to single thread.
+
+                ``"threads"``: The number of threads (in str).
+                Providing the value ``"0"`` will let FFmpeg decides based on its heuristics.
+
+                ``"thread_type"``: Which multithreading method to use.
+                The valid values are ``"frame"`` or ``"slice"``.
+                Note that each encoder supports different set of methods.
+                If not provided, a default value is used.
+
+                - ``"frame"``: Encode more than one frame at once.
+                  Each thread handles one frame.
+                  This will increase decoding delay by one frame per thread
+                - ``"slice"``: Encode more than one part of a single frame at once.
+
+                |
+                """
+
+
+_encoder_format = """Format used to encode media.
+                When encoder supports multiple formats, passing this argument will override
+                the format used for encoding.
+
+                To list supported formats for the encoder, you can use
+                ``ffmpeg -h encoder=<ENCODER>`` command.
+
+                Default: ``None``.
+
+                Note:
+                    When ``encoder_format`` option is not provided, encoder uses its default format.
+
+                    For example, when encoding audio into wav format, 16-bit signed integer is used,
+                    and when encoding video into mp4 format (h264 encoder), one of YUV format is used.
+
+                    This is because typically, 32-bit or 16-bit floating point is used in audio models but
+                    they are not commonly used in audio formats. Similarly, RGB24 is commonly used in vision
+                    models, but video formats usually (and better) support YUV formats.
+                """
+
+_codec_config = """Codec configuration. Please refer to :py:class:`CodecConfig` for
+                configuration options.
+
+                Default: ``None``."""
+
+
+_filter_desc = """Additional processing to apply before encoding the input media.
+                """
+
+_format_common_args = _format_doc(
+    encoder=_encoder,
+    encoder_option=_encoder_option,
+    encoder_format=_encoder_format,
+    codec_config=_codec_config,
+    filter_desc=_filter_desc,
+)
+
+
+class StreamingMediaEncoder:
+    """Encode and write audio/video streams chunk by chunk
+
+    Args:
+        dst (str, path-like or file-like object): The destination where the encoded data are written.
+            If string-type, it must be a resource indicator that FFmpeg can
+            handle. The supported value depends on the FFmpeg found in the system.
+
+            If file-like object, it must support `write` method with the signature
+            `write(data: bytes) -> int`.
+
+            Please refer to the following for the expected signature and behavior of
+            `write` method.
+
+            - https://docs.python.org/3/library/io.html#io.BufferedIOBase.write
+
+        format (str or None, optional):
+            Override the output format, or specify the output media device.
+            Default: ``None`` (no override nor device output).
+
+            This argument serves two different use cases.
+
+            1) Override the output format.
+               This is useful when writing raw data or in a format different from the extension.
+
+            2) Specify the output device.
+               This allows to output media streams to hardware devices,
+               such as speaker and video screen.
+
+            .. note::
+
+               This option roughly corresponds to ``-f`` option of ``ffmpeg`` command.
+               Please refer to the ffmpeg documentations for possible values.
+
+               https://ffmpeg.org/ffmpeg-formats.html#Muxers
+
+               Please use :py:func:`~torio.utils.ffmpeg_utils.get_muxers` to list the
+               multiplexers available in the current environment.
+
+               For device access, the available values vary based on hardware (AV device) and
+               software configuration (ffmpeg build).
+               Please refer to the ffmpeg documentations for possible values.
+
+               https://ffmpeg.org/ffmpeg-devices.html#Output-Devices
+
+               Please use :py:func:`~torio.utils.ffmpeg_utils.get_output_devices` to list
+               the output devices available in the current environment.
+
+        buffer_size (int):
+            The internal buffer size in byte. Used only when `dst` is a file-like object.
+
+            Default: `4096`.
+    """
+
+    def __init__(
+        self,
+        dst: Union[str, Path, BinaryIO],
+        format: Optional[str] = None,
+        buffer_size: int = 4096,
+    ):
+        if hasattr(dst, "write"):
+            self._s = ffmpeg_ext.StreamingMediaEncoderFileObj(dst, format, buffer_size)
+        else:
+            self._s = ffmpeg_ext.StreamingMediaEncoder(str(dst), format)
+        self._is_open = False
+
+    @_format_common_args
+    def add_audio_stream(
+        self,
+        sample_rate: int,
+        num_channels: int,
+        format: str = "flt",
+        *,
+        encoder: Optional[str] = None,
+        encoder_option: Optional[Dict[str, str]] = None,
+        encoder_sample_rate: Optional[int] = None,
+        encoder_num_channels: Optional[int] = None,
+        encoder_format: Optional[str] = None,
+        codec_config: Optional[CodecConfig] = None,
+        filter_desc: Optional[str] = None,
+    ):
+        """Add an output audio stream.
+
+        Args:
+            sample_rate (int): The sample rate.
+
+            num_channels (int): The number of channels.
+
+            format (str, optional): Input sample format, which determines the dtype
+                of the input tensor.
+
+                - ``"u8"``: The input tensor must be ``torch.uint8`` type.
+                - ``"s16"``: The input tensor must be ``torch.int16`` type.
+                - ``"s32"``: The input tensor must be ``torch.int32`` type.
+                - ``"s64"``: The input tensor must be ``torch.int64`` type.
+                - ``"flt"``: The input tensor must be ``torch.float32`` type.
+                - ``"dbl"``: The input tensor must be ``torch.float64`` type.
+
+                Default: ``"flt"``.
+
+            encoder (str or None, optional): {encoder}
+
+            encoder_option (dict or None, optional): {encoder_option}
+
+            encoder_sample_rate (int or None, optional): Override the sample rate used for encoding time.
+                Some encoders pose restriction on the sample rate used for encoding.
+                If the source sample rate is not supported by the encoder, the source sample rate is used,
+                otherwise a default one is picked.
+
+                For example, ``"opus"`` encoder only supports 48k Hz, so, when encoding a
+                waveform with ``"opus"`` encoder, it is always encoded as 48k Hz.
+                Meanwhile ``"mp3"`` (``"libmp3lame"``) supports 44.1k, 48k, 32k, 22.05k,
+                24k, 16k, 11.025k, 12k and 8k Hz.
+                If the original sample rate is one of these, then the original sample rate
+                is used, otherwise it will be resampled to a default one (44.1k).
+                When encoding into WAV format, there is no restriction on sample rate,
+                so the original sample rate will be used.
+
+                Providing ``encoder_sample_rate`` will override this behavior and
+                make encoder attempt to use the provided sample rate.
+                The provided value must be one support by the encoder.
+
+            encoder_num_channels (int or None, optional): Override the number of channels used for encoding.
+
+                Similar to sample rate, some encoders (such as ``"opus"``,
+                ``"vorbis"`` and ``"g722"``) pose restriction on
+                the numbe of channels that can be used for encoding.
+
+                If the original number of channels is supported by encoder,
+                then it will be used, otherwise, the encoder attempts to
+                remix the channel to one of the supported ones.
+
+                Providing ``encoder_num_channels`` will override this behavior and
+                make encoder attempt to use the provided number of channels.
+                The provided value must be one support by the encoder.
+
+            encoder_format (str or None, optional): {encoder_format}
+
+            codec_config (CodecConfig or None, optional): {codec_config}
+
+            filter_desc (str or None, optional): {filter_desc}
+        """
+        self._s.add_audio_stream(
+            sample_rate,
+            num_channels,
+            format,
+            encoder,
+            encoder_option,
+            encoder_format,
+            encoder_sample_rate,
+            encoder_num_channels,
+            _convert_config(codec_config),
+            filter_desc,
+        )
+
+    @_format_common_args
+    def add_video_stream(
+        self,
+        frame_rate: float,
+        width: int,
+        height: int,
+        format: str = "rgb24",
+        *,
+        encoder: Optional[str] = None,
+        encoder_option: Optional[Dict[str, str]] = None,
+        encoder_frame_rate: Optional[float] = None,
+        encoder_width: Optional[int] = None,
+        encoder_height: Optional[int] = None,
+        encoder_format: Optional[str] = None,
+        codec_config: Optional[CodecConfig] = None,
+        filter_desc: Optional[str] = None,
+        hw_accel: Optional[str] = None,
+    ):
+        """Add an output video stream.
+
+        This method has to be called before `open` is called.
+
+        Args:
+            frame_rate (float): Frame rate of the video.
+
+            width (int): Width of the video frame.
+
+            height (int): Height of the video frame.
+
+            format (str, optional): Input pixel format, which determines the
+                color channel order of the input tensor.
+
+                - ``"gray8"``: One channel, grayscale.
+                - ``"rgb24"``: Three channels in the order of RGB.
+                - ``"bgr24"``: Three channels in the order of BGR.
+                - ``"yuv444p"``: Three channels in the order of YUV.
+
+                Default: ``"rgb24"``.
+
+                In either case, the input tensor has to be ``torch.uint8`` type and
+                the shape must be (frame, channel, height, width).
+
+            encoder (str or None, optional): {encoder}
+
+            encoder_option (dict or None, optional): {encoder_option}
+
+            encoder_frame_rate (float or None, optional): Override the frame rate used for encoding.
+
+                Some encoders, (such as ``"mpeg1"`` and ``"mpeg2"``) pose restriction on the
+                frame rate that can be used for encoding.
+                If such case, if the source frame rate (provided as ``frame_rate``) is not
+                one of the supported frame rate, then a default one is picked, and the frame rate
+                is changed on-the-fly. Otherwise the source frame rate is used.
+
+                Providing ``encoder_frame_rate`` will override this behavior and
+                make encoder attempts to use the provided sample rate.
+                The provided value must be one support by the encoder.
+
+            encoder_width (int or None, optional): Width of the image used for encoding.
+                This allows to change the image size during encoding.
+
+            encoder_height (int or None, optional): Height of the image used for encoding.
+                This allows to change the image size during encoding.
+
+            encoder_format (str or None, optional): {encoder_format}
+
+            codec_config (CodecConfig or None, optional): {codec_config}
+
+            filter_desc (str or None, optional): {filter_desc}
+
+            hw_accel (str or None, optional): Enable hardware acceleration.
+
+                When video is encoded on CUDA hardware, for example
+                `encoder="h264_nvenc"`, passing CUDA device indicator to `hw_accel`
+                (i.e. `hw_accel="cuda:0"`) will make StreamingMediaEncoder expect video
+                chunk to be CUDA Tensor. Passing CPU Tensor will result in an error.
+
+                If `None`, the video chunk Tensor has to be CPU Tensor.
+                Default: ``None``.
+        """
+        self._s.add_video_stream(
+            frame_rate,
+            width,
+            height,
+            format,
+            encoder,
+            encoder_option,
+            encoder_format,
+            encoder_frame_rate,
+            encoder_width,
+            encoder_height,
+            hw_accel,
+            _convert_config(codec_config),
+            filter_desc,
+        )
+
+    def set_metadata(self, metadata: Dict[str, str]):
+        """Set file-level metadata
+
+        Args:
+            metadata (dict or None, optional): File-level metadata.
+        """
+        self._s.set_metadata(metadata)
+
+    def _print_output_stream(self, i: int):
+        """[debug] Print the registered stream information to stdout."""
+        self._s.dump_format(i)
+
+    def open(self, option: Optional[Dict[str, str]] = None) -> "StreamingMediaEncoder":
+        """Open the output file / device and write the header.
+
+        :py:class:`StreamingMediaEncoder` is also a context manager and therefore supports the
+        ``with`` statement.
+        This method returns the instance on which the method is called (i.e. `self`),
+        so that it can be used in `with` statement.
+        It is recommended to use context manager, as the file is closed automatically
+        when exiting from ``with`` clause.
+
+        Args:
+            option (dict or None, optional): Private options for protocol, device and muxer. See example.
+
+        Example - Protocol option
+            >>> s = StreamingMediaEncoder(dst="rtmp://localhost:1234/live/app", format="flv")
+            >>> s.add_video_stream(...)
+            >>> # Passing protocol option `listen=1` makes StreamingMediaEncoder act as RTMP server.
+            >>> with s.open(option={"listen": "1"}) as f:
+            >>>     f.write_video_chunk(...)
+
+        Example - Device option
+            >>> s = StreamingMediaEncoder("-", format="sdl")
+            >>> s.add_video_stream(..., encoder_format="rgb24")
+            >>> # Open SDL video player with fullscreen
+            >>> with s.open(option={"window_fullscreen": "1"}):
+            >>>     f.write_video_chunk(...)
+
+        Example - Muxer option
+            >>> s = StreamingMediaEncoder("foo.flac")
+            >>> s.add_audio_stream(...)
+            >>> s.set_metadata({"artist": "torio contributors"})
+            >>> # FLAC muxer has a private option to not write the header.
+            >>> # The resulting file does not contain the above metadata.
+            >>> with s.open(option={"write_header": "false"}) as f:
+            >>>     f.write_audio_chunk(...)
+        """
+        if not self._is_open:
+            self._s.open(option)
+            self._is_open = True
+        return self
+
+    def close(self):
+        """Close the output
+
+        :py:class:`StreamingMediaEncoder` is also a context manager and therefore supports the
+        ``with`` statement.
+        It is recommended to use context manager, as the file is closed automatically
+        when exiting from ``with`` clause.
+
+        See :py:meth:`StreamingMediaEncoder.open` for more detail.
+        """
+        if self._is_open:
+            self._s.close()
+            self._is_open = False
+
+    def write_audio_chunk(self, i: int, chunk: torch.Tensor, pts: Optional[float] = None):
+        """Write audio data
+
+        Args:
+            i (int): Stream index.
+            chunk (Tensor): Waveform tensor. Shape: `(frame, channel)`.
+                The ``dtype`` must match what was passed to :py:meth:`add_audio_stream` method.
+            pts (float, optional, or None): If provided, overwrite the presentation timestamp.
+
+                .. note::
+
+                   The provided value is converted to integer value expressed in basis of
+                   sample rate. Therefore, it is truncated to the nearest value of
+                   ``n / sample_rate``.
+        """
+        self._s.write_audio_chunk(i, chunk, pts)
+
+    def write_video_chunk(self, i: int, chunk: torch.Tensor, pts: Optional[float] = None):
+        """Write video/image data
+
+        Args:
+            i (int): Stream index.
+            chunk (Tensor): Video/image tensor.
+                Shape: `(time, channel, height, width)`.
+                The ``dtype`` must be ``torch.uint8``.
+                The shape (height, width and the number of channels) must match
+                what was configured when calling :py:meth:`add_video_stream`
+            pts (float, optional or None): If provided, overwrite the presentation timestamp.
+
+                .. note::
+
+                   The provided value is converted to integer value expressed in basis of
+                   frame rate. Therefore, it is truncated to the nearest value of
+                   ``n / frame_rate``.
+        """
+        self._s.write_video_chunk(i, chunk, pts)
+
+    def flush(self):
+        """Flush the frames from encoders and write the frames to the destination."""
+        self._s.flush()
+
+    def __enter__(self):
+        """Context manager so that the destination is closed and data are flushed automatically."""
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        """Context manager so that the destination is closed and data are flushed automatically."""
+        self.flush()
+        self.close()

MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg4.pyd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:144cdcf7ee3bf60d2589dccd6a17a127218ae38a4c99b2ab25519e9c46448090
+size 1710080

MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg5.pyd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8a912dc0691b65075b20ebbdd517946b52da49600fb47ccd31fe7d6a2ea464c
+size 1710080

MLPY/Lib/site-packages/torio/lib/_torio_ffmpeg6.pyd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a54d9a42baf649f5d759862f499e3c3863b634e2b44d957a31fae39092f03387
+size 1710080

MLPY/Lib/site-packages/torio/utils/__init__.py

@@ -0,0 +1,4 @@
+from . import ffmpeg_utils
+
+
+__all__ = ["ffmpeg_utils"]

MLPY/Lib/site-packages/torio/utils/ffmpeg_utils.py

@@ -0,0 +1,247 @@
+"""Module to change the configuration of FFmpeg libraries (such as libavformat).
+
+It affects functionalities in :py:mod:`torio.io`.
+"""
+from typing import Dict, List, Tuple
+
+import torio
+
+ffmpeg_ext = torio._extension.lazy_import_ffmpeg_ext()
+
+
+def get_versions() -> Dict[str, Tuple[int]]:
+    """Get the versions of FFmpeg libraries
+
+    Returns:
+        dict: mapping from library names to version string,
+            i.e. `"libavutil": (56, 22, 100)`.
+    """
+    return ffmpeg_ext.get_versions()
+
+
+def get_log_level() -> int:
+    """Get the log level of FFmpeg.
+
+    See :py:func:`set_log_level` for the detail.
+    """
+    return ffmpeg_ext.get_log_level()
+
+
+def set_log_level(level: int):
+    """Set the log level of FFmpeg (libavformat etc)
+
+    Arguments:
+        level (int): Log level. The larger, the more verbose.
+
+            The following values are common values, the corresponding ``ffmpeg``'s
+            ``-loglevel`` option value and desription.
+
+                * ``-8`` (``quiet``):
+                  Print no output.
+                * ``0`` (``panic``):
+                  Something went really wrong and we will crash now.
+                * ``8`` (``fatal``):
+                  Something went wrong and recovery is not possible.
+                  For example, no header was found for a format which depends
+                  on headers or an illegal combination of parameters is used.
+                * ``16`` (``error``):
+                  Something went wrong and cannot losslessly be recovered.
+                  However, not all future data is affected.
+                * ``24`` (``warning``):
+                  Something somehow does not look correct.
+                  This may or may not lead to problems.
+                * ``32`` (``info``):
+                  Standard information.
+                * ``40`` (``verbose``):
+                  Detailed information.
+                * ``48`` (``debug``):
+                  Stuff which is only useful for libav* developers.
+                * ``56`` (``trace``):
+                  Extremely verbose debugging, useful for libav* development.
+
+    """
+    ffmpeg_ext.set_log_level(level)
+
+
+def get_demuxers() -> Dict[str, str]:
+    """Get the available demuxers.
+
+    Returns:
+        Dict[str, str]: Mapping from demuxer (format) short name to long name.
+
+    Example
+        >>> for k, v in get_demuxers().items():
+        >>>     print(f"{k}: {v}")
+        ... aa: Audible AA format files
+        ... aac: raw ADTS AAC (Advanced Audio Coding)
+        ... aax: CRI AAX
+        ... ac3: raw AC-3
+    """
+    return ffmpeg_ext.get_demuxers()
+
+
+def get_muxers() -> Dict[str, str]:
+    """Get the available muxers.
+
+    Returns:
+        Dict[str, str]: Mapping from muxer (format) short name to long name.
+
+    Example
+        >>> for k, v in get_muxers().items():
+        >>>     print(f"{k}: {v}")
+        ... a64: a64 - video for Commodore 64
+        ... ac3: raw AC-3
+        ... adts: ADTS AAC (Advanced Audio Coding)
+        ... adx: CRI ADX
+        ... aiff: Audio IFF
+    """
+    return ffmpeg_ext.get_muxers()
+
+
+def get_audio_decoders() -> Dict[str, str]:
+    """Get the available audio decoders.
+
+    Returns:
+        Dict[str, str]: Mapping from decoder short name to long name.
+
+    Example
+        >>> for k, v in get_audio_decoders().items():
+        >>>     print(f"{k}: {v}")
+        ... a64: a64 - video for Commodore 64
+        ... ac3: raw AC-3
+        ... adts: ADTS AAC (Advanced Audio Coding)
+        ... adx: CRI ADX
+        ... aiff: Audio IFF
+    """
+    return ffmpeg_ext.get_audio_decoders()
+
+
+def get_audio_encoders() -> Dict[str, str]:
+    """Get the available audio encoders.
+
+    Returns:
+        Dict[str, str]: Mapping from encoder short name to long name.
+
+    Example
+        >>> for k, v in get_audio_encoders().items():
+        >>>     print(f"{k}: {v}")
+        ... comfortnoise: RFC 3389 comfort noise generator
+        ... s302m: SMPTE 302M
+        ... aac: AAC (Advanced Audio Coding)
+        ... ac3: ATSC A/52A (AC-3)
+        ... ac3_fixed: ATSC A/52A (AC-3)
+        ... alac: ALAC (Apple Lossless Audio Codec)
+    """
+    return ffmpeg_ext.get_audio_encoders()
+
+
+def get_video_decoders() -> Dict[str, str]:
+    """Get the available video decoders.
+
+    Returns:
+        Dict[str, str]: Mapping from decoder short name to long name.
+
+    Example
+        >>> for k, v in get_video_decoders().items():
+        >>>     print(f"{k}: {v}")
+        ... aasc: Autodesk RLE
+        ... aic: Apple Intermediate Codec
+        ... alias_pix: Alias/Wavefront PIX image
+        ... agm: Amuse Graphics Movie
+        ... amv: AMV Video
+        ... anm: Deluxe Paint Animation
+    """
+    return ffmpeg_ext.get_video_decoders()
+
+
+def get_video_encoders() -> Dict[str, str]:
+    """Get the available video encoders.
+
+    Returns:
+        Dict[str, str]: Mapping from encoder short name to long name.
+
+    Example
+        >>> for k, v in get_audio_encoders().items():
+        >>>     print(f"{k}: {v}")
+        ... a64multi: Multicolor charset for Commodore 64
+        ... a64multi5: Multicolor charset for Commodore 64, extended with 5th color (colram)
+        ... alias_pix: Alias/Wavefront PIX image
+        ... amv: AMV Video
+        ... apng: APNG (Animated Portable Network Graphics) image
+        ... asv1: ASUS V1
+        ... asv2: ASUS V2
+    """
+    return ffmpeg_ext.get_video_encoders()
+
+
+def get_input_devices() -> Dict[str, str]:
+    """Get the available input devices.
+
+    Returns:
+        Dict[str, str]: Mapping from device short name to long name.
+
+    Example
+        >>> for k, v in get_input_devices().items():
+        >>>     print(f"{k}: {v}")
+        ... avfoundation: AVFoundation input device
+        ... lavfi: Libavfilter virtual input device
+    """
+    return ffmpeg_ext.get_input_devices()
+
+
+def get_output_devices() -> Dict[str, str]:
+    """Get the available output devices.
+
+    Returns:
+        Dict[str, str]: Mapping from device short name to long name.
+
+    Example
+        >>> for k, v in get_output_devices().items():
+        >>>     print(f"{k}: {v}")
+        ... audiotoolbox: AudioToolbox output device
+    """
+    return ffmpeg_ext.get_output_devices()
+
+
+def get_input_protocols() -> List[str]:
+    """Get the supported input protocols.
+
+    Returns:
+        List[str]: The names of supported input protocols
+
+    Example
+        >>> print(get_input_protocols())
+        ... ['file', 'ftp', 'hls', 'http','https', 'pipe', 'rtmp', 'tcp', 'tls', 'udp', 'unix']
+    """
+    return ffmpeg_ext.get_input_protocols()
+
+
+def get_output_protocols() -> List[str]:
+    """Get the supported output protocols.
+
+    Returns:
+        list of str: The names of supported output protocols
+
+    Example
+        >>> print(get_output_protocols())
+        ... ['file', 'ftp', 'http', 'https', 'md5', 'pipe', 'prompeg', 'rtmp', 'tee', 'tcp', 'tls', 'udp', 'unix']
+    """
+    return ffmpeg_ext.get_output_protocols()
+
+
+def get_build_config() -> str:
+    """Get the FFmpeg build configuration
+
+    Returns:
+        str: Build configuration string.
+
+    Example
+        >>> print(get_build_config())
+        --prefix=/Users/runner/miniforge3 --cc=arm64-apple-darwin20.0.0-clang --enable-gpl --enable-hardcoded-tables --enable-libfreetype --enable-libopenh264 --enable-neon --enable-libx264 --enable-libx265 --enable-libaom --enable-libsvtav1 --enable-libxml2 --enable-libvpx --enable-pic --enable-pthreads --enable-shared --disable-static --enable-version3 --enable-zlib --enable-libmp3lame --pkg-config=/Users/runner/miniforge3/conda-bld/ffmpeg_1646229390493/_build_env/bin/pkg-config --enable-cross-compile --arch=arm64 --target-os=darwin --cross-prefix=arm64-apple-darwin20.0.0- --host-cc=/Users/runner/miniforge3/conda-bld/ffmpeg_1646229390493/_build_env/bin/x86_64-apple-darwin13.4.0-clang  # noqa
+    """
+    return ffmpeg_ext.get_build_config()
+
+
+def clear_cuda_context_cache():
+    """Clear the CUDA context used by CUDA Hardware accelerated video decoding"""
+    ffmpeg_ext.clear_cuda_context_cache()

MLPY/Lib/site-packages/typing_extensions-4.12.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

MLPY/Lib/site-packages/typing_extensions-4.12.2.dist-info/LICENSE

@@ -0,0 +1,279 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

MLPY/Lib/site-packages/typing_extensions-4.12.2.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: typing_extensions
+Version: 4.12.2
+Summary: Backported and Experimental Type Hints for Python 3.8+
+Keywords: annotations,backport,checker,checking,function,hinting,hints,type,typechecking,typehinting,typehints,typing
+Author-email: "Guido van Rossum, Jukka Lehtosalo, Łukasz Langa, Michael Lee" <[email protected]>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Project-URL: Bug Tracker, https://github.com/python/typing_extensions/issues
+Project-URL: Changes, https://github.com/python/typing_extensions/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://typing-extensions.readthedocs.io/
+Project-URL: Home, https://github.com/python/typing_extensions
+Project-URL: Q & A, https://github.com/python/typing/discussions
+Project-URL: Repository, https://github.com/python/typing_extensions
+
+# Typing Extensions
+
+[![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing)
+
+[Documentation](https://typing-extensions.readthedocs.io/en/latest/#) –
+[PyPI](https://pypi.org/project/typing-extensions/)
+
+## Overview
+
+The `typing_extensions` module serves two related purposes:
+
+- Enable use of new type system features on older Python versions. For example,
+  `typing.TypeGuard` is new in Python 3.10, but `typing_extensions` allows
+  users on previous Python versions to use it too.
+- Enable experimentation with new type system PEPs before they are accepted and
+  added to the `typing` module.
+
+`typing_extensions` is treated specially by static type checkers such as
+mypy and pyright. Objects defined in `typing_extensions` are treated the same
+way as equivalent forms in `typing`.
+
+`typing_extensions` uses
+[Semantic Versioning](https://semver.org/). The
+major version will be incremented only for backwards-incompatible changes.
+Therefore, it's safe to depend
+on `typing_extensions` like this: `typing_extensions >=x.y, <(x+1)`,
+where `x.y` is the first version that includes all features you need.
+
+## Included items
+
+See [the documentation](https://typing-extensions.readthedocs.io/en/latest/#) for a
+complete listing of module contents.
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/python/typing_extensions/blob/main/CONTRIBUTING.md)
+for how to contribute to `typing_extensions`.
+

MLPY/Lib/site-packages/typing_extensions-4.12.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+__pycache__/typing_extensions.cpython-39.pyc,,
+typing_extensions-4.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+typing_extensions-4.12.2.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
+typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjWx-N8TOznM9UGW5Gm2DicVpDtRA8W0,3018
+typing_extensions-4.12.2.dist-info/RECORD,,
+typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451

MLPY/Lib/site-packages/typing_extensions-4.12.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any