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