Add files using upload-large-folder tool

.gitattributes

@@ -375,3 +375,7 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pkg_resourc
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/__pycache__/backend_bases.cpython-38.pyc filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/lxml/objectify.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/__pycache__/figure.cpython-38.pyc filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/__pycache__/patches.cpython-38.pyc filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBolIta.ttf filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralItalic.ttf filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Bold.ttf filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/config/__init__.py

@@ -0,0 +1,16 @@
+from .extensions import (
+    extension_list,
+    known_extensions,
+    FileExtension,
+    video_extensions,
+)
+from .plugins import known_plugins, PluginConfig
+
+__all__ = [
+    "known_plugins",
+    "PluginConfig",
+    "extension_list",
+    "known_extensions",
+    "FileExtension",
+    "video_extensions",
+]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/config/extensions.py

@@ -0,0 +1,1919 @@
+"""
+A set of objects representing each file extension recognized by ImageIO. If an
+extension is not listed here it is still supported, as long as there exists a
+supporting backend.
+
+"""
+
+
+class FileExtension:
+    """File Extension Metadata
+
+    This class holds information about a image file format associated with a
+    given extension. This information is used to track plugins that are known to
+    be able to handle a particular format. It also contains additional
+    information about a format, which is used when creating the supported format
+    docs.
+
+    Plugins known to be able to handle this format are ordered by a ``priority``
+    list. This list is used to determine the ideal plugin to use when choosing a
+    plugin based on file extension.
+
+    Parameters
+    ----------
+    extension : str
+        The name of the extension including the initial dot, e.g. ".png".
+    priority : List
+        A list of plugin names (entries in config.known_plugins) that can handle
+        this format. The position of a plugin expresses a preference, e.g.
+        ["plugin1", "plugin2"] indicates that, if available, plugin1 should be
+        preferred over plugin2 when handling a request related to this format.
+    name : str
+        The full name of the format.
+    description : str
+        A description of the format.
+    external_link : str
+        A link to further information about the format. Typically, the format's
+        specification.
+
+    Examples
+    --------
+    >>> FileExtension(
+            name="Bitmap",
+            extension=".bmp",
+            priority=["pillow", "BMP-PIL", "BMP-FI", "ITK"],
+            external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+        )
+
+    """
+
+    def __init__(
+        self, *, extension, priority, name=None, description=None, external_link=None
+    ):
+        self.extension = extension
+        self.priority = priority
+        self.name = name
+        self.description = description
+        self.external_link = external_link
+        self.default_priority = priority.copy()
+
+    def reset(self):
+        self.priority = self.default_priority.copy()
+
+
+extension_list = [
+    FileExtension(
+        name="Hasselblad raw",
+        extension=".3fr",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Sony alpha",
+        extension=".arw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Animated Portable Network Graphics",
+        external_link="https://en.wikipedia.org/wiki/APNG",
+        extension=".apng",
+        priority=["pillow", "pyav"],
+    ),
+    FileExtension(
+        name="Audio Video Interleave",
+        extension=".avi",
+        priority=["FFMPEG"],
+    ),
+    FileExtension(
+        name="Casio raw format",
+        extension=".bay",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".blp",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Bitmap",
+        extension=".bmp",
+        priority=["pillow", "BMP-PIL", "BMP-FI", "ITK", "pyav", "opencv"],
+        external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+    ),
+    FileExtension(
+        name="Device-Independent Bitmap",
+        extension=".dip",
+        priority=["opencv"],
+        external_link="https://en.wikipedia.org/wiki/BMP_file_format",
+    ),
+    FileExtension(
+        name="Re-Volt mipmap",
+        extension=".bmq",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Binary Structured Data Format",
+        extension=".bsdf",
+        priority=["BSDF"],
+        external_link="http://bsdf.io/",
+    ),
+    FileExtension(
+        name="Binary Universal Form for the Representation of meteorological data",
+        extension=".bufr",
+        priority=["pillow", "BUFR-PIL"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".bw",
+        priority=["pillow", "SGI-PIL", "SGI-FI"],
+    ),
+    FileExtension(
+        name="Scirra Construct",
+        extension=".cap",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="AMETEK High Speed Camera Format",
+        extension=".cine",
+        priority=["RAW-FI"],
+        external_link="https://phantomhighspeed-knowledge.secure.force.com/servlet/fileField?id=0BE1N000000kD2i#:~:text=Cine%20is%20a%20video%20file,camera%20model%20and%20image%20resolution",
+    ),
+    FileExtension(extension=".cr2", priority=["RAW-FI"]),
+    FileExtension(
+        extension=".crw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".cs1",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Computerized Tomography",
+        extension=".ct",
+        priority=["DICOM"],
+    ),
+    FileExtension(
+        name="Windows Cursor Icons",
+        extension=".cur",
+        priority=["pillow", "CUR-PIL"],
+    ),
+    FileExtension(
+        name="Dr. Halo",
+        extension=".cut",
+        priority=["CUT-FI"],
+    ),
+    FileExtension(
+        extension=".dc2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="DICOM file format",
+        extension=".dcm",
+        priority=["DICOM", "ITK"],
+    ),
+    FileExtension(
+        extension=".dcr",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Intel DCX",
+        extension=".dcx",
+        priority=["pillow", "DCX-PIL"],
+    ),
+    FileExtension(
+        name="DirectX Texture Container",
+        extension=".dds",
+        priority=["pillow", "DDS-FI", "DDS-PIL"],
+    ),
+    FileExtension(
+        name="Windows Bitmap",
+        extension=".dib",
+        priority=["pillow", "DIB-PIL"],
+    ),
+    FileExtension(
+        name="DICOM file format",
+        extension=".dicom",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".dng",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".drf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".dsc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Enhanced Compression Wavelet",
+        extension=".ecw",
+        priority=["GDAL"],
+    ),
+    FileExtension(
+        name="Windows Metafile",
+        extension=".emf",
+        priority=["pillow", "WMF-PIL"],
+    ),
+    FileExtension(
+        name="Encapsulated Postscript",
+        extension=".eps",
+        priority=["pillow", "EPS-PIL"],
+    ),
+    FileExtension(
+        extension=".erf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="ILM OpenEXR",
+        extension=".exr",
+        priority=["EXR-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        extension=".fff",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fit",
+        priority=["pillow", "FITS-PIL", "FITS"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fits",
+        priority=["pillow", "FITS-PIL", "FITS", "pyav"],
+    ),
+    FileExtension(
+        name="Autodesk FLC Animation",
+        extension=".flc",
+        priority=["pillow", "FLI-PIL"],
+    ),
+    FileExtension(
+        name="Autodesk FLI Animation",
+        extension=".fli",
+        priority=["pillow", "FLI-PIL"],
+    ),
+    FileExtension(
+        name="Kodak FlashPix",
+        extension=".fpx",
+        priority=["pillow", "FPX-PIL"],
+    ),
+    FileExtension(
+        name="Independence War 2: Edge Of Chaos Texture Format",
+        extension=".ftc",
+        priority=["pillow", "FTEX-PIL"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fts",
+        priority=["FITS"],
+    ),
+    FileExtension(
+        name="Independence War 2: Edge Of Chaos Texture Format",
+        extension=".ftu",
+        priority=["pillow", "FTEX-PIL"],
+    ),
+    FileExtension(
+        name="Flexible Image Transport System File",
+        extension=".fz",
+        priority=["FITS"],
+    ),
+    FileExtension(
+        name="Raw fax format CCITT G.3",
+        extension=".g3",
+        priority=["G3-FI"],
+    ),
+    FileExtension(
+        name="GIMP brush file",
+        extension=".gbr",
+        priority=["pillow", "GBR-PIL"],
+    ),
+    FileExtension(
+        name="Grassroots DICOM",
+        extension=".gdcm",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Graphics Interchange Format",
+        extension=".gif",
+        priority=["pillow", "GIF-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="UMDS GIPL",
+        extension=".gipl",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="gridded meteorological data",
+        extension=".grib",
+        priority=["pillow", "GRIB-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".h5",
+        priority=["pillow", "HDF5-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".hdf",
+        priority=["pillow", "HDF5-PIL"],
+    ),
+    FileExtension(
+        name="Hierarchical Data Format 5",
+        extension=".hdf5",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".hdp",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        name="High Dynamic Range Image",
+        extension=".hdr",
+        priority=["HDR-FI", "ITK", "opencv"],
+    ),
+    FileExtension(
+        extension=".ia",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".icb",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Mac OS Icon File",
+        extension=".icns",
+        priority=["pillow", "ICNS-PIL"],
+    ),
+    FileExtension(
+        name="Windows Icon File",
+        extension=".ico",
+        priority=["pillow", "ICO-FI", "ICO-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="ILBM Interleaved Bitmap",
+        extension=".iff",
+        priority=["IFF-FI"],
+    ),
+    FileExtension(
+        name="IPTC/NAA",
+        extension=".iim",
+        priority=["pillow", "IPTC-PIL"],
+    ),
+    FileExtension(
+        extension=".iiq",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="IFUNC Image Memory",
+        extension=".im",
+        priority=["pillow", "IM-PIL"],
+    ),
+    FileExtension(
+        extension=".img",
+        priority=["ITK", "GDAL"],
+    ),
+    FileExtension(
+        extension=".img.gz",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="IM Tools",
+        extension=".IMT",
+        priority=["pillow", "IMT-PIL"],
+    ),
+    FileExtension(
+        name="Image Processing Lab",
+        extension=".ipl",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".j2c",
+        priority=["pillow", "J2K-FI", "JPEG2000-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".j2k",
+        priority=["pillow", "J2K-FI", "JPEG2000-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jfif",
+        priority=["pillow", "JPEG-PIL"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jif",
+        priority=["JPEG-FI"],
+    ),
+    FileExtension(
+        name="JPEG Network Graphics",
+        extension=".jng",
+        priority=["JNG-FI"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jp2",
+        priority=["pillow", "JP2-FI", "JPEG2000-PIL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpc",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="JPEG",
+        extension=".jpe",
+        priority=["pillow", "JPEG-FI", "JPEG-PIL", "opencv"],
+    ),
+    FileExtension(
+        name="Joint Photographic Experts Group",
+        extension=".jpeg",
+        priority=["pillow", "JPEG-PIL", "JPEG-FI", "ITK", "GDAL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpf",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="Joint Photographic Experts Group",
+        extension=".jpg",
+        priority=["pillow", "JPEG-PIL", "JPEG-FI", "ITK", "GDAL", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="JPEG 2000",
+        extension=".jpx",
+        priority=["pillow", "JPEG2000-PIL"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".jxr",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        extension=".k25",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".kc2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".kdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="C64 Koala Graphics",
+        extension=".koa",
+        priority=["KOALA-FI"],
+    ),
+    FileExtension(
+        name="ILBM Interleaved Bitmap",
+        extension=".lbm",
+        priority=["IFF-FI"],
+    ),
+    FileExtension(
+        name="Lytro F01",
+        extension=".lfp",
+        priority=["LYTRO-LFP"],
+    ),
+    FileExtension(
+        name="Lytro Illum",
+        extension=".lfr",
+        priority=["LYTRO-LFR"],
+    ),
+    FileExtension(
+        name="ZEISS LSM",
+        extension=".lsm",
+        priority=["ITK", "TIFF"],
+    ),
+    FileExtension(
+        name="McIdas area file",
+        extension=".MCIDAS",
+        priority=["pillow", "MCIDAS-PIL"],
+        external_link="https://www.ssec.wisc.edu/mcidas/doc/prog_man/2003print/progman2003-formats.html",
+    ),
+    FileExtension(
+        extension=".mdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".mef",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="FreeSurfer File Format",
+        extension=".mgh",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="ITK MetaImage",
+        extension=".mha",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="ITK MetaImage Header",
+        extension=".mhd",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Microsoft Image Composer",
+        extension=".mic",
+        priority=["pillow", "MIC-PIL"],
+    ),
+    FileExtension(
+        name="Matroska Multimedia Container",
+        extension=".mkv",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Medical Imaging NetCDF",
+        extension=".mnc",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Medical Imaging NetCDF 2",
+        extension=".mnc2",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Leaf Raw Image Format",
+        extension=".mos",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="QuickTime File Format",
+        extension=".mov",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="MPEG-4 Part 14",
+        extension=".mp4",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="MPEG-1 Moving Picture Experts Group",
+        extension=".mpeg",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Moving Picture Experts Group",
+        extension=".mpg",
+        priority=["pillow", "FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="JPEG Multi-Picture Format",
+        extension=".mpo",
+        priority=["pillow", "MPO-PIL"],
+    ),
+    FileExtension(
+        name="Magnetic resonance imaging",
+        extension=".mri",
+        priority=["DICOM"],
+    ),
+    FileExtension(
+        extension=".mrw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Windows Paint",
+        extension=".msp",
+        priority=["pillow", "MSP-PIL"],
+    ),
+    FileExtension(
+        extension=".nef",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".nhdr",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nia",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nii",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="nii.gz",
+        extension=".nii.gz",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Numpy Array",
+        extension=".npz",
+        priority=["NPZ"],
+    ),
+    FileExtension(
+        extension=".nrrd",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        extension=".nrw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".orf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".palm",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        name="Portable Bitmap",
+        extension=".pbm",
+        priority=["PGM-FI", "PGMRAW-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Kodak PhotoCD",
+        extension=".pcd",
+        priority=["pillow", "PCD-FI", "PCD-PIL"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pct",
+        priority=["PICT-FI"],
+    ),
+    FileExtension(
+        name="Zsoft Paintbrush",
+        extension=".PCX",
+        priority=["pillow", "PCX-FI", "PCX-PIL"],
+    ),
+    FileExtension(
+        extension=".pdf",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".pef",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".pfm",
+        priority=["PFM-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Greymap",
+        extension=".pgm",
+        priority=["pillow", "PGM-FI", "PGMRAW-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pic",
+        priority=["PICT-FI", "ITK", "opencv"],
+    ),
+    FileExtension(
+        name="Macintosh PICT",
+        extension=".pict",
+        priority=["PICT-FI"],
+    ),
+    FileExtension(
+        name="Portable Network Graphics",
+        extension=".png",
+        priority=["pillow", "PNG-PIL", "PNG-FI", "ITK", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Image Format",
+        extension=".pnm",
+        priority=["pillow", "opencv"],
+    ),
+    FileExtension(
+        name="Pbmplus image",
+        extension=".ppm",
+        priority=["pillow", "PPM-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="Pbmplus image",
+        extension=".pbm",
+        priority=["pillow", "PPM-PIL", "PPM-FI"],
+    ),
+    FileExtension(
+        name="Portable image format",
+        extension=".pxm",
+        priority=["opencv"],
+    ),
+    FileExtension(
+        name="Portable Pixelmap (ASCII)",
+        extension=".ppm",
+        priority=["PPM-FI", "opencv"],
+    ),
+    FileExtension(
+        name="Portable Pixelmap (Raw)",
+        extension=".ppm",
+        priority=["PPMRAW-FI"],
+    ),
+    FileExtension(
+        name="Ghostscript",
+        extension=".ps",
+        priority=["pillow", "EPS-PIL"],
+    ),
+    FileExtension(
+        name="Adope Photoshop 2.5 and 3.0",
+        extension=".psd",
+        priority=["pillow", "PSD-PIL", "PSD-FI"],
+    ),
+    FileExtension(
+        extension=".ptx",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".pxn",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="PIXAR raster image",
+        extension=".pxr",
+        priority=["pillow", "PIXAR-PIL"],
+    ),
+    FileExtension(
+        extension=".qtk",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".raf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Sun Raster File",
+        extension=".ras",
+        priority=["pillow", "SUN-PIL", "RAS-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Sun Raster File",
+        extension=".sr",
+        priority=["opencv"],
+    ),
+    FileExtension(
+        extension=".raw",
+        priority=["RAW-FI", "LYTRO-ILLUM-RAW", "LYTRO-F01-RAW"],
+    ),
+    FileExtension(
+        extension=".rdc",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".rgb",
+        priority=["pillow", "SGI-PIL"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".rgba",
+        priority=["pillow", "SGI-PIL"],
+    ),
+    FileExtension(
+        extension=".rw2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".rwl",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".rwz",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        name="Silicon Graphics Image",
+        extension=".sgi",
+        priority=["pillow", "SGI-PIL", "pyav"],
+    ),
+    FileExtension(
+        name="SPE File Format",
+        extension=".spe",
+        priority=["SPE"],
+    ),
+    FileExtension(
+        extension=".SPIDER",
+        priority=["pillow", "SPIDER-PIL"],
+    ),
+    FileExtension(
+        extension=".sr2",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".srf",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".srw",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".sti",
+        priority=["RAW-FI"],
+    ),
+    FileExtension(
+        extension=".stk",
+        priority=["TIFF"],
+    ),
+    FileExtension(
+        name="ShockWave Flash",
+        extension=".swf",
+        priority=["SWF", "pyav"],
+    ),
+    FileExtension(
+        name="Truevision TGA",
+        extension=".targa",
+        priority=["pillow", "TARGA-FI"],
+    ),
+    FileExtension(
+        name="Truevision TGA",
+        extension=".tga",
+        priority=["pillow", "TGA-PIL", "TARGA-FI", "pyav"],
+    ),
+    FileExtension(
+        name="Tagged Image File",
+        extension=".tif",
+        priority=[
+            "TIFF",
+            "pillow",
+            "TIFF-PIL",
+            "TIFF-FI",
+            "FEI",
+            "ITK",
+            "GDAL",
+            "pyav",
+            "opencv",
+        ],
+    ),
+    FileExtension(
+        name="Tagged Image File Format",
+        extension=".tiff",
+        priority=[
+            "TIFF",
+            "pillow",
+            "TIFF-PIL",
+            "TIFF-FI",
+            "FEI",
+            "ITK",
+            "GDAL",
+            "pyav",
+            "opencv",
+        ],
+    ),
+    FileExtension(
+        extension=".vda",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".vst",
+        priority=["pillow"],
+    ),
+    FileExtension(
+        extension=".vtk",
+        priority=["ITK"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wap",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wbm",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="Wireless Bitmap",
+        extension=".wbmp",
+        priority=["WBMP-FI"],
+    ),
+    FileExtension(
+        name="JPEG Extended Range",
+        extension=".wdp",
+        priority=["JPEG-XR-FI"],
+    ),
+    FileExtension(
+        name="Matroska",
+        extension=".webm",
+        priority=["FFMPEG", "pyav"],
+    ),
+    FileExtension(
+        name="Google WebP",
+        extension=".webp",
+        priority=["pillow", "WEBP-FI", "pyav", "opencv"],
+    ),
+    FileExtension(
+        name="Windows Meta File",
+        extension=".wmf",
+        priority=["pillow", "WMF-PIL"],
+    ),
+    FileExtension(
+        name="Windows Media Video",
+        extension=".wmv",
+        priority=["FFMPEG"],
+    ),
+    FileExtension(
+        name="X11 Bitmap",
+        extension=".xbm",
+        priority=["pillow", "XBM-PIL", "XBM-FI", "pyav"],
+    ),
+    FileExtension(
+        name="X11 Pixel Map",
+        extension=".xpm",
+        priority=["pillow", "XPM-PIL", "XPM-FI"],
+    ),
+    FileExtension(
+        name="Thumbnail Image",
+        extension=".XVTHUMB",
+        priority=["pillow", "XVTHUMB-PIL"],
+    ),
+    FileExtension(
+        extension=".dpx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im1",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im24",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".im8",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".jls",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".ljpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pam",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pcx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pgmyuv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".pix",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".ppm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".rs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".sun",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".sunras",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".xface",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".xwd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        extension=".y",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP (3GPP file format)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GP2 (3GPP2 file format)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="3GPP AMR",
+        extension=".amr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="a64 - video for Commodore 64",
+        extension=".A64",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="a64 - video for Commodore 64",
+        extension=".a64",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Adobe Filmstrip",
+        extension=".flm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AMV",
+        extension=".amv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".asf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".asf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".wmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="ASF (Advanced / Active Streaming Format)",
+        extension=".wmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AV1 Annex B",
+        extension=".obu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AV1 low overhead OBU",
+        extension=".obu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AVI (Audio Video Interleaved)",
+        extension=".avi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="AVR (Audio Visual Research)",
+        extension=".avr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Beam Software SIFF",
+        extension=".vb",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="CD Graphics",
+        extension=".cdg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Commodore CDXL video",
+        extension=".cdxl",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Commodore CDXL video",
+        extension=".xl",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DASH Muxer",
+        extension=".mpd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Digital Pictures SGA",
+        extension=".sga",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Discworld II BMV",
+        extension=".bmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DV (Digital Video)",
+        extension=".dif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="DV (Digital Video)",
+        extension=".dv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="F4V Adobe Flash Video",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="FLV (Flash Video)",
+        extension=".flv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="GXF (General eXchange Format)",
+        extension=".gxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iCE Draw File",
+        extension=".idf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="IFV CCTV DVR",
+        extension=".ifv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="iPod H.264 MP4 (MPEG-4 Part 14)",
+        extension=".m4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="IVR (Internet Video Recording)",
+        extension=".ivr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Konami PS2 SVAG",
+        extension=".svag",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="KUX (YouKu)",
+        extension=".kux",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="live RTMP FLV (Flash Video)",
+        extension=".flv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Loki SDL MJPEG",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="LVF",
+        extension=".lvf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mk3d",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mka",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Matroska / WebM",
+        extension=".mks",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Microsoft XMV",
+        extension=".xmv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MIME multipart JPEG",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MobiClip MODS",
+        extension=".mods",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MobiClip MOFLEX",
+        extension=".moflex",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Motion Pixels MVI",
+        extension=".mvi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MP4 (MPEG-4 Part 14)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (DVD VOB)",
+        extension=".dvd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (SVCD)",
+        extension=".vob",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-2 PS (VOB)",
+        extension=".vob",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".m2t",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".m2ts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".mts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MPEG-TS (MPEG-2 Transport Stream)",
+        extension=".ts",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Musepack",
+        extension=".mpc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MXF (Material eXchange Format) Operational Pattern Atom",
+        extension=".mxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MXF (Material eXchange Format)",
+        extension=".mxf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="MxPEG clip",
+        extension=".mxg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="NC camera feed",
+        extension=".v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="NUT",
+        extension=".nut",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Ogg Video",
+        extension=".ogv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Ogg",
+        extension=".ogg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="On2 IVF",
+        extension=".ivf",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="PSP MP4 (MPEG-4 Part 14)",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Psygnosis YOP",
+        extension=".yop",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".3g2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".3gp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".f4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".ism",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".isma",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".ismv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".m4a",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".m4b",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".mj2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="QuickTime / MOV",
+        extension=".psp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS2-P2/IEEE1857.4 video",
+        extension=".avs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS2-P2/IEEE1857.4 video",
+        extension=".avs2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw AVS3-P2/IEEE1857.10",
+        extension=".avs3",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Chinese AVS (Audio Video Standard) video",
+        extension=".cavs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Dirac",
+        extension=".drc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Dirac",
+        extension=".vc2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw DNxHD (SMPTE VC-3)",
+        extension=".dnxhd",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw DNxHD (SMPTE VC-3)",
+        extension=".dnxhr",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw GSM",
+        extension=".gsm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.261",
+        extension=".h261",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.263",
+        extension=".h263",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".264",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".avc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".h264",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw H.264 video",
+        extension=".h26l",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".265",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".h265",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw HEVC video",
+        extension=".hevc",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw id RoQ",
+        extension=".roq",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw Ingenient MJPEG",
+        extension=".cgi",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw IPU Video",
+        extension=".ipu",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG 2000 video",
+        extension=".j2k",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mjpeg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mjpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MJPEG video",
+        extension=".mpo",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".m1v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".mpeg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-1 video",
+        extension=".mpg",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-2 video",
+        extension=".m2v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw MPEG-4 video",
+        extension=".m4v",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw VC-1 video",
+        extension=".vc1",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".cif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".qcif",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".rgb",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="raw video",
+        extension=".yuv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="RealMedia",
+        extension=".rm",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="SDR2",
+        extension=".sdr2",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Sega FILM / CPK",
+        extension=".cpk",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="SER (Simple uncompressed video format for astronomical capturing)",
+        extension=".ser",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Simbiosis Interactive IMX",
+        extension=".imx",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Square SVS",
+        extension=".svs",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="TiVo TY Stream",
+        extension=".ty",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="TiVo TY Stream",
+        extension=".ty+",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Uncompressed 4:2:2 10-bit",
+        extension=".v210",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Uncompressed 4:2:2 10-bit",
+        extension=".yuv10",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="VC-1 test bitstream",
+        extension=".rcv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Video CCTV DAT",
+        extension=".dat",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Video DAV",
+        extension=".dav",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Vivo",
+        extension=".viv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM Chunk Muxer",
+        extension=".chk",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mk3d",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mka",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="WebM",
+        extension=".mks",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Windows Television (WTV)",
+        extension=".wtv",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="Xilam DERF",
+        extension=".adp",
+        priority=["pyav"],
+    ),
+    FileExtension(
+        name="YUV4MPEG pipe",
+        extension=".y4m",
+        priority=["pyav"],
+    ),
+]
+extension_list.sort(key=lambda x: x.extension)
+
+
+known_extensions = dict()
+for ext in extension_list:
+    if ext.extension not in known_extensions:
+        known_extensions[ext.extension] = list()
+    known_extensions[ext.extension].append(ext)
+
+extension_list = [ext for ext_list in known_extensions.values() for ext in ext_list]
+
+_video_extension_strings = [
+    ".264",
+    ".265",
+    ".3g2",
+    ".3gp",
+    ".a64",
+    ".A64",
+    ".adp",
+    ".amr",
+    ".amv",
+    ".asf",
+    ".avc",
+    ".avi",
+    ".avr",
+    ".avs",
+    ".avs2",
+    ".avs3",
+    ".bmv",
+    ".cavs",
+    ".cdg",
+    ".cdxl",
+    ".cgi",
+    ".chk",
+    ".cif",
+    ".cpk",
+    ".dat",
+    ".dav",
+    ".dif",
+    ".dnxhd",
+    ".dnxhr",
+    ".drc",
+    ".dv",
+    ".dvd",
+    ".f4v",
+    ".flm",
+    ".flv",
+    ".gsm",
+    ".gxf",
+    ".h261",
+    ".h263",
+    ".h264",
+    ".h265",
+    ".h26l",
+    ".hevc",
+    ".idf",
+    ".ifv",
+    ".imx",
+    ".ipu",
+    ".ism",
+    ".isma",
+    ".ismv",
+    ".ivf",
+    ".ivr",
+    ".j2k",
+    ".kux",
+    ".lvf",
+    ".m1v",
+    ".m2t",
+    ".m2ts",
+    ".m2v",
+    ".m4a",
+    ".m4b",
+    ".m4v",
+    ".mj2",
+    ".mjpeg",
+    ".mjpg",
+    ".mk3d",
+    ".mka",
+    ".mks",
+    ".mkv",
+    ".mods",
+    ".moflex",
+    ".mov",
+    ".mp4",
+    ".mpc",
+    ".mpd",
+    ".mpeg",
+    ".mpg",
+    ".mpo",
+    ".mts",
+    ".mvi",
+    ".mxf",
+    ".mxg",
+    ".nut",
+    ".obu",
+    ".ogg",
+    ".ogv",
+    ".psp",
+    ".qcif",
+    ".rcv",
+    ".rgb",
+    ".rm",
+    ".roq",
+    ".sdr2",
+    ".ser",
+    ".sga",
+    ".svag",
+    ".svs",
+    ".ts",
+    ".ty",
+    ".ty+",
+    ".v",
+    ".v210",
+    ".vb",
+    ".vc1",
+    ".vc2",
+    ".viv",
+    ".vob",
+    ".webm",
+    ".wmv",
+    ".wtv",
+    ".xl",
+    ".xmv",
+    ".y4m",
+    ".yop",
+    ".yuv",
+    ".yuv10",
+]
+video_extensions = list()
+for ext_string in _video_extension_strings:
+    formats = known_extensions[ext_string]
+    video_extensions.append(formats[0])
+video_extensions.sort(key=lambda x: x.extension)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/config/plugins.py

@@ -0,0 +1,784 @@
+import importlib
+
+from ..core.legacy_plugin_wrapper import LegacyPlugin
+
+
+class PluginConfig:
+    """Plugin Configuration Metadata
+
+    This class holds the information needed to lazy-import plugins.
+
+    Parameters
+    ----------
+    name : str
+        The name of the plugin.
+    class_name : str
+        The name of the plugin class inside the plugin module.
+    module_name : str
+        The name of the module/package from which to import the plugin.
+    is_legacy : bool
+        If True, this plugin is a v2 plugin and will be wrapped in a
+        LegacyPlugin. Default: False.
+    package_name : str
+        If the given module name points to a relative module, then the package
+        name determines the package it is relative to.
+    install_name : str
+        The name of the optional dependency that can be used to install this
+        plugin if it is missing.
+    legacy_args : Dict
+        A dictionary of kwargs to pass to the v2 plugin (Format) upon construction.
+
+    Examples
+    --------
+    >>> PluginConfig(
+            name="TIFF",
+            class_name="TiffFormat",
+            module_name="imageio.plugins.tifffile",
+            is_legacy=True,
+            install_name="tifffile",
+            legacy_args={
+                "description": "TIFF format",
+                "extensions": ".tif .tiff .stk .lsm",
+                "modes": "iIvV",
+            },
+        )
+    >>> PluginConfig(
+            name="pillow",
+            class_name="PillowPlugin",
+            module_name="imageio.plugins.pillow"
+        )
+
+    """
+
+    def __init__(
+        self,
+        name,
+        class_name,
+        module_name,
+        *,
+        is_legacy=False,
+        package_name=None,
+        install_name=None,
+        legacy_args=None,
+    ):
+        legacy_args = legacy_args or dict()
+
+        self.name = name
+        self.class_name = class_name
+        self.module_name = module_name
+        self.package_name = package_name
+
+        self.is_legacy = is_legacy
+        self.install_name = install_name or self.name
+        self.legacy_args = {"name": name, "description": "A legacy plugin"}
+        self.legacy_args.update(legacy_args)
+
+    @property
+    def format(self):
+        """For backwards compatibility with FormatManager
+
+        Delete when migrating to v3
+        """
+        if not self.is_legacy:
+            raise RuntimeError("Can only get format for legacy plugins.")
+
+        module = importlib.import_module(self.module_name, self.package_name)
+        clazz = getattr(module, self.class_name)
+        return clazz(**self.legacy_args)
+
+    @property
+    def plugin_class(self):
+        """Get the plugin class (import if needed)
+
+        Returns
+        -------
+        plugin_class : Any
+            The class that can be used to instantiate plugins.
+
+        """
+
+        module = importlib.import_module(self.module_name, self.package_name)
+        clazz = getattr(module, self.class_name)
+
+        if self.is_legacy:
+            legacy_plugin = clazz(**self.legacy_args)
+
+            def partial_legacy_plugin(request):
+                return LegacyPlugin(request, legacy_plugin)
+
+            clazz = partial_legacy_plugin
+
+        return clazz
+
+
+known_plugins = dict()
+known_plugins["pillow"] = PluginConfig(
+    name="pillow", class_name="PillowPlugin", module_name="imageio.plugins.pillow"
+)
+known_plugins["pyav"] = PluginConfig(
+    name="pyav", class_name="PyAVPlugin", module_name="imageio.plugins.pyav"
+)
+known_plugins["opencv"] = PluginConfig(
+    name="opencv", class_name="OpenCVPlugin", module_name="imageio.plugins.opencv"
+)
+
+# Legacy plugins
+# ==============
+#
+# Which are partly registered by format, partly by plugin, and partly by a mix
+# of both. We keep the naming here for backwards compatibility.
+# In v3 this should become a single entry per plugin named after the plugin
+# We can choose extension-specific priority in ``config.extensions``.
+#
+# Note: Since python 3.7 order of insertion determines the order of dict().keys()
+# This means that the order here determines the order by which plugins are
+# checked during the full fallback search. We don't advertise this downstream,
+# but it could be a useful thing to keep in mind to choose a sensible default
+# search order.
+
+known_plugins["TIFF"] = PluginConfig(
+    name="TIFF",
+    class_name="TiffFormat",
+    module_name="imageio.plugins.tifffile",
+    is_legacy=True,
+    install_name="tifffile",
+    legacy_args={
+        "description": "TIFF format",
+        "extensions": ".tif .tiff .stk .lsm",
+        "modes": "iIvV",
+    },
+)
+
+# PILLOW plugin formats (legacy)
+PILLOW_FORMATS = [
+    ("BMP", "Windows Bitmap", ".bmp", "PillowFormat"),
+    ("BUFR", "BUFR", ".bufr", "PillowFormat"),
+    ("CUR", "Windows Cursor", ".cur", "PillowFormat"),
+    ("DCX", "Intel DCX", ".dcx", "PillowFormat"),
+    ("DDS", "DirectDraw Surface", ".dds", "PillowFormat"),
+    ("DIB", "Windows Bitmap", "", "PillowFormat"),
+    ("EPS", "Encapsulated Postscript", ".ps .eps", "PillowFormat"),
+    ("FITS", "FITS", ".fit .fits", "PillowFormat"),
+    ("FLI", "Autodesk FLI/FLC Animation", ".fli .flc", "PillowFormat"),
+    ("FPX", "FlashPix", ".fpx", "PillowFormat"),
+    ("FTEX", "Texture File Format (IW2:EOC)", ".ftc .ftu", "PillowFormat"),
+    ("GBR", "GIMP brush file", ".gbr", "PillowFormat"),
+    ("GIF", "Compuserve GIF", ".gif", "GIFFormat"),
+    ("GRIB", "GRIB", ".grib", "PillowFormat"),
+    ("HDF5", "HDF5", ".h5 .hdf", "PillowFormat"),
+    ("ICNS", "Mac OS icns resource", ".icns", "PillowFormat"),
+    ("ICO", "Windows Icon", ".ico", "PillowFormat"),
+    ("IM", "IFUNC Image Memory", ".im", "PillowFormat"),
+    ("IMT", "IM Tools", "", "PillowFormat"),
+    ("IPTC", "IPTC/NAA", ".iim", "PillowFormat"),
+    ("JPEG", "JPEG (ISO 10918)", ".jfif .jpe .jpg .jpeg", "JPEGFormat"),
+    (
+        "JPEG2000",
+        "JPEG 2000 (ISO 15444)",
+        ".jp2 .j2k .jpc .jpf .jpx .j2c",
+        "JPEG2000Format",
+    ),
+    ("MCIDAS", "McIdas area file", "", "PillowFormat"),
+    ("MIC", "Microsoft Image Composer", ".mic", "PillowFormat"),
+    # skipped in legacy pillow
+    # ("MPEG", "MPEG", ".mpg .mpeg", "PillowFormat"),
+    ("MPO", "MPO (CIPA DC-007)", ".mpo", "PillowFormat"),
+    ("MSP", "Windows Paint", ".msp", "PillowFormat"),
+    ("PCD", "Kodak PhotoCD", ".pcd", "PillowFormat"),
+    ("PCX", "Paintbrush", ".pcx", "PillowFormat"),
+    ("PIXAR", "PIXAR raster image", ".pxr", "PillowFormat"),
+    ("PNG", "Portable network graphics", ".png", "PNGFormat"),
+    ("PPM", "Pbmplus image", ".pbm .pgm .ppm", "PillowFormat"),
+    ("PSD", "Adobe Photoshop", ".psd", "PillowFormat"),
+    ("SGI", "SGI Image File Format", ".bw .rgb .rgba .sgi", "PillowFormat"),
+    ("SPIDER", "Spider 2D image", "", "PillowFormat"),
+    ("SUN", "Sun Raster File", ".ras", "PillowFormat"),
+    ("TGA", "Targa", ".tga", "PillowFormat"),
+    ("TIFF", "Adobe TIFF", ".tif .tiff", "TIFFFormat"),
+    ("WMF", "Windows Metafile", ".wmf .emf", "PillowFormat"),
+    ("XBM", "X11 Bitmap", ".xbm", "PillowFormat"),
+    ("XPM", "X11 Pixel Map", ".xpm", "PillowFormat"),
+    ("XVTHUMB", "XV thumbnail image", "", "PillowFormat"),
+]
+for id, summary, ext, class_name in PILLOW_FORMATS:
+    config = PluginConfig(
+        name=id.upper() + "-PIL",
+        class_name=class_name,
+        module_name="imageio.plugins.pillow_legacy",
+        is_legacy=True,
+        install_name="pillow",
+        legacy_args={
+            "description": summary + " via Pillow",
+            "extensions": ext,
+            "modes": "iI" if class_name == "GIFFormat" else "i",
+            "plugin_id": id,
+        },
+    )
+    known_plugins[config.name] = config
+
+known_plugins["FFMPEG"] = PluginConfig(
+    name="FFMPEG",
+    class_name="FfmpegFormat",
+    module_name="imageio.plugins.ffmpeg",
+    is_legacy=True,
+    install_name="ffmpeg",
+    legacy_args={
+        "description": "Many video formats and cameras (via ffmpeg)",
+        "extensions": ".mov .avi .mpg .mpeg .mp4 .mkv .webm .wmv",
+        "modes": "I",
+    },
+)
+
+known_plugins["BSDF"] = PluginConfig(
+    name="BSDF",
+    class_name="BsdfFormat",
+    module_name="imageio.plugins.bsdf",
+    is_legacy=True,
+    install_name="bsdf",
+    legacy_args={
+        "description": "Format based on the Binary Structured Data Format",
+        "extensions": ".bsdf",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["DICOM"] = PluginConfig(
+    name="DICOM",
+    class_name="DicomFormat",
+    module_name="imageio.plugins.dicom",
+    is_legacy=True,
+    install_name="dicom",
+    legacy_args={
+        "description": "Digital Imaging and Communications in Medicine",
+        "extensions": ".dcm .ct .mri",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["FEI"] = PluginConfig(
+    name="FEI",
+    class_name="FEISEMFormat",
+    module_name="imageio.plugins.feisem",
+    is_legacy=True,
+    install_name="feisem",
+    legacy_args={
+        "description": "FEI-SEM TIFF format",
+        "extensions": [".tif", ".tiff"],
+        "modes": "iv",
+    },
+)
+
+known_plugins["FITS"] = PluginConfig(
+    name="FITS",
+    class_name="FitsFormat",
+    module_name="imageio.plugins.fits",
+    is_legacy=True,
+    install_name="fits",
+    legacy_args={
+        "description": "Flexible Image Transport System (FITS) format",
+        "extensions": ".fits .fit .fts .fz",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["GDAL"] = PluginConfig(
+    name="GDAL",
+    class_name="GdalFormat",
+    module_name="imageio.plugins.gdal",
+    is_legacy=True,
+    install_name="gdal",
+    legacy_args={
+        "description": "Geospatial Data Abstraction Library",
+        "extensions": ".tiff  .tif .img .ecw .jpg .jpeg",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["ITK"] = PluginConfig(
+    name="ITK",
+    class_name="ItkFormat",
+    module_name="imageio.plugins.simpleitk",
+    is_legacy=True,
+    install_name="simpleitk",
+    legacy_args={
+        "description": "Insight Segmentation and Registration Toolkit (ITK) format",
+        "extensions": " ".join(
+            (
+                ".gipl",
+                ".ipl",
+                ".mha",
+                ".mhd",
+                ".nhdr",
+                ".nia",
+                ".hdr",
+                ".nrrd",
+                ".nii",
+                ".nii.gz",
+                ".img",
+                ".img.gz",
+                ".vtk",
+                ".hdf5",
+                ".lsm",
+                ".mnc",
+                ".mnc2",
+                ".mgh",
+                ".mnc",
+                ".pic",
+                ".bmp",
+                ".jpeg",
+                ".jpg",
+                ".png",
+                ".tiff",
+                ".tif",
+                ".dicom",
+                ".dcm",
+                ".gdcm",
+            )
+        ),
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["NPZ"] = PluginConfig(
+    name="NPZ",
+    class_name="NpzFormat",
+    module_name="imageio.plugins.npz",
+    is_legacy=True,
+    install_name="numpy",
+    legacy_args={
+        "description": "Numpy's compressed array format",
+        "extensions": ".npz",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["SPE"] = PluginConfig(
+    name="SPE",
+    class_name="SpeFormat",
+    module_name="imageio.plugins.spe",
+    is_legacy=True,
+    install_name="spe",
+    legacy_args={
+        "description": "SPE file format",
+        "extensions": ".spe",
+        "modes": "iIvV",
+    },
+)
+
+known_plugins["SWF"] = PluginConfig(
+    name="SWF",
+    class_name="SWFFormat",
+    module_name="imageio.plugins.swf",
+    is_legacy=True,
+    install_name="swf",
+    legacy_args={
+        "description": "Shockwave flash",
+        "extensions": ".swf",
+        "modes": "I",
+    },
+)
+
+known_plugins["SCREENGRAB"] = PluginConfig(
+    name="SCREENGRAB",
+    class_name="ScreenGrabFormat",
+    module_name="imageio.plugins.grab",
+    is_legacy=True,
+    install_name="pillow",
+    legacy_args={
+        "description": "Grab screenshots (Windows and OS X only)",
+        "extensions": [],
+        "modes": "i",
+    },
+)
+
+known_plugins["CLIPBOARDGRAB"] = PluginConfig(
+    name="CLIPBOARDGRAB",
+    class_name="ClipboardGrabFormat",
+    module_name="imageio.plugins.grab",
+    is_legacy=True,
+    install_name="pillow",
+    legacy_args={
+        "description": "Grab from clipboard (Windows only)",
+        "extensions": [],
+        "modes": "i",
+    },
+)
+
+# LYTRO plugin (legacy)
+lytro_formats = [
+    ("lytro-lfr", "Lytro Illum lfr image file", ".lfr", "i", "LytroLfrFormat"),
+    (
+        "lytro-illum-raw",
+        "Lytro Illum raw image file",
+        ".raw",
+        "i",
+        "LytroIllumRawFormat",
+    ),
+    ("lytro-lfp", "Lytro F01 lfp image file", ".lfp", "i", "LytroLfpFormat"),
+    ("lytro-f01-raw", "Lytro F01 raw image file", ".raw", "i", "LytroF01RawFormat"),
+]
+for name, des, ext, mode, class_name in lytro_formats:
+    config = PluginConfig(
+        name=name.upper(),
+        class_name=class_name,
+        module_name="imageio.plugins.lytro",
+        is_legacy=True,
+        install_name="lytro",
+        legacy_args={
+            "description": des,
+            "extensions": ext,
+            "modes": mode,
+        },
+    )
+    known_plugins[config.name] = config
+
+# FreeImage plugin (legacy)
+FREEIMAGE_FORMATS = [
+    (
+        "BMP",
+        0,
+        "Windows or OS/2 Bitmap",
+        ".bmp",
+        "i",
+        "FreeimageBmpFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "CUT",
+        21,
+        "Dr. Halo",
+        ".cut",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "DDS",
+        24,
+        "DirectX Surface",
+        ".dds",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "EXR",
+        29,
+        "ILM OpenEXR",
+        ".exr",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "G3",
+        27,
+        "Raw fax format CCITT G.3",
+        ".g3",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "GIF",
+        25,
+        "Static and animated gif (FreeImage)",
+        ".gif",
+        "iI",
+        "GifFormat",
+        "imageio.plugins.freeimagemulti",
+    ),
+    (
+        "HDR",
+        26,
+        "High Dynamic Range Image",
+        ".hdr",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "ICO",
+        1,
+        "Windows Icon",
+        ".ico",
+        "iI",
+        "IcoFormat",
+        "imageio.plugins.freeimagemulti",
+    ),
+    (
+        "IFF",
+        5,
+        "IFF Interleaved Bitmap",
+        ".iff .lbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "J2K",
+        30,
+        "JPEG-2000 codestream",
+        ".j2k .j2c",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JNG",
+        3,
+        "JPEG Network Graphics",
+        ".jng",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JP2",
+        31,
+        "JPEG-2000 File Format",
+        ".jp2",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JPEG",
+        2,
+        "JPEG - JFIF Compliant",
+        ".jpg .jif .jpeg .jpe",
+        "i",
+        "FreeimageJpegFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "JPEG-XR",
+        36,
+        "JPEG XR image format",
+        ".jxr .wdp .hdp",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "KOALA",
+        4,
+        "C64 Koala Graphics",
+        ".koa",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    # not registered in legacy pillow
+    # ("MNG", 6, "Multiple-image Network Graphics", ".mng", "i", "FreeimageFormat", "imageio.plugins.freeimage"),
+    (
+        "PBM",
+        7,
+        "Portable Bitmap (ASCII)",
+        ".pbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PBMRAW",
+        8,
+        "Portable Bitmap (RAW)",
+        ".pbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PCD",
+        9,
+        "Kodak PhotoCD",
+        ".pcd",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PCX",
+        10,
+        "Zsoft Paintbrush",
+        ".pcx",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PFM",
+        32,
+        "Portable floatmap",
+        ".pfm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PGM",
+        11,
+        "Portable Greymap (ASCII)",
+        ".pgm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PGMRAW",
+        12,
+        "Portable Greymap (RAW)",
+        ".pgm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PICT",
+        33,
+        "Macintosh PICT",
+        ".pct .pict .pic",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PNG",
+        13,
+        "Portable Network Graphics",
+        ".png",
+        "i",
+        "FreeimagePngFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PPM",
+        14,
+        "Portable Pixelmap (ASCII)",
+        ".ppm",
+        "i",
+        "FreeimagePnmFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PPMRAW",
+        15,
+        "Portable Pixelmap (RAW)",
+        ".ppm",
+        "i",
+        "FreeimagePnmFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "PSD",
+        20,
+        "Adobe Photoshop",
+        ".psd",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "RAS",
+        16,
+        "Sun Raster Image",
+        ".ras",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "RAW",
+        34,
+        "RAW camera image",
+        ".3fr .arw .bay .bmq .cap .cine .cr2 .crw .cs1 .dc2 "
+        ".dcr .drf .dsc .dng .erf .fff .ia .iiq .k25 .kc2 .kdc .mdc .mef .mos .mrw .nef .nrw .orf "
+        ".pef .ptx .pxn .qtk .raf .raw .rdc .rw2 .rwl .rwz .sr2 .srf .srw .sti",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "SGI",
+        28,
+        "SGI Image Format",
+        ".sgi .rgb .rgba .bw",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "TARGA",
+        17,
+        "Truevision Targa",
+        ".tga .targa",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "TIFF",
+        18,
+        "Tagged Image File Format",
+        ".tif .tiff",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "WBMP",
+        19,
+        "Wireless Bitmap",
+        ".wap .wbmp .wbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "WebP",
+        35,
+        "Google WebP image format",
+        ".webp",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "XBM",
+        22,
+        "X11 Bitmap Format",
+        ".xbm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+    (
+        "XPM",
+        23,
+        "X11 Pixmap Format",
+        ".xpm",
+        "i",
+        "FreeimageFormat",
+        "imageio.plugins.freeimage",
+    ),
+]
+for name, i, des, ext, mode, class_name, module_name in FREEIMAGE_FORMATS:
+    config = PluginConfig(
+        name=name.upper() + "-FI",
+        class_name=class_name,
+        module_name=module_name,
+        is_legacy=True,
+        install_name="freeimage",
+        legacy_args={
+            "description": des,
+            "extensions": ext,
+            "modes": mode,
+            "fif": i,
+        },
+    )
+    known_plugins[config.name] = config
+
+# exists for backwards compatibility with FormatManager
+# delete in V3
+_original_order = [x for x, config in known_plugins.items() if config.is_legacy]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+""" This subpackage provides the core functionality of imageio
+(everything but the plugins).
+"""
+
+# flake8: noqa
+
+from .util import Image, Array, Dict, asarray, image_as_uint, urlopen
+from .util import BaseProgressIndicator, StdoutProgressIndicator, IS_PYPY
+from .util import get_platform, appdata_dir, resource_dirs, has_module
+from .findlib import load_lib
+from .fetching import get_remote_file, InternetNotAllowedError, NeedDownloadError
+from .request import Request, read_n_bytes, RETURN_BYTES
+from .format import Format, FormatManager

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/findlib.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015-1018, imageio contributors
+# Copyright (C) 2013, Zach Pincus, Almar Klein and others
+
+""" This module contains generic code to find and load a dynamic library.
+"""
+
+import os
+import sys
+import ctypes
+
+
+LOCALDIR = os.path.abspath(os.path.dirname(__file__))
+
+# Flag that can be patched / set to True to disable loading non-system libs
+SYSTEM_LIBS_ONLY = False
+
+
+def looks_lib(fname):
+    """Returns True if the given filename looks like a dynamic library.
+    Based on extension, but cross-platform and more flexible.
+    """
+    fname = fname.lower()
+    if sys.platform.startswith("win"):
+        return fname.endswith(".dll")
+    elif sys.platform.startswith("darwin"):
+        return fname.endswith(".dylib")
+    else:
+        return fname.endswith(".so") or ".so." in fname
+
+
+def generate_candidate_libs(lib_names, lib_dirs=None):
+    """Generate a list of candidate filenames of what might be the dynamic
+    library corresponding with the given list of names.
+    Returns (lib_dirs, lib_paths)
+    """
+    lib_dirs = lib_dirs or []
+
+    # Get system dirs to search
+    sys_lib_dirs = [
+        "/lib",
+        "/usr/lib",
+        "/usr/lib/x86_64-linux-gnu",
+        "/usr/lib/aarch64-linux-gnu",
+        "/usr/local/lib",
+        "/opt/local/lib",
+    ]
+
+    # Get Python dirs to search (shared if for Pyzo)
+    py_sub_dirs = ["bin", "lib", "DLLs", "Library/bin", "shared"]
+    py_lib_dirs = [os.path.join(sys.prefix, d) for d in py_sub_dirs]
+    if hasattr(sys, "base_prefix"):
+        py_lib_dirs += [os.path.join(sys.base_prefix, d) for d in py_sub_dirs]
+
+    # Get user dirs to search (i.e. HOME)
+    home_dir = os.path.expanduser("~")
+    user_lib_dirs = [os.path.join(home_dir, d) for d in ["lib"]]
+
+    # Select only the dirs for which a directory exists, and remove duplicates
+    potential_lib_dirs = lib_dirs + sys_lib_dirs + py_lib_dirs + user_lib_dirs
+    lib_dirs = []
+    for ld in potential_lib_dirs:
+        if os.path.isdir(ld) and ld not in lib_dirs:
+            lib_dirs.append(ld)
+
+    # Now attempt to find libraries of that name in the given directory
+    # (case-insensitive)
+    lib_paths = []
+    for lib_dir in lib_dirs:
+        # Get files, prefer short names, last version
+        files = os.listdir(lib_dir)
+        files = reversed(sorted(files))
+        files = sorted(files, key=len)
+        for lib_name in lib_names:
+            # Test all filenames for name and ext
+            for fname in files:
+                if fname.lower().startswith(lib_name) and looks_lib(fname):
+                    lib_paths.append(os.path.join(lib_dir, fname))
+
+    # Return (only the items which are files)
+    lib_paths = [lp for lp in lib_paths if os.path.isfile(lp)]
+    return lib_dirs, lib_paths
+
+
+def load_lib(exact_lib_names, lib_names, lib_dirs=None):
+    """load_lib(exact_lib_names, lib_names, lib_dirs=None)
+
+    Load a dynamic library.
+
+    This function first tries to load the library from the given exact
+    names. When that fails, it tries to find the library in common
+    locations. It searches for files that start with one of the names
+    given in lib_names (case insensitive). The search is performed in
+    the given lib_dirs and a set of common library dirs.
+
+    Returns ``(ctypes_library, library_path)``
+    """
+
+    # Checks
+    assert isinstance(exact_lib_names, list)
+    assert isinstance(lib_names, list)
+    if lib_dirs is not None:
+        assert isinstance(lib_dirs, list)
+    exact_lib_names = [n for n in exact_lib_names if n]
+    lib_names = [n for n in lib_names if n]
+
+    # Get reference name (for better messages)
+    if lib_names:
+        the_lib_name = lib_names[0]
+    elif exact_lib_names:
+        the_lib_name = exact_lib_names[0]
+    else:
+        raise ValueError("No library name given.")
+
+    # Collect filenames of potential libraries
+    # First try a few bare library names that ctypes might be able to find
+    # in the default locations for each platform.
+    if SYSTEM_LIBS_ONLY:
+        lib_dirs, lib_paths = [], []
+    else:
+        lib_dirs, lib_paths = generate_candidate_libs(lib_names, lib_dirs)
+    lib_paths = exact_lib_names + lib_paths
+
+    # Select loader
+    if sys.platform.startswith("win"):
+        loader = ctypes.windll
+    else:
+        loader = ctypes.cdll
+
+    # Try to load until success
+    the_lib = None
+    errors = []
+    for fname in lib_paths:
+        try:
+            the_lib = loader.LoadLibrary(fname)
+            break
+        except Exception as err:
+            # Don't record errors when it couldn't load the library from an
+            # exact name -- this fails often, and doesn't provide any useful
+            # debugging information anyway, beyond "couldn't find library..."
+            if fname not in exact_lib_names:
+                errors.append((fname, err))
+
+    # No success ...
+    if the_lib is None:
+        if errors:
+            # No library loaded, and load-errors reported for some
+            # candidate libs
+            err_txt = ["%s:\n%s" % (lib, str(e)) for lib, e in errors]
+            msg = (
+                "One or more %s libraries were found, but "
+                + "could not be loaded due to the following errors:\n%s"
+            )
+            raise OSError(msg % (the_lib_name, "\n\n".join(err_txt)))
+        else:
+            # No errors, because no potential libraries found at all!
+            msg = "Could not find a %s library in any of:\n%s"
+            raise OSError(msg % (the_lib_name, "\n".join(lib_dirs)))
+
+    # Done
+    return the_lib, fname

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/format.py

@@ -0,0 +1,856 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""
+
+.. note::
+    imageio is under construction, some details with regard to the
+    Reader and Writer classes may change.
+
+These are the main classes of imageio. They expose an interface for
+advanced users and plugin developers. A brief overview:
+
+  * imageio.FormatManager - for keeping track of registered formats.
+  * imageio.Format - representation of a file format reader/writer
+  * imageio.Format.Reader - object used during the reading of a file.
+  * imageio.Format.Writer - object used during saving a file.
+  * imageio.Request - used to store the filename and other info.
+
+Plugins need to implement a Format class and register
+a format object using ``imageio.formats.add_format()``.
+
+"""
+
+# todo: do we even use the known extensions?
+
+# Some notes:
+#
+# The classes in this module use the Request object to pass filename and
+# related info around. This request object is instantiated in
+# imageio.get_reader and imageio.get_writer.
+
+import sys
+import warnings
+
+import numpy as np
+from pathlib import Path
+
+from . import Array, asarray
+from .request import ImageMode
+from ..config import known_plugins, known_extensions, PluginConfig, FileExtension
+from ..config.plugins import _original_order
+from .imopen import imopen
+
+
+# survived for backwards compatibility
+# I don't know if external plugin code depends on it existing
+# We no longer do
+MODENAMES = ImageMode
+
+
+def _get_config(plugin):
+    """Old Plugin resolution logic.
+
+    Remove once we remove the old format manager.
+    """
+
+    extension_name = None
+
+    if Path(plugin).suffix.lower() in known_extensions:
+        extension_name = Path(plugin).suffix.lower()
+    elif plugin in known_plugins:
+        pass
+    elif plugin.lower() in known_extensions:
+        extension_name = plugin.lower()
+    elif "." + plugin.lower() in known_extensions:
+        extension_name = "." + plugin.lower()
+    else:
+        raise IndexError(f"No format known by name `{plugin}`.")
+
+    if extension_name is not None:
+        for plugin_name in [
+            x
+            for file_extension in known_extensions[extension_name]
+            for x in file_extension.priority
+        ]:
+            if known_plugins[plugin_name].is_legacy:
+                plugin = plugin_name
+                break
+
+    return known_plugins[plugin]
+
+
+class Format(object):
+    """Represents an implementation to read/write a particular file format
+
+    A format instance is responsible for 1) providing information about
+    a format; 2) determining whether a certain file can be read/written
+    with this format; 3) providing a reader/writer class.
+
+    Generally, imageio will select the right format and use that to
+    read/write an image. A format can also be explicitly chosen in all
+    read/write functions. Use ``print(format)``, or ``help(format_name)``
+    to see its documentation.
+
+    To implement a specific format, one should create a subclass of
+    Format and the Format.Reader and Format.Writer classes. See
+    :class:`imageio.plugins` for details.
+
+    Parameters
+    ----------
+    name : str
+        A short name of this format. Users can select a format using its name.
+    description : str
+        A one-line description of the format.
+    extensions : str | list | None
+        List of filename extensions that this format supports. If a
+        string is passed it should be space or comma separated. The
+        extensions are used in the documentation and to allow users to
+        select a format by file extension. It is not used to determine
+        what format to use for reading/saving a file.
+    modes : str
+        A string containing the modes that this format can handle ('iIvV'),
+        “i” for an image, “I” for multiple images, “v” for a volume,
+        “V” for multiple volumes.
+        This attribute is used in the documentation and to select the
+        formats when reading/saving a file.
+    """
+
+    def __init__(self, name, description, extensions=None, modes=None):
+        """Initialize the Plugin.
+
+        Parameters
+        ----------
+        name : str
+            A short name of this format. Users can select a format using its name.
+        description : str
+            A one-line description of the format.
+        extensions : str | list | None
+            List of filename extensions that this format supports. If a
+            string is passed it should be space or comma separated. The
+            extensions are used in the documentation and to allow users to
+            select a format by file extension. It is not used to determine
+            what format to use for reading/saving a file.
+        modes : str
+            A string containing the modes that this format can handle ('iIvV'),
+            “i” for an image, “I” for multiple images, “v” for a volume,
+            “V” for multiple volumes.
+            This attribute is used in the documentation and to select the
+            formats when reading/saving a file.
+        """
+
+        # Store name and description
+        self._name = name.upper()
+        self._description = description
+
+        # Store extensions, do some effort to normalize them.
+        # They are stored as a list of lowercase strings without leading dots.
+        if extensions is None:
+            extensions = []
+        elif isinstance(extensions, str):
+            extensions = extensions.replace(",", " ").split(" ")
+        #
+        if isinstance(extensions, (tuple, list)):
+            self._extensions = tuple(
+                ["." + e.strip(".").lower() for e in extensions if e]
+            )
+        else:
+            raise ValueError("Invalid value for extensions given.")
+
+        # Store mode
+        self._modes = modes or ""
+        if not isinstance(self._modes, str):
+            raise ValueError("Invalid value for modes given.")
+        for m in self._modes:
+            if m not in "iIvV?":
+                raise ValueError("Invalid value for mode given.")
+
+    def __repr__(self):
+        # Short description
+        return "<Format %s - %s>" % (self.name, self.description)
+
+    def __str__(self):
+        return self.doc
+
+    @property
+    def doc(self):
+        """The documentation for this format (name + description + docstring)."""
+        # Our docsring is assumed to be indented by four spaces. The
+        # first line needs special attention.
+        return "%s - %s\n\n    %s\n" % (
+            self.name,
+            self.description,
+            self.__doc__.strip(),
+        )
+
+    @property
+    def name(self):
+        """The name of this format."""
+        return self._name
+
+    @property
+    def description(self):
+        """A short description of this format."""
+        return self._description
+
+    @property
+    def extensions(self):
+        """A list of file extensions supported by this plugin.
+        These are all lowercase with a leading dot.
+        """
+        return self._extensions
+
+    @property
+    def modes(self):
+        """A string specifying the modes that this format can handle."""
+        return self._modes
+
+    def get_reader(self, request):
+        """get_reader(request)
+
+        Return a reader object that can be used to read data and info
+        from the given file. Users are encouraged to use
+        imageio.get_reader() instead.
+        """
+        select_mode = request.mode[1] if request.mode[1] in "iIvV" else ""
+        if select_mode not in self.modes:
+            raise RuntimeError(
+                f"Format {self.name} cannot read in {request.mode.image_mode} mode"
+            )
+        return self.Reader(self, request)
+
+    def get_writer(self, request):
+        """get_writer(request)
+
+        Return a writer object that can be used to write data and info
+        to the given file. Users are encouraged to use
+        imageio.get_writer() instead.
+        """
+        select_mode = request.mode[1] if request.mode[1] in "iIvV" else ""
+        if select_mode not in self.modes:
+            raise RuntimeError(
+                f"Format {self.name} cannot write in {request.mode.image_mode} mode"
+            )
+        return self.Writer(self, request)
+
+    def can_read(self, request):
+        """can_read(request)
+
+        Get whether this format can read data from the specified uri.
+        """
+        return self._can_read(request)
+
+    def can_write(self, request):
+        """can_write(request)
+
+        Get whether this format can write data to the speciefed uri.
+        """
+        return self._can_write(request)
+
+    def _can_read(self, request):  # pragma: no cover
+        """Check if Plugin can read from ImageResource.
+
+        This method is called when the format manager is searching for a format
+        to read a certain image. Return True if this format can do it.
+
+        The format manager is aware of the extensions and the modes that each
+        format can handle. It will first ask all formats that *seem* to be able
+        to read it whether they can. If none can, it will ask the remaining
+        formats if they can: the extension might be missing, and this allows
+        formats to provide functionality for certain extensions, while giving
+        preference to other plugins.
+
+        If a format says it can, it should live up to it. The format would
+        ideally check the request.firstbytes and look for a header of some kind.
+
+        Parameters
+        ----------
+        request : Request
+            A request that can be used to access the ImageResource and obtain
+            metadata about it.
+
+        Returns
+        -------
+        can_read : bool
+            True if the plugin can read from the ImageResource, False otherwise.
+
+        """
+        return None  # Plugins must implement this
+
+    def _can_write(self, request):  # pragma: no cover
+        """Check if Plugin can write to ImageResource.
+
+        Parameters
+        ----------
+        request : Request
+            A request that can be used to access the ImageResource and obtain
+            metadata about it.
+
+        Returns
+        -------
+        can_read : bool
+            True if the plugin can write to the ImageResource, False otherwise.
+
+        """
+        return None  # Plugins must implement this
+
+    # -----
+
+    class _BaseReaderWriter(object):
+        """Base class for the Reader and Writer class to implement common
+        functionality. It implements a similar approach for opening/closing
+        and context management as Python's file objects.
+        """
+
+        def __init__(self, format, request):
+            self.__closed = False
+            self._BaseReaderWriter_last_index = -1
+            self._format = format
+            self._request = request
+            # Open the reader/writer
+            self._open(**self.request.kwargs.copy())
+
+        @property
+        def format(self):
+            """The :class:`.Format` object corresponding to the current
+            read/write operation.
+            """
+            return self._format
+
+        @property
+        def request(self):
+            """The :class:`.Request` object corresponding to the
+            current read/write operation.
+            """
+            return self._request
+
+        def __enter__(self):
+            self._checkClosed()
+            return self
+
+        def __exit__(self, type, value, traceback):
+            if value is None:
+                # Otherwise error in close hide the real error.
+                self.close()
+
+        def __del__(self):
+            try:
+                self.close()
+            except Exception:  # pragma: no cover
+                pass  # Supress noise when called during interpreter shutdown
+
+        def close(self):
+            """Flush and close the reader/writer.
+            This method has no effect if it is already closed.
+            """
+            if self.__closed:
+                return
+            self.__closed = True
+            self._close()
+            # Process results and clean request object
+            self.request.finish()
+
+        @property
+        def closed(self):
+            """Whether the reader/writer is closed."""
+            return self.__closed
+
+        def _checkClosed(self, msg=None):
+            """Internal: raise an ValueError if reader/writer is closed"""
+            if self.closed:
+                what = self.__class__.__name__
+                msg = msg or ("I/O operation on closed %s." % what)
+                raise RuntimeError(msg)
+
+        # To implement
+
+        def _open(self, **kwargs):
+            """_open(**kwargs)
+
+            Plugins should probably implement this.
+
+            It is called when reader/writer is created. Here the
+            plugin can do its initialization. The given keyword arguments
+            are those that were given by the user at imageio.read() or
+            imageio.write().
+            """
+            raise NotImplementedError()
+
+        def _close(self):
+            """_close()
+
+            Plugins should probably implement this.
+
+            It is called when the reader/writer is closed. Here the plugin
+            can do a cleanup, flush, etc.
+
+            """
+            raise NotImplementedError()
+
+    # -----
+
+    class Reader(_BaseReaderWriter):
+        """
+        The purpose of a reader object is to read data from an image
+        resource, and should be obtained by calling :func:`.get_reader`.
+
+        A reader can be used as an iterator to read multiple images,
+        and (if the format permits) only reads data from the file when
+        new data is requested (i.e. streaming). A reader can also be
+        used as a context manager so that it is automatically closed.
+
+        Plugins implement Reader's for different formats. Though rare,
+        plugins may provide additional functionality (beyond what is
+        provided by the base reader class).
+        """
+
+        def get_length(self):
+            """get_length()
+
+            Get the number of images in the file. (Note: you can also
+            use ``len(reader_object)``.)
+
+            The result can be:
+                * 0 for files that only have meta data
+                * 1 for singleton images (e.g. in PNG, JPEG, etc.)
+                * N for image series
+                * inf for streams (series of unknown length)
+            """
+            return self._get_length()
+
+        def get_data(self, index, **kwargs):
+            """get_data(index, **kwargs)
+
+            Read image data from the file, using the image index. The
+            returned image has a 'meta' attribute with the meta data.
+            Raises IndexError if the index is out of range.
+
+            Some formats may support additional keyword arguments. These are
+            listed in the documentation of those formats.
+            """
+            self._checkClosed()
+            self._BaseReaderWriter_last_index = index
+            try:
+                im, meta = self._get_data(index, **kwargs)
+            except StopIteration:
+                raise IndexError(index)
+            return Array(im, meta)  # Array tests im and meta
+
+        def get_next_data(self, **kwargs):
+            """get_next_data(**kwargs)
+
+            Read the next image from the series.
+
+            Some formats may support additional keyword arguments. These are
+            listed in the documentation of those formats.
+            """
+            return self.get_data(self._BaseReaderWriter_last_index + 1, **kwargs)
+
+        def set_image_index(self, index, **kwargs):
+            """set_image_index(index)
+
+            Set the internal pointer such that the next call to
+            get_next_data() returns the image specified by the index
+            """
+            self._checkClosed()
+            n = self.get_length()
+            self._BaseReaderWriter_last_index = min(max(index - 1, -1), n)
+
+        def get_meta_data(self, index=None):
+            """get_meta_data(index=None)
+
+            Read meta data from the file. using the image index. If the
+            index is omitted or None, return the file's (global) meta data.
+
+            Note that ``get_data`` also provides the meta data for the returned
+            image as an atrribute of that image.
+
+            The meta data is a dict, which shape depends on the format.
+            E.g. for JPEG, the dict maps group names to subdicts and each
+            group is a dict with name-value pairs. The groups represent
+            the different metadata formats (EXIF, XMP, etc.).
+            """
+            self._checkClosed()
+            meta = self._get_meta_data(index)
+            if not isinstance(meta, dict):
+                raise ValueError(
+                    "Meta data must be a dict, not %r" % meta.__class__.__name__
+                )
+            return meta
+
+        def iter_data(self):
+            """iter_data()
+
+            Iterate over all images in the series. (Note: you can also
+            iterate over the reader object.)
+
+            """
+            self._checkClosed()
+            n = self.get_length()
+            i = 0
+            while i < n:
+                try:
+                    im, meta = self._get_data(i)
+                except StopIteration:
+                    return
+                except IndexError:
+                    if n == float("inf"):
+                        return
+                    raise
+                yield Array(im, meta)
+                i += 1
+
+        # Compatibility
+
+        def __iter__(self):
+            return self.iter_data()
+
+        def __len__(self):
+            n = self.get_length()
+            if n == float("inf"):
+                n = sys.maxsize
+            return n
+
+        # To implement
+
+        def _get_length(self):
+            """_get_length()
+
+            Plugins must implement this.
+
+            The retured scalar specifies the number of images in the series.
+            See Reader.get_length for more information.
+            """
+            raise NotImplementedError()
+
+        def _get_data(self, index):
+            """_get_data()
+
+            Plugins must implement this, but may raise an IndexError in
+            case the plugin does not support random access.
+
+            It should return the image and meta data: (ndarray, dict).
+            """
+            raise NotImplementedError()
+
+        def _get_meta_data(self, index):
+            """_get_meta_data(index)
+
+            Plugins must implement this.
+
+            It should return the meta data as a dict, corresponding to the
+            given index, or to the file's (global) meta data if index is
+            None.
+            """
+            raise NotImplementedError()
+
+    # -----
+
+    class Writer(_BaseReaderWriter):
+        """
+        The purpose of a writer object is to write data to an image
+        resource, and should be obtained by calling :func:`.get_writer`.
+
+        A writer will (if the format permits) write data to the file
+        as soon as new data is provided (i.e. streaming). A writer can
+        also be used as a context manager so that it is automatically
+        closed.
+
+        Plugins implement Writer's for different formats. Though rare,
+        plugins may provide additional functionality (beyond what is
+        provided by the base writer class).
+        """
+
+        def append_data(self, im, meta=None):
+            """append_data(im, meta={})
+
+            Append an image (and meta data) to the file. The final meta
+            data that is used consists of the meta data on the given
+            image (if applicable), updated with the given meta data.
+            """
+            self._checkClosed()
+            # Check image data
+            if not isinstance(im, np.ndarray):
+                raise ValueError("append_data requires ndarray as first arg")
+            # Get total meta dict
+            total_meta = {}
+            if hasattr(im, "meta") and isinstance(im.meta, dict):
+                total_meta.update(im.meta)
+            if meta is None:
+                pass
+            elif not isinstance(meta, dict):
+                raise ValueError("Meta must be a dict.")
+            else:
+                total_meta.update(meta)
+
+            # Decouple meta info
+            im = asarray(im)
+            # Call
+            return self._append_data(im, total_meta)
+
+        def set_meta_data(self, meta):
+            """set_meta_data(meta)
+
+            Sets the file's (global) meta data. The meta data is a dict which
+            shape depends on the format. E.g. for JPEG the dict maps
+            group names to subdicts, and each group is a dict with
+            name-value pairs. The groups represents the different
+            metadata formats (EXIF, XMP, etc.).
+
+            Note that some meta formats may not be supported for
+            writing, and individual fields may be ignored without
+            warning if they are invalid.
+            """
+            self._checkClosed()
+            if not isinstance(meta, dict):
+                raise ValueError("Meta must be a dict.")
+            else:
+                return self._set_meta_data(meta)
+
+        # To implement
+
+        def _append_data(self, im, meta):
+            # Plugins must implement this
+            raise NotImplementedError()
+
+        def _set_meta_data(self, meta):
+            # Plugins must implement this
+            raise NotImplementedError()
+
+
+class FormatManager(object):
+    """
+    The FormatManager is a singleton plugin factory.
+
+    The format manager supports getting a format object using indexing (by
+    format name or extension). When used as an iterator, this object
+    yields all registered format objects.
+
+    See also :func:`.help`.
+    """
+
+    @property
+    def _formats(self):
+        return [x for x in known_plugins.values() if x.is_legacy]
+
+    def __repr__(self):
+        return f"<imageio.FormatManager with {len(self._formats)} registered formats>"
+
+    def __iter__(self):
+        return iter(x.format for x in self._formats)
+
+    def __len__(self):
+        return len(self._formats)
+
+    def __str__(self):
+        ss = []
+        for config in self._formats:
+            ext = config.legacy_args["extensions"]
+            desc = config.legacy_args["description"]
+            s = f"{config.name} - {desc} [{ext}]"
+            ss.append(s)
+        return "\n".join(ss)
+
+    def __getitem__(self, name):
+        warnings.warn(
+            "The usage of `FormatManager` is deprecated and it will be "
+            "removed in Imageio v3. Use `iio.imopen` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        if not isinstance(name, str):
+            raise ValueError(
+                "Looking up a format should be done by name or by extension."
+            )
+
+        if name == "":
+            raise ValueError("No format matches the empty string.")
+
+        # Test if name is existing file
+        if Path(name).is_file():
+            # legacy compatibility - why test reading here??
+            try:
+                return imopen(name, "r", legacy_mode=True)._format
+            except ValueError:
+                # no plugin can read the file
+                pass
+
+        config = _get_config(name.upper())
+
+        try:
+            return config.format
+        except ImportError:
+            raise ImportError(
+                f"The `{config.name}` format is not installed. "
+                f"Use `pip install imageio[{config.install_name}]` to install it."
+            )
+
+    def sort(self, *names):
+        """sort(name1, name2, name3, ...)
+
+        Sort the formats based on zero or more given names; a format with
+        a name that matches one of the given names will take precedence
+        over other formats. A match means an equal name, or ending with
+        that name (though the former counts higher). Case insensitive.
+
+        Format preference will match the order of the given names: using
+        ``sort('TIFF', '-FI', '-PIL')`` would prefer the FreeImage formats
+        over the Pillow formats, but prefer TIFF even more. Each time
+        this is called, the starting point is the default format order,
+        and calling ``sort()`` with no arguments will reset the order.
+
+        Be aware that using the function can affect the behavior of
+        other code that makes use of imageio.
+
+        Also see the ``IMAGEIO_FORMAT_ORDER`` environment variable.
+        """
+
+        warnings.warn(
+            "`FormatManager` is deprecated and it will be removed in ImageIO v3."
+            " Migrating `FormatManager.sort` depends on your use-case:\n"
+            "\t- modify `iio.config.known_plugins` to specify the search order for "
+            "unrecognized formats.\n"
+            "\t- modify `iio.config.known_extensions[<extension>].priority`"
+            " to control a specific extension.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        # Check and sanitize imput
+        for name in names:
+            if not isinstance(name, str):
+                raise TypeError("formats.sort() accepts only string names.")
+            if any(c in name for c in ".,"):
+                raise ValueError(
+                    "Names given to formats.sort() should not "
+                    "contain dots `.` or commas `,`."
+                )
+
+        should_reset = len(names) == 0
+        if should_reset:
+            names = _original_order
+
+        sane_names = [name.strip().upper() for name in names if name != ""]
+
+        # enforce order for every extension that uses it
+        flat_extensions = [
+            ext for ext_list in known_extensions.values() for ext in ext_list
+        ]
+        for extension in flat_extensions:
+            if should_reset:
+                extension.reset()
+                continue
+
+            for name in reversed(sane_names):
+                for plugin in [x for x in extension.default_priority]:
+                    if plugin.endswith(name):
+                        extension.priority.remove(plugin)
+                        extension.priority.insert(0, plugin)
+
+        old_order = known_plugins.copy()
+        known_plugins.clear()
+
+        for name in sane_names:
+            plugin = old_order.pop(name, None)
+            if plugin is not None:
+                known_plugins[name] = plugin
+
+        known_plugins.update(old_order)
+
+    def add_format(self, iio_format, overwrite=False):
+        """add_format(format, overwrite=False)
+
+        Register a format, so that imageio can use it. If a format with the
+        same name already exists, an error is raised, unless overwrite is True,
+        in which case the current format is replaced.
+        """
+
+        warnings.warn(
+            "`FormatManager` is deprecated and it will be removed in ImageIO v3."
+            "To migrate `FormatManager.add_format` add the plugin directly to "
+            "`iio.config.known_plugins`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        if not isinstance(iio_format, Format):
+            raise ValueError("add_format needs argument to be a Format object")
+        elif not overwrite and iio_format.name in self.get_format_names():
+            raise ValueError(
+                f"A Format named {iio_format.name} is already registered, use"
+                " `overwrite=True` to replace."
+            )
+
+        config = PluginConfig(
+            name=iio_format.name.upper(),
+            class_name=iio_format.__class__.__name__,
+            module_name=iio_format.__class__.__module__,
+            is_legacy=True,
+            install_name="unknown",
+            legacy_args={
+                "name": iio_format.name,
+                "description": iio_format.description,
+                "extensions": " ".join(iio_format.extensions),
+                "modes": iio_format.modes,
+            },
+        )
+
+        known_plugins[config.name] = config
+
+        for extension in iio_format.extensions:
+            # be conservative and always treat it as a unique file format
+            ext = FileExtension(
+                extension=extension,
+                priority=[config.name],
+                name="Unique Format",
+                description="A format inserted at runtime."
+                f" It is being read by the `{config.name}` plugin.",
+            )
+            known_extensions.setdefault(extension, list()).append(ext)
+
+    def search_read_format(self, request):
+        """search_read_format(request)
+
+        Search a format that can read a file according to the given request.
+        Returns None if no appropriate format was found. (used internally)
+        """
+
+        try:
+            # in legacy_mode imopen returns a LegacyPlugin
+            return imopen(request, request.mode.io_mode, legacy_mode=True)._format
+        except ValueError:
+            # no plugin can read this request
+            # but the legacy API doesn't raise
+            return None
+
+    def search_write_format(self, request):
+        """search_write_format(request)
+
+        Search a format that can write a file according to the given request.
+        Returns None if no appropriate format was found. (used internally)
+        """
+
+        try:
+            # in legacy_mode imopen returns a LegacyPlugin
+            return imopen(request, request.mode.io_mode, legacy_mode=True)._format
+        except ValueError:
+            # no plugin can write this request
+            # but the legacy API doesn't raise
+            return None
+
+    def get_format_names(self):
+        """Get the names of all registered formats."""
+
+        warnings.warn(
+            "`FormatManager` is deprecated and it will be removed in ImageIO v3."
+            "To migrate `FormatManager.get_format_names` use `iio.config.known_plugins.keys()` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        return [f.name for f in self._formats]
+
+    def show(self):
+        """Show a nicely formatted list of available formats"""
+        print(self)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/imopen.py

@@ -0,0 +1,303 @@
+from pathlib import Path
+import warnings
+
+from ..config import known_plugins
+from ..config.extensions import known_extensions
+from .request import (
+    SPECIAL_READ_URIS,
+    URI_FILENAME,
+    InitializationError,
+    IOMode,
+    Request,
+)
+
+
+def imopen(
+    uri,
+    io_mode,
+    *,
+    plugin=None,
+    extension=None,
+    format_hint=None,
+    legacy_mode=False,
+    **kwargs,
+):
+    """Open an ImageResource.
+
+    .. warning::
+        This warning is for pypy users. If you are not using a context manager,
+        remember to deconstruct the returned plugin to avoid leaking the file
+        handle to an unclosed file.
+
+    Parameters
+    ----------
+    uri : str or pathlib.Path or bytes or file or Request
+        The :doc:`ImageResource <../../user_guide/requests>` to load the
+        image from.
+    io_mode : str
+        The mode in which the file is opened. Possible values are::
+
+            ``r`` - open the file for reading
+            ``w`` - open the file for writing
+
+        Depreciated since v2.9:
+        A second character can be added to give the reader a hint on what
+        the user expects. This will be ignored by new plugins and will
+        only have an effect on legacy plugins. Possible values are::
+
+            ``i`` for a single image,
+            ``I`` for multiple images,
+            ``v`` for a single volume,
+            ``V`` for multiple volumes,
+            ``?`` for don't care (default)
+
+    plugin : str, Plugin, or None
+        The plugin to use. If set to None (default) imopen will perform a
+        search for a matching plugin. If not None, this takes priority over
+        the provided format hint.
+    extension : str
+        If not None, treat the provided ImageResource as if it had the given
+        extension. This affects the order in which backends are considered, and
+        when writing this may also influence the format used when encoding.
+    format_hint : str
+        A format hint to help optimize plugin selection given as the format's
+        extension, e.g. ".png". This can speed up the selection process for
+        ImageResources that don't have an explicit extension, e.g. streams, or
+        for ImageResources where the extension does not match the resource's
+        content. If the ImageResource lacks an explicit extension, it will be
+        set to this format.
+    legacy_mode : bool
+        If true (default) use the v2 behavior when searching for a suitable
+        plugin. This will ignore v3 plugins and will check ``plugin``
+        against known extensions if no plugin with the given name can be found.
+    **kwargs : Any
+        Additional keyword arguments will be passed to the plugin upon
+        construction.
+
+    Notes
+    -----
+    Registered plugins are controlled via the ``known_plugins`` dict in
+    ``imageio.config``.
+
+    Passing a ``Request`` as the uri is only supported if ``legacy_mode``
+    is ``True``. In this case ``io_mode`` is ignored.
+
+    Using the kwarg ``format_hint`` does not enforce the given format. It merely
+    provides a `hint` to the selection process and plugin. The selection
+    processes uses this hint for optimization; however, a plugin's decision how
+    to read a ImageResource will - typically - still be based on the content of
+    the resource.
+
+
+    Examples
+    --------
+
+    >>> import imageio.v3 as iio
+    >>> with iio.imopen("/path/to/image.png", "r") as file:
+    >>>     im = file.read()
+
+    >>> with iio.imopen("/path/to/output.jpg", "w") as file:
+    >>>     file.write(im)
+
+    """
+
+    if isinstance(uri, Request) and legacy_mode:
+        warnings.warn(
+            "`iio.core.Request` is a low-level object and using it"
+            " directly as input to `imopen` is discouraged. This will raise"
+            " an exception in ImageIO v3.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        request = uri
+        uri = request.raw_uri
+        io_mode = request.mode.io_mode
+        request.format_hint = format_hint
+    else:
+        request = Request(uri, io_mode, format_hint=format_hint, extension=extension)
+
+    source = "<bytes>" if isinstance(uri, bytes) else uri
+
+    # fast-path based on plugin
+    # (except in legacy mode)
+    if plugin is not None:
+        if isinstance(plugin, str):
+            try:
+                config = known_plugins[plugin]
+            except KeyError:
+                request.finish()
+                raise ValueError(
+                    f"`{plugin}` is not a registered plugin name."
+                ) from None
+
+            def loader(request, **kwargs):
+                return config.plugin_class(request, **kwargs)
+
+        elif not legacy_mode:
+
+            def loader(request, **kwargs):
+                return plugin(request, **kwargs)
+
+        else:
+            request.finish()
+            raise ValueError("The `plugin` argument must be a string.")
+
+        try:
+            return loader(request, **kwargs)
+        except InitializationError as class_specific:
+            err_from = class_specific
+            err_type = RuntimeError if legacy_mode else IOError
+            err_msg = f"`{plugin}` can not handle the given uri."
+        except ImportError:
+            err_from = None
+            err_type = ImportError
+            err_msg = (
+                f"The `{config.name}` plugin is not installed. "
+                f"Use `pip install imageio[{config.install_name}]` to install it."
+            )
+        except Exception as generic_error:
+            err_from = generic_error
+            err_type = IOError
+            err_msg = f"An unknown error occured while initializing plugin `{plugin}`."
+
+        request.finish()
+        raise err_type(err_msg) from err_from
+
+    # fast-path based on format_hint
+    if request.format_hint is not None:
+        for candidate_format in known_extensions[format_hint]:
+            for plugin_name in candidate_format.priority:
+                config = known_plugins[plugin_name]
+
+                # v2 compatibility; delete in v3
+                if legacy_mode and not config.is_legacy:
+                    continue
+
+                try:
+                    candidate_plugin = config.plugin_class
+                except ImportError:
+                    # not installed
+                    continue
+
+                try:
+                    plugin_instance = candidate_plugin(request, **kwargs)
+                except InitializationError:
+                    # file extension doesn't match file type
+                    continue
+
+                return plugin_instance
+        else:
+            resource = (
+                "<bytes>" if isinstance(request.raw_uri, bytes) else request.raw_uri
+            )
+            warnings.warn(f"`{resource}` can not be opened as a `{format_hint}` file.")
+
+    # fast-path based on file extension
+    if request.extension in known_extensions:
+        for candidate_format in known_extensions[request.extension]:
+            for plugin_name in candidate_format.priority:
+                config = known_plugins[plugin_name]
+
+                # v2 compatibility; delete in v3
+                if legacy_mode and not config.is_legacy:
+                    continue
+
+                try:
+                    candidate_plugin = config.plugin_class
+                except ImportError:
+                    # not installed
+                    continue
+
+                try:
+                    plugin_instance = candidate_plugin(request, **kwargs)
+                except InitializationError:
+                    # file extension doesn't match file type
+                    continue
+
+                return plugin_instance
+
+    # error out for read-only special targets
+    # this is hacky; can we come up with a better solution for this?
+    if request.mode.io_mode == IOMode.write:
+        if isinstance(uri, str) and uri.startswith(SPECIAL_READ_URIS):
+            request.finish()
+            err_type = ValueError if legacy_mode else IOError
+            err_msg = f"`{source}` is read-only."
+            raise err_type(err_msg)
+
+    # error out for directories
+    # this is a bit hacky and should be cleaned once we decide
+    # how to gracefully handle DICOM
+    if request._uri_type == URI_FILENAME and Path(request.raw_uri).is_dir():
+        request.finish()
+        err_type = ValueError if legacy_mode else IOError
+        err_msg = (
+            "ImageIO does not generally support reading folders. "
+            "Limited support may be available via specific plugins. "
+            "Specify the plugin explicitly using the `plugin` kwarg, e.g. `plugin='DICOM'`"
+        )
+        raise err_type(err_msg)
+
+    # close the current request here and use fresh/new ones while trying each
+    # plugin This is slow (means potentially reopening a resource several
+    # times), but should only happen rarely because this is the fallback if all
+    # else fails.
+    request.finish()
+
+    # fallback option: try all plugins
+    for config in known_plugins.values():
+        # Note: for v2 compatibility
+        # this branch can be removed in ImageIO v3.0
+        if legacy_mode and not config.is_legacy:
+            continue
+
+        # each plugin gets its own request
+        request = Request(uri, io_mode, format_hint=format_hint)
+
+        try:
+            plugin_instance = config.plugin_class(request, **kwargs)
+        except InitializationError:
+            continue
+        except ImportError:
+            continue
+        else:
+            return plugin_instance
+
+    err_type = ValueError if legacy_mode else IOError
+    err_msg = f"Could not find a backend to open `{source}`` with iomode `{io_mode}`."
+
+    # check if a missing plugin could help
+    if request.extension in known_extensions:
+        missing_plugins = list()
+
+        formats = known_extensions[request.extension]
+        plugin_names = [
+            plugin for file_format in formats for plugin in file_format.priority
+        ]
+        for name in plugin_names:
+            config = known_plugins[name]
+
+            try:
+                config.plugin_class
+                continue
+            except ImportError:
+                missing_plugins.append(config)
+
+        if len(missing_plugins) > 0:
+            install_candidates = "\n".join(
+                [
+                    (
+                        f"  {config.name}:  "
+                        f"pip install imageio[{config.install_name}]"
+                    )
+                    for config in missing_plugins
+                ]
+            )
+            err_msg += (
+                "\nBased on the extension, the following plugins might add capable backends:\n"
+                f"{install_candidates}"
+            )
+
+    request.finish()
+    raise err_type(err_msg)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/legacy_plugin_wrapper.py

@@ -0,0 +1,322 @@
+import numpy as np
+from pathlib import Path
+
+from .request import IOMode, InitializationError
+from .v3_plugin_api import PluginV3, ImageProperties
+
+
+def _legacy_default_index(format):
+    if format._name == "FFMPEG":
+        index = Ellipsis
+    elif format._name == "GIF-PIL":
+        index = Ellipsis
+    else:
+        index = 0
+
+    return index
+
+
+class LegacyPlugin(PluginV3):
+    """A plugin to  make old (v2.9) plugins compatible with v3.0
+
+    .. depreciated:: 2.9
+        `legacy_get_reader` will be removed in a future version of imageio.
+        `legacy_get_writer` will be removed in a future version of imageio.
+
+    This plugin is a wrapper around the old FormatManager class and exposes
+    all the old plugins via the new API. On top of this it has
+    ``legacy_get_reader`` and ``legacy_get_writer`` methods to allow using
+    it with the v2.9 API.
+
+    Methods
+    -------
+    read(index=None, **kwargs)
+        Read the image at position ``index``.
+    write(image, **kwargs)
+        Write image to the URI.
+    iter(**kwargs)
+        Iteratively yield images from the given URI.
+    get_meta(index=None)
+        Return the metadata for the image at position ``index``.
+    legacy_get_reader(**kwargs)
+        Returns the v2.9 image reader. (depreciated)
+    legacy_get_writer(**kwargs)
+        Returns the v2.9 image writer. (depreciated)
+
+    Examples
+    --------
+
+    >>> import imageio.v3 as iio
+    >>> with iio.imopen("/path/to/image.tiff", "r", legacy_mode=True) as file:
+    >>>     reader = file.legacy_get_reader()  # depreciated
+    >>>     for im in file.iter():
+    >>>         print(im.shape)
+
+    """
+
+    def __init__(self, request, legacy_plugin):
+        """Instantiate a new Legacy Plugin
+
+        Parameters
+        ----------
+        uri : {str, pathlib.Path, bytes, file}
+            The resource to load the image from, e.g. a filename, pathlib.Path,
+            http address or file object, see the docs for more info.
+        legacy_plugin : Format
+            The (legacy) format to use to interface with the URI.
+
+        """
+        self._request = request
+        self._format = legacy_plugin
+
+        source = (
+            "<bytes>"
+            if isinstance(self._request.raw_uri, bytes)
+            else self._request.raw_uri
+        )
+        if self._request.mode.io_mode == IOMode.read:
+            if not self._format.can_read(request):
+                raise InitializationError(
+                    f"`{self._format.name}`" f" can not read `{source}`."
+                )
+        else:
+            if not self._format.can_write(request):
+                raise InitializationError(
+                    f"`{self._format.name}`" f" can not write to `{source}`."
+                )
+
+    def legacy_get_reader(self, **kwargs):
+        """legacy_get_reader(**kwargs)
+
+        a utility method to provide support vor the V2.9 API
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See :func:`.help`
+            to see what arguments are available for a particular format.
+        """
+
+        # Note: this will break thread-safety
+        self._request._kwargs = kwargs
+
+        # safeguard for DICOM plugin reading from folders
+        try:
+            assert Path(self._request.filename).is_dir()
+        except OSError:
+            pass  # not a valid path on this OS
+        except AssertionError:
+            pass  # not a folder
+        else:
+            return self._format.get_reader(self._request)
+
+        self._request.get_file().seek(0)
+        return self._format.get_reader(self._request)
+
+    def read(self, *, index=None, **kwargs):
+        """
+        Parses the given URI and creates a ndarray from it.
+
+        Parameters
+        ----------
+        index : {integer, None}
+            If the URI contains a list of ndimages return the index-th
+            image. If None, stack all images into an ndimage along the
+            0-th dimension (equivalent to np.stack(imgs, axis=0)).
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See
+            :func:`.help` to see what arguments are available for a particular
+            format.
+
+        Returns
+        -------
+        ndimage : np.ndarray
+            A numpy array containing the decoded image data.
+
+        """
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        if index is Ellipsis:
+            img = np.stack([im for im in self.iter(**kwargs)])
+            return img
+
+        reader = self.legacy_get_reader(**kwargs)
+        return reader.get_data(index)
+
+    def legacy_get_writer(self, **kwargs):
+        """legacy_get_writer(**kwargs)
+
+        Returns a :class:`.Writer` object which can be used to write data
+        and meta data to the specified file.
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the writer. See :func:`.help`
+            to see what arguments are available for a particular format.
+        """
+
+        # Note: this will break thread-safety
+        self._request._kwargs = kwargs
+        return self._format.get_writer(self._request)
+
+    def write(self, ndimage, **kwargs):
+        """
+        Write an ndimage to the URI specified in path.
+
+        If the URI points to a file on the current host and the file does not
+        yet exist it will be created. If the file exists already, it will be
+        appended if possible; otherwise, it will be replaced.
+
+        Parameters
+        ----------
+        image : numpy.ndarray
+            The ndimage or list of ndimages to write.
+        kwargs : ...
+            Further keyword arguments are passed to the writer. See
+            :func:`.help` to see what arguments are available for a
+            particular format.
+        """
+        with self.legacy_get_writer(**kwargs) as writer:
+            if self._request.mode.image_mode in "iv":
+                writer.append_data(ndimage)
+            else:
+                if len(ndimage) == 0:
+                    raise RuntimeError("Zero images were written.")
+                for written, ndimage in enumerate(ndimage):
+                    # Test image
+                    imt = type(ndimage)
+                    ndimage = np.asanyarray(ndimage)
+                    if not np.issubdtype(ndimage.dtype, np.number):
+                        raise ValueError(
+                            "Image is not numeric, but {}.".format(imt.__name__)
+                        )
+                    elif self._request.mode.image_mode == "I":
+                        if ndimage.ndim == 2:
+                            pass
+                        elif ndimage.ndim == 3 and ndimage.shape[2] in [1, 3, 4]:
+                            pass
+                        else:
+                            raise ValueError(
+                                "Image must be 2D " "(grayscale, RGB, or RGBA)."
+                            )
+                    elif self._request.mode.image_mode == "V":
+                        if ndimage.ndim == 3:
+                            pass
+                        elif ndimage.ndim == 4 and ndimage.shape[3] < 32:
+                            pass
+                        else:
+                            raise ValueError(
+                                "Image must be 3D," " or 4D if each voxel is a tuple."
+                            )
+
+                    # Add image
+                    writer.append_data(ndimage)
+
+        return writer.request.get_result()
+
+    def iter(self, **kwargs):
+        """Iterate over a list of ndimages given by the URI
+
+        Parameters
+        ----------
+        kwargs : ...
+            Further keyword arguments are passed to the reader. See
+            :func:`.help` to see what arguments are available for a particular
+            format.
+        """
+
+        reader = self.legacy_get_reader(**kwargs)
+        for image in reader:
+            yield image
+
+    def properties(self, index=None):
+        """Standardized ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            The index of the ndimage for which to return properties. If the
+            index is out of bounds a ``ValueError`` is raised. If ``None``,
+            return the properties for the ndimage stack. If this is impossible,
+            e.g., due to shape missmatch, an exception will be raised.
+
+        Returns
+        -------
+        properties : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        """
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        # for backwards compatibility ... actually reads pixel data :(
+        image = self.read(index=index)
+
+        return ImageProperties(
+            shape=image.shape,
+            dtype=image.dtype,
+            is_batch=True if index is None else False,
+        )
+
+    def get_meta(self, *, index=None):
+        """Read ndimage metadata from the URI
+
+        Parameters
+        ----------
+        index : {integer, None}
+            If the URI contains a list of ndimages return the metadata
+            corresponding to the index-th image. If None, behavior depends on
+            the used api
+
+            Legacy-style API: return metadata of the first element (index=0)
+            New-style API: Behavior depends on the used Plugin.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary of metadata.
+
+        """
+
+        return self.metadata(index=index, exclude_applied=False)
+
+    def metadata(self, index=None, exclude_applied: bool = True):
+        """Format-Specific ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            The index of the ndimage to read. If the index is out of bounds a
+            ``ValueError`` is raised. If ``None``, global metadata is returned.
+        exclude_applied : bool
+            If True (default), do not report metadata fields that the plugin
+            would apply/consume while reading the image.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary filled with format-specific metadata fields and their
+            values.
+
+        """
+
+        if exclude_applied:
+            raise ValueError(
+                "Legacy plugins don't support excluding applied metadata fields."
+            )
+
+        if index is None:
+            index = _legacy_default_index(self._format)
+
+        return self.legacy_get_reader().get_meta_data(index=index)
+
+    def __del__(self) -> None:
+        pass
+        # turns out we can't close the file here for LegacyPlugin
+        # because it would break backwards compatibility
+        # with legacy_get_writer and legacy_get_reader
+        # self._request.finish()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/request.py

@@ -0,0 +1,752 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""
+Definition of the Request object, which acts as a kind of bridge between
+what the user wants and what the plugins can.
+"""
+
+import os
+from io import BytesIO
+import zipfile
+import tempfile
+import shutil
+import enum
+import warnings
+
+from ..core import urlopen, get_remote_file
+
+from pathlib import Path
+from urllib.parse import urlparse
+from typing import Optional
+
+# URI types
+URI_BYTES = 1
+URI_FILE = 2
+URI_FILENAME = 3
+URI_ZIPPED = 4
+URI_HTTP = 5
+URI_FTP = 6
+
+
+class IOMode(str, enum.Enum):
+    """Available Image modes
+
+    This is a helper enum for ``Request.Mode`` which is a composite of a
+    ``Request.ImageMode`` and ``Request.IOMode``. The IOMode that tells the
+    plugin if the resource should be read from or written to. Available values are
+
+    - read ("r"): Read from the specified resource
+    - write ("w"): Write to the specified resource
+
+    """
+
+    read = "r"
+    write = "w"
+
+
+class ImageMode(str, enum.Enum):
+    """Available Image modes
+
+    This is a helper enum for ``Request.Mode`` which is a composite of a
+    ``Request.ImageMode`` and ``Request.IOMode``. The image mode that tells the
+    plugin the desired (and expected) image shape. Available values are
+
+    - single_image ("i"): Return a single image extending in two spacial
+      dimensions
+    - multi_image ("I"): Return a list of images extending in two spacial
+      dimensions
+    - single_volume ("v"): Return an image extending into multiple dimensions.
+      E.g. three spacial dimensions for image stacks, or two spatial and one
+      time dimension for videos
+    - multi_volume ("V"): Return a list of images extending into multiple
+      dimensions.
+    - any_mode ("?"): Return an image in any format (the plugin decides the
+      appropriate action).
+
+    """
+
+    single_image = "i"
+    multi_image = "I"
+    single_volume = "v"
+    multi_volume = "V"
+    any_mode = "?"
+
+
+@enum.unique
+class Mode(str, enum.Enum):
+    """The mode to use when interacting with the resource
+
+    ``Request.Mode`` is a composite of ``Request.ImageMode`` and
+    ``Request.IOMode``. The image mode that tells the plugin the desired (and
+    expected) image shape and the ``Request.IOMode`` tells the plugin the way
+    the resource should be interacted with. For a detailed description of the
+    available modes, see the documentation for ``Request.ImageMode`` and
+    ``Request.IOMode`` respectively.
+
+    Available modes are all combinations of ``Request.IOMode`` and ``Request.ImageMode``:
+
+    - read_single_image ("ri")
+    - read_multi_image ("rI")
+    - read_single_volume ("rv")
+    - read_multi_volume ("rV")
+    - read_any ("r?")
+    - write_single_image ("wi")
+    - write_multi_image ("wI")
+    - write_single_volume ("wv")
+    - write_multi_volume ("wV")
+    - write_any ("w?")
+
+    Examples
+    --------
+    >>> Request.Mode("rI")  # a list of simple images should be read from the resource
+    >>> Request.Mode("wv")  # a single volume should be written to the resource
+
+    """
+
+    read_single_image = "ri"
+    read_multi_image = "rI"
+    read_single_volume = "rv"
+    read_multi_volume = "rV"
+    read_any = "r?"
+    write_single_image = "wi"
+    write_multi_image = "wI"
+    write_single_volume = "wv"
+    write_multi_volume = "wV"
+    write_any = "w?"
+
+    @classmethod
+    def _missing_(cls, value):
+        """Enable Mode("r") and Mode("w")
+
+        The sunder method ``_missing_`` is called whenever the constructor fails
+        to directly look up the corresponding enum value from the given input.
+        In our case, we use it to convert the modes "r" and "w" (from the v3
+        API) into their legacy versions "r?" and "w?".
+
+        More info on _missing_:
+        https://docs.python.org/3/library/enum.html#supported-sunder-names
+        """
+
+        if value == "r":
+            return cls("r?")
+        elif value == "w":
+            return cls("w?")
+        else:
+            raise ValueError(f"{value} is no valid Mode.")
+
+    @property
+    def io_mode(self) -> IOMode:
+        return IOMode(self.value[0])
+
+    @property
+    def image_mode(self) -> ImageMode:
+        return ImageMode(self.value[1])
+
+    def __getitem__(self, key):
+        """For backwards compatibility with the old non-enum modes"""
+        if key == 0:
+            return self.io_mode
+        elif key == 1:
+            return self.image_mode
+        else:
+            raise IndexError(f"Mode has no item {key}")
+
+
+SPECIAL_READ_URIS = "<video", "<screen>", "<clipboard>"
+
+# The user can use this string in a write call to get the data back as bytes.
+RETURN_BYTES = "<bytes>"
+
+# Example images that will be auto-downloaded
+EXAMPLE_IMAGES = {
+    "astronaut.png": "Image of the astronaut Eileen Collins",
+    "camera.png": "A grayscale image of a photographer",
+    "checkerboard.png": "Black and white image of a chekerboard",
+    "wood.jpg": "A (repeatable) texture of wooden planks",
+    "bricks.jpg": "A (repeatable) texture of stone bricks",
+    "clock.png": "Photo of a clock with motion blur (Stefan van der Walt)",
+    "coffee.png": "Image of a cup of coffee (Rachel Michetti)",
+    "chelsea.png": "Image of Stefan's cat",
+    "wikkie.png": "Image of Almar's cat",
+    "coins.png": "Image showing greek coins from Pompeii",
+    "horse.png": "Image showing the silhouette of a horse (Andreas Preuss)",
+    "hubble_deep_field.png": "Photograph taken by Hubble telescope (NASA)",
+    "immunohistochemistry.png": "Immunohistochemical (IHC) staining",
+    "moon.png": "Image showing a portion of the surface of the moon",
+    "page.png": "A scanned page of text",
+    "text.png": "A photograph of handdrawn text",
+    "chelsea.zip": "The chelsea.png in a zipfile (for testing)",
+    "chelsea.bsdf": "The chelsea.png in a BSDF file(for testing)",
+    "newtonscradle.gif": "Animated GIF of a newton's cradle",
+    "cockatoo.mp4": "Video file of a cockatoo",
+    "stent.npz": "Volumetric image showing a stented abdominal aorta",
+    "meadow_cube.jpg": "A cubemap image of a meadow, e.g. to render a skybox.",
+}
+
+
+class Request(object):
+    """ImageResource handling utility.
+
+    Represents a request for reading or saving an image resource. This
+    object wraps information to that request and acts as an interface
+    for the plugins to several resources; it allows the user to read
+    from filenames, files, http, zipfiles, raw bytes, etc., but offer
+    a simple interface to the plugins via ``get_file()`` and
+    ``get_local_filename()``.
+
+    For each read/write operation a single Request instance is used and passed
+    to the can_read/can_write method of a format, and subsequently to
+    the Reader/Writer class. This allows rudimentary passing of
+    information between different formats and between a format and
+    associated reader/writer.
+
+    Parameters
+    ----------
+    uri : {str, bytes, file}
+        The resource to load the image from.
+    mode : str
+        The first character is "r" or "w", indicating a read or write
+        request. The second character is used to indicate the kind of data:
+        "i" for an image, "I" for multiple images, "v" for a volume,
+        "V" for multiple volumes, "?" for don't care.
+
+    """
+
+    def __init__(self, uri, mode, *, extension=None, format_hint: str = None, **kwargs):
+
+        # General
+        self.raw_uri = uri
+        self._uri_type = None
+        self._filename = None
+        self._extension = None
+        self._format_hint = None
+        self._kwargs = kwargs
+        self._result = None  # Some write actions may have a result
+
+        # To handle the user-side
+        self._filename_zip = None  # not None if a zipfile is used
+        self._bytes = None  # Incoming bytes
+        self._zipfile = None  # To store a zipfile instance (if used)
+
+        # To handle the plugin side
+        self._file = None  # To store the file instance
+        self._file_is_local = False  # whether the data needs to be copied at end
+        self._filename_local = None  # not None if using tempfile on this FS
+        self._firstbytes = None  # For easy header parsing
+
+        # To store formats that may be able to fulfil this request
+        # self._potential_formats = []
+
+        # Check mode
+        try:
+            self._mode = Mode(mode)
+        except ValueError:
+            raise ValueError(f"Invalid Request.Mode: {mode}")
+
+        # Parse what was given
+        self._parse_uri(uri)
+
+        # Set extension
+        if extension is not None:
+            if extension[0] != ".":
+                raise ValueError(
+                    "`extension` should be a file extension starting with a `.`,"
+                    f" but is `{extension}`."
+                )
+            self._extension = extension
+        elif self._filename is not None:
+            if self._uri_type in (URI_FILENAME, URI_ZIPPED):
+                path = self._filename
+            else:
+                path = urlparse(self._filename).path
+            ext = Path(path).suffix.lower()
+            self._extension = ext if ext != "" else None
+
+        if format_hint is not None:
+            warnings.warn(
+                "The usage of `format_hint` is deprecated and will be removed in ImageIO v3."
+                " Use `extension` instead."
+            )
+
+        if format_hint is not None and format_hint[0] != ".":
+            raise ValueError(
+                "`format_hint` should be a file extension starting with a `.`,"
+                f" but is `{format_hint}`."
+            )
+
+        self.format_hint = format_hint
+
+    def _parse_uri(self, uri):
+        """Try to figure our what we were given"""
+        is_read_request = self.mode.io_mode is IOMode.read
+        is_write_request = self.mode.io_mode is IOMode.write
+
+        if isinstance(uri, str):
+            # Explicit
+            if uri.startswith("imageio:"):
+                if is_write_request:
+                    raise RuntimeError("Cannot write to the standard images.")
+                fn = uri.split(":", 1)[-1].lower()
+                fn, _, zip_part = fn.partition(".zip/")
+                if zip_part:
+                    fn += ".zip"
+                if fn not in EXAMPLE_IMAGES:
+                    raise ValueError("Unknown standard image %r." % fn)
+                self._uri_type = URI_FILENAME
+                self._filename = get_remote_file("images/" + fn, auto=True)
+                if zip_part:
+                    self._filename += "/" + zip_part
+            elif uri.startswith("http://") or uri.startswith("https://"):
+                self._uri_type = URI_HTTP
+                self._filename = uri
+            elif uri.startswith("ftp://") or uri.startswith("ftps://"):
+                self._uri_type = URI_FTP
+                self._filename = uri
+            elif uri.startswith("file://"):
+                self._uri_type = URI_FILENAME
+                self._filename = uri[7:]
+            elif uri.startswith(SPECIAL_READ_URIS) and is_read_request:
+                self._uri_type = URI_BYTES
+                self._filename = uri
+            elif uri.startswith(RETURN_BYTES) and is_write_request:
+                self._uri_type = URI_BYTES
+                self._filename = uri
+            else:
+                self._uri_type = URI_FILENAME
+                self._filename = uri
+
+        elif isinstance(uri, memoryview) and is_read_request:
+            self._uri_type = URI_BYTES
+            self._filename = "<bytes>"
+            self._bytes = uri.tobytes()
+        elif isinstance(uri, bytes) and is_read_request:
+            self._uri_type = URI_BYTES
+            self._filename = "<bytes>"
+            self._bytes = uri
+        elif isinstance(uri, Path):
+            self._uri_type = URI_FILENAME
+            self._filename = str(uri)
+        # Files
+        elif is_read_request:
+            if hasattr(uri, "read") and hasattr(uri, "close"):
+                self._uri_type = URI_FILE
+                self._filename = "<file>"
+                self._file = uri  # Data must be read from here
+        elif is_write_request:
+            if hasattr(uri, "write") and hasattr(uri, "close"):
+                self._uri_type = URI_FILE
+                self._filename = "<file>"
+                self._file = uri  # Data must be written here
+
+        # Expand user dir
+        if self._uri_type == URI_FILENAME and self._filename.startswith("~"):
+            self._filename = os.path.expanduser(self._filename)
+
+        # Check if a zipfile
+        if self._uri_type == URI_FILENAME:
+            # Search for zip extension followed by a path separater
+            for needle in [".zip/", ".zip\\"]:
+                zip_i = self._filename.lower().find(needle)
+                if zip_i > 0:
+                    zip_i += 4
+                    zip_path = self._filename[:zip_i]
+                    if os.path.isdir(zip_path):
+                        pass  # is an existing dir (see #548)
+                    elif is_write_request or os.path.isfile(zip_path):
+                        self._uri_type = URI_ZIPPED
+                        self._filename_zip = (
+                            zip_path,
+                            self._filename[zip_i:].lstrip("/\\"),
+                        )
+                        break
+
+        # Check if we could read it
+        if self._uri_type is None:
+            uri_r = repr(uri)
+            if len(uri_r) > 60:
+                uri_r = uri_r[:57] + "..."
+            raise IOError("Cannot understand given URI: %s." % uri_r)
+
+        # Check if this is supported
+        noWriting = [URI_HTTP, URI_FTP]
+        if is_write_request and self._uri_type in noWriting:
+            raise IOError("imageio does not support writing to http/ftp.")
+
+        # Deprecated way to load standard images, give a sensible error message
+        if is_read_request and self._uri_type in [URI_FILENAME, URI_ZIPPED]:
+            fn = self._filename
+            if self._filename_zip:
+                fn = self._filename_zip[0]
+            if (not os.path.exists(fn)) and (fn in EXAMPLE_IMAGES):
+                raise IOError(
+                    "No such file: %r. This file looks like one of "
+                    "the standard images, but from imageio 2.1, "
+                    "standard images have to be specified using "
+                    '"imageio:%s".' % (fn, fn)
+                )
+
+        # Make filename absolute
+        if self._uri_type in [URI_FILENAME, URI_ZIPPED]:
+            if self._filename_zip:
+                self._filename_zip = (
+                    os.path.abspath(self._filename_zip[0]),
+                    self._filename_zip[1],
+                )
+            else:
+                self._filename = os.path.abspath(self._filename)
+
+        # Check whether file name is valid
+        if self._uri_type in [URI_FILENAME, URI_ZIPPED]:
+            fn = self._filename
+            if self._filename_zip:
+                fn = self._filename_zip[0]
+            if is_read_request:
+                # Reading: check that the file exists (but is allowed a dir)
+                if not os.path.exists(fn):
+                    raise FileNotFoundError("No such file: '%s'" % fn)
+            else:
+                # Writing: check that the directory to write to does exist
+                dn = os.path.dirname(fn)
+                if not os.path.exists(dn):
+                    raise FileNotFoundError("The directory %r does not exist" % dn)
+
+    @property
+    def filename(self):
+        """Name of the ImageResource.
+
+
+        The uri for which reading/saving was requested. This
+        can be a filename, an http address, or other resource
+        identifier. Do not rely on the filename to obtain the data,
+        but use ``get_file()`` or ``get_local_filename()`` instead.
+        """
+        return self._filename
+
+    @property
+    def extension(self) -> str:
+        """The (lowercase) extension of the requested filename.
+        Suffixes in url's are stripped. Can be None if the request is
+        not based on a filename.
+        """
+        return self._extension
+
+    @property
+    def format_hint(self) -> Optional[str]:
+        return self._format_hint
+
+    @format_hint.setter
+    def format_hint(self, format: str) -> None:
+        self._format_hint = format
+        if self._extension is None:
+            self._extension = format
+
+    @property
+    def mode(self):
+        """The mode of the request. The first character is "r" or "w",
+        indicating a read or write request. The second character is
+        used to indicate the kind of data:
+        "i" for an image, "I" for multiple images, "v" for a volume,
+        "V" for multiple volumes, "?" for don't care.
+        """
+        return self._mode
+
+    @property
+    def kwargs(self):
+        """The dict of keyword arguments supplied by the user."""
+        return self._kwargs
+
+    # For obtaining data
+
+    def get_file(self):
+        """get_file()
+        Get a file object for the resource associated with this request.
+        If this is a reading request, the file is in read mode,
+        otherwise in write mode. This method is not thread safe. Plugins
+        should not close the file when done.
+
+        This is the preferred way to read/write the data. But if a
+        format cannot handle file-like objects, they should use
+        ``get_local_filename()``.
+        """
+        want_to_write = self.mode.io_mode is IOMode.write
+
+        # Is there already a file?
+        # Either _uri_type == URI_FILE, or we already opened the file,
+        # e.g. by using firstbytes
+        if self._file is not None:
+            return self._file
+
+        if self._uri_type == URI_BYTES:
+            if want_to_write:
+                # Create new file object, we catch the bytes in finish()
+                self._file = BytesIO()
+                self._file_is_local = True
+            else:
+                self._file = BytesIO(self._bytes)
+
+        elif self._uri_type == URI_FILENAME:
+            if want_to_write:
+                self._file = open(self.filename, "wb")
+            else:
+                self._file = open(self.filename, "rb")
+
+        elif self._uri_type == URI_ZIPPED:
+            # Get the correct filename
+            filename, name = self._filename_zip
+            if want_to_write:
+                # Create new file object, we catch the bytes in finish()
+                self._file = BytesIO()
+                self._file_is_local = True
+            else:
+                # Open zipfile and open new file object for specific file
+                self._zipfile = zipfile.ZipFile(filename, "r")
+                self._file = self._zipfile.open(name, "r")
+                self._file = SeekableFileObject(self._file)
+
+        elif self._uri_type in [URI_HTTP or URI_FTP]:
+            assert not want_to_write  # This should have been tested in init
+            timeout = os.getenv("IMAGEIO_REQUEST_TIMEOUT")
+            if timeout is None or not timeout.isdigit():
+                timeout = 5
+            self._file = urlopen(self.filename, timeout=float(timeout))
+            self._file = SeekableFileObject(self._file)
+
+        return self._file
+
+    def get_local_filename(self):
+        """get_local_filename()
+        If the filename is an existing file on this filesystem, return
+        that. Otherwise a temporary file is created on the local file
+        system which can be used by the format to read from or write to.
+        """
+
+        if self._uri_type == URI_FILENAME:
+            return self._filename
+        else:
+            # Get filename
+            if self.extension is not None:
+                ext = self.extension
+            else:
+                ext = os.path.splitext(self._filename)[1]
+            self._filename_local = tempfile.mktemp(ext, "imageio_")
+            # Write stuff to it?
+            if self.mode.io_mode == IOMode.read:
+                with open(self._filename_local, "wb") as file:
+                    shutil.copyfileobj(self.get_file(), file)
+            return self._filename_local
+
+    def finish(self) -> None:
+        """Wrap up this request.
+
+        Finishes any pending reads or writes, closes any open files and frees
+        any resources allocated by this request.
+        """
+
+        if self.mode.io_mode == IOMode.write:
+
+            # See if we "own" the data and must put it somewhere
+            bytes = None
+            if self._filename_local:
+                bytes = Path(self._filename_local).read_bytes()
+            elif self._file_is_local:
+                self._file_is_local = False
+                bytes = self._file.getvalue()
+
+            # Put the data in the right place
+            if bytes is not None:
+                if self._uri_type == URI_BYTES:
+                    self._result = bytes  # Picked up by imread function
+                elif self._uri_type == URI_FILE:
+                    self._file.write(bytes)
+                elif self._uri_type == URI_ZIPPED:
+                    zf = zipfile.ZipFile(self._filename_zip[0], "a")
+                    zf.writestr(self._filename_zip[1], bytes)
+                    zf.close()
+                # elif self._uri_type == URI_FILENAME: -> is always direct
+                # elif self._uri_type == URI_FTP/HTTP: -> write not supported
+
+        # Close open files that we know of (and are responsible for)
+        if self._file and self._uri_type != URI_FILE:
+            self._file.close()
+            self._file = None
+        if self._zipfile:
+            self._zipfile.close()
+            self._zipfile = None
+
+        # Remove temp file
+        if self._filename_local:
+            try:
+                os.remove(self._filename_local)
+            except Exception:  # pragma: no cover
+                warnings.warn(
+                    "Failed to delete the temporary file at "
+                    f"`{self._filename_local}`. Please report this issue."
+                )
+            self._filename_local = None
+
+        # Detach so gc can clean even if a reference of self lingers
+        self._bytes = None
+
+    def get_result(self):
+        """For internal use. In some situations a write action can have
+        a result (bytes data). That is obtained with this function.
+        """
+        # Is there a reason to disallow reading multiple times?
+        self._result, res = None, self._result
+        return res
+
+    @property
+    def firstbytes(self):
+        """The first 256 bytes of the file. These can be used to
+        parse the header to determine the file-format.
+        """
+        if self._firstbytes is None:
+            self._read_first_bytes()
+        return self._firstbytes
+
+    def _read_first_bytes(self, N=256):
+        if self._bytes is not None:
+            self._firstbytes = self._bytes[:N]
+        else:
+            # Prepare
+            try:
+                f = self.get_file()
+            except IOError:
+                if os.path.isdir(self.filename):  # A directory, e.g. for DICOM
+                    self._firstbytes = bytes()
+                    return
+                raise
+            try:
+                i = f.tell()
+            except Exception:
+                i = None
+            # Read
+            self._firstbytes = read_n_bytes(f, N)
+            # Set back
+            try:
+                if i is None:
+                    raise Exception("cannot seek with None")
+                f.seek(i)
+            except Exception:
+                # Prevent get_file() from reusing the file
+                self._file = None
+                # If the given URI was a file object, we have a problem,
+                if self._uri_type == URI_FILE:
+                    raise IOError("Cannot seek back after getting firstbytes!")
+
+
+def read_n_bytes(f, N):
+    """read_n_bytes(file, n)
+
+    Read n bytes from the given file, or less if the file has less
+    bytes. Returns zero bytes if the file is closed.
+    """
+    bb = bytes()
+    while len(bb) < N:
+        extra_bytes = f.read(N - len(bb))
+        if not extra_bytes:
+            break
+        bb += extra_bytes
+    return bb
+
+
+class SeekableFileObject:
+    """A readonly wrapper file object that add support for seeking, even if
+    the wrapped file object does not. The allows us to stream from http and
+    still use Pillow.
+    """
+
+    def __init__(self, f):
+        self.f = f
+        self._i = 0  # >=0 but can exceed buffer
+        self._buffer = b""
+        self._have_all = False
+        self.closed = False
+
+    def read(self, n=None):
+
+        # Fix up n
+        if n is None:
+            pass
+        else:
+            n = int(n)
+            if n < 0:
+                n = None
+
+        # Can and must we read more?
+        if not self._have_all:
+            more = b""
+            if n is None:
+                more = self.f.read()
+                self._have_all = True
+            else:
+                want_i = self._i + n
+                want_more = want_i - len(self._buffer)
+                if want_more > 0:
+                    more = self.f.read(want_more)
+                    if len(more) < want_more:
+                        self._have_all = True
+            self._buffer += more
+
+        # Read data from buffer and update pointer
+        if n is None:
+            res = self._buffer[self._i :]
+        else:
+            res = self._buffer[self._i : self._i + n]
+        self._i += len(res)
+
+        return res
+
+    def tell(self):
+        return self._i
+
+    def seek(self, i, mode=0):
+        # Mimic BytesIO behavior
+
+        # Get the absolute new position
+        i = int(i)
+        if mode == 0:
+            if i < 0:
+                raise ValueError("negative seek value " + str(i))
+            real_i = i
+        elif mode == 1:
+            real_i = max(0, self._i + i)  # negative ok here
+        elif mode == 2:
+            if not self._have_all:
+                self.read()
+            real_i = max(0, len(self._buffer) + i)
+        else:
+            raise ValueError("invalid whence (%s, should be 0, 1 or 2)" % i)
+
+        # Read some?
+        if real_i <= len(self._buffer):
+            pass  # no need to read
+        elif not self._have_all:
+            assert real_i > self._i  # if we don't have all, _i cannot be > _buffer
+            self.read(real_i - self._i)  # sets self._i
+
+        self._i = real_i
+        return self._i
+
+    def close(self):
+        self.closed = True
+        self.f.close()
+
+    def isatty(self):
+        return False
+
+    def seekable(self):
+        return True
+
+
+class InitializationError(Exception):
+    """The plugin could not initialize from the given request.
+
+    This is a _internal_ error that is raised by plugins that fail to handle
+    a given request. We use this to differentiate incompatibility between
+    a plugin and a request from an actual error/bug inside a plugin.
+
+    """
+
+    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/core/v3_plugin_api.py

@@ -0,0 +1,367 @@
+from . import Request
+from ..typing import ArrayLike
+import numpy as np
+from typing import Optional, Dict, Any, Tuple, Union, List, Iterator
+from dataclasses import dataclass
+
+
+@dataclass
+class ImageProperties:
+    """Standardized Metadata
+
+    ImageProperties represent a set of standardized metadata that is available
+    under the same name for every supported format. If the ImageResource (or
+    format) does not specify the value, a sensible default value is chosen
+    instead.
+
+    Attributes
+    ----------
+    shape : Tuple[int, ...]
+        The shape of the loaded ndimage.
+    dtype : np.dtype
+        The dtype of the loaded ndimage.
+    is_batch : bool
+        If True, the first dimension of the ndimage represents a batch dimension
+        along which several images are stacked.
+    spacing : Tuple
+        A tuple describing the spacing between pixels along each axis of the
+        ndimage. If the spacing is uniform along an axis the value corresponding
+        to that axis is a single float. If the spacing is non-uniform, the value
+        corresponding to that axis is a tuple in which the i-th element
+        indicates the spacing between the i-th and (i+1)-th pixel along that
+        axis.
+
+    """
+
+    shape: Tuple[int, ...]
+    dtype: np.dtype
+    is_batch: bool = False
+    spacing: Optional[tuple] = None
+
+
+class PluginV3:
+    """A ImageIO Plugin.
+
+    This is an abstract plugin that documents the v3 plugin API interface. A
+    plugin is an adapter/wrapper around a backend that converts a request from
+    iio.core (e.g., read an image from file) into a sequence of instructions for
+    the backend that fullfill the request.
+
+    Plugin authors may choose to subclass this class when implementing a new
+    plugin, but aren't obliged to do so. As long as the plugin class implements
+    the interface (methods) described below the ImageIO core will treat it just
+    like any other plugin.
+
+
+    Parameters
+    ----------
+    request : iio.Request
+        A request object that represents the users intent. It provides a
+        standard interface to access the various ImageResources and serves them
+        to the plugin as a file object (or file). Check the docs for details.
+    **kwargs : Any
+        Additional configuration arguments for the plugin or backend. Usually
+        these match the configuration arguments available on the backend and
+        are forwarded to it.
+
+
+    Raises
+    ------
+    InitializationError
+        During ``__init__`` the plugin tests if it can fulfill the request. If
+        it can't, e.g., because the request points to a file in the wrong
+        format, then it should raise an ``InitializationError`` and provide a
+        reason for failure. This reason may be reported to the user.
+    ImportError
+        Plugins will be imported dynamically when listed in
+        ``iio.config.known_plugins`` to fullfill requests. This way, users only
+        have to load plugins/backends they actually use. If this plugin's backend
+        is not installed, it should raise an ``ImportError`` either during
+        module import or during class construction.
+
+    Notes
+    -----
+    Upon successful construction the plugin takes ownership of the provided
+    request. This means that it is the plugin's responsibility to call
+    request.finish() to close the resource when it is no longer needed.
+
+    Plugins _must_ implement a context manager that closes and cleans any
+    resources held by the plugin upon exit.
+
+    """
+
+    def __init__(self, request: Request) -> None:
+        """Initialize a new Plugin Instance.
+
+        See Plugin's docstring for detailed documentation.
+
+        Notes
+        -----
+        The implementation here stores the request as a local variable that is
+        exposed using a @property below. If you inherit from PluginV3, remember
+        to call ``super().__init__(request)``.
+
+        """
+
+        self._request = request
+
+    def read(self, *, index: int = 0) -> np.ndarray:
+        """Read a ndimage.
+
+        The ``read`` method loads a (single) ndimage, located at ``index`` from
+        the requested ImageResource.
+
+        It is at the plugin's descretion to decide (and document) what
+        constitutes a single ndimage. A sensible way to make this decision is to
+        choose based on the ImageResource's format and on what users will expect
+        from such a format. For example, a sensible choice for a TIFF file
+        produced by an ImageJ hyperstack is to read it as a volumetric ndimage
+        (1 color dimension followed by 3 spatial dimensions). On the other hand,
+        a sensible choice for a MP4 file produced by Davinci Resolve is to treat
+        each frame as a ndimage (2 spatial dimensions followed by 1 color
+        dimension).
+
+        The value ``index=None`` is special. It requests the plugin to load all
+        ndimages in the file and stack them along a new first axis. For example,
+        if a MP4 file is read with ``index=None`` and the plugin identifies
+        single frames as ndimages, then the plugin should read all frames and
+        stack them into a new ndimage which now contains a time axis as its
+        first axis. If a PNG file (single image format) is read with
+        ``index=None`` the plugin does a very similar thing: It loads all
+        ndimages in the file (here it's just one) and stacks them along a new
+        first axis, effectively prepending an axis with size 1 to the image. If
+        a plugin does not wish to support ``index=None`` it should set a more
+        sensible default and raise a ``ValueError`` when requested to read using
+        ``index=None``.
+
+        Parameters
+        ----------
+        index : int
+            If the ImageResource contains multiple ndimages, and index is an
+            integer, select the index-th ndimage from among them and return it.
+            If index is an ellipsis (...), read all ndimages in the file and
+            stack them along a new batch dimension. If index is None, let the
+            plugin decide. If the index is out of bounds a ``ValueError`` is
+            raised.
+        **kwargs : Any
+            The read method may accept any number of plugin-specific keyword
+            arguments to further customize the read behavior. Usually these
+            match the arguments available on the backend and are forwarded to
+            it.
+
+        Returns
+        -------
+        ndimage : np.ndarray
+            A ndimage containing decoded pixel data (sometimes called bitmap).
+
+        Notes
+        -----
+        The ImageResource from which the plugin should read is managed by the
+        provided request object. Directly accessing the managed ImageResource is
+        _not_ permitted. Instead, you can get FileLike access to the
+        ImageResource via request.get_file().
+
+        If the backend doesn't support reading from FileLike objects, you can
+        request a temporary file to pass to the backend via
+        ``request.get_local_filename()``. This is, however, not very performant
+        (involves copying the Request's content into a temporary file), so you
+        should avoid doing this whenever possible. Consider it a fallback method
+        in case all else fails.
+
+        """
+        raise NotImplementedError()
+
+    def write(self, ndimage: Union[ArrayLike, List[ArrayLike]]) -> Optional[bytes]:
+        """Write a ndimage to a ImageResource.
+
+        The ``write`` method encodes the given ndimage into the format handled
+        by the backend and writes it to the ImageResource. It overwrites
+        any content that may have been previously stored in the file.
+
+        If the backend supports only a single format then it must check if
+        the ImageResource matches that format and raise an exception if not.
+        Typically, this should be done during initialization in the form of a
+        ``InitializationError``.
+
+        If the backend supports more than one format it must determine the
+        requested/desired format. Usually this can be done by inspecting the
+        ImageResource (e.g., by checking ``request.extension``), or by providing
+        a mechanism to explicitly set the format (perhaps with a - sensible -
+        default value). If the plugin can not determine the desired format, it
+        **must not** write to the ImageResource, but raise an exception instead.
+
+        If the backend supports at least one format that can hold multiple
+        ndimages it should be capable of handling ndimage batches and lists of
+        ndimages. If the ``ndimage`` input is a list of ndimages, the plugin
+        should not assume that the ndimages are not stackable, i.e., ndimages
+        may have different shapes. Otherwise, the ``ndimage`` may be a batch of
+        multiple ndimages stacked along the first axis of the array. The plugin
+        must be able to discover this, either automatically or via additional
+        `kwargs`. If there is ambiguity in the process, the plugin must clearly
+        document what happens in such cases and, if possible, describe how to
+        resolve this ambiguity.
+
+        Parameters
+        ----------
+        ndimage : ArrayLike
+            The ndimage to encode and write to the current ImageResource.
+        **kwargs : Any
+            The write method may accept any number of plugin-specific keyword
+            arguments to customize the writing behavior. Usually these match the
+            arguments available on the backend and are forwarded to it.
+
+        Returns
+        -------
+        encoded_image : bytes or None
+            If the chosen ImageResource is the special target ``"<bytes>"`` then
+            write should return a byte string containing the encoded image data.
+            Otherwise, it returns None.
+
+        Notes
+        -----
+        The ImageResource to which the plugin should write to is managed by the
+        provided request object. Directly accessing the managed ImageResource is
+        _not_ permitted. Instead, you can get FileLike access to the
+        ImageResource via request.get_file().
+
+        If the backend doesn't support writing to FileLike objects, you can
+        request a temporary file to pass to the backend via
+        ``request.get_local_filename()``. This is, however, not very performant
+        (involves copying the Request's content from a temporary file), so you
+        should avoid doing this whenever possible. Consider it a fallback method
+        in case all else fails.
+
+        """
+        raise NotImplementedError()
+
+    def iter(self) -> Iterator[np.ndarray]:
+        """Iterate the ImageResource.
+
+        This method returns a generator that yields ndimages in the order in which
+        they appear in the file. This is roughly equivalent to::
+
+            idx = 0
+            while True:
+                try:
+                    yield self.read(index=idx)
+                except ValueError:
+                    break
+
+        It works very similar to ``read``, and you can consult the documentation
+        of that method for additional information on desired behavior.
+
+        Parameters
+        ----------
+        **kwargs : Any
+            The iter method may accept any number of plugin-specific keyword
+            arguments to further customize the reading/iteration behavior.
+            Usually these match the arguments available on the backend and are
+            forwarded to it.
+
+        Yields
+        ------
+        ndimage : np.ndarray
+            A ndimage containing decoded pixel data (sometimes called bitmap).
+
+        See Also
+        --------
+        PluginV3.read
+
+        """
+        raise NotImplementedError()
+
+    def properties(self, index: int = 0) -> ImageProperties:
+        """Standardized ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            If the ImageResource contains multiple ndimages, and index is an
+        integer, select the index-th ndimage from among them and return its
+        properties. If index is an ellipsis (...), read all ndimages in the file
+        and stack them along a new batch dimension and return their properties.
+        If index is None, the plugin decides the default.
+
+        Returns
+        -------
+        properties : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        """
+        raise NotImplementedError()
+
+    def metadata(self, index: int = 0, exclude_applied: bool = True) -> Dict[str, Any]:
+        """Format-Specific ndimage metadata.
+
+        The method reads metadata stored in the ImageResource and returns it as
+        a python dict. The plugin is free to choose which name to give a piece
+        of metadata; however, if possible, it should match the name given by the
+        format. There is no requirement regarding the fields a plugin must
+        expose; however, if a plugin does expose any,``exclude_applied`` applies
+        to these fields.
+
+        If the plugin does return metadata items, it must check the value of
+        ``exclude_applied`` before returning them. If ``exclude applied`` is
+        True, then any metadata item that would be applied to an ndimage
+        returned by ``read`` (or ``iter``) must not be returned. This is done to
+        avoid confusion; for example, if an ImageResource defines the ExIF
+        rotation tag, and the plugin applies the rotation to the data before
+        returning it, then ``exclude_applied`` prevents confusion on whether the
+        tag was already applied or not.
+
+        The `kwarg` ``index`` behaves similar to its counterpart in ``read``
+        with one exception: If the ``index`` is None, then global metadata is
+        returned instead of returning a combination of all metadata items. If
+        there is no global metadata, the Plugin should return an empty dict or
+        raise an exception.
+
+        Parameters
+        ----------
+        index : int
+            If the ImageResource contains multiple ndimages, and index is an
+            integer, select the index-th ndimage from among them and return its
+            metadata. If index is an ellipsis (...), return global metadata. If
+            index is None, the plugin decides the default.
+        exclude_applied : bool
+            If True (default), do not report metadata fields that the plugin
+            would apply/consume while reading the image.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary filled with format-specific metadata fields and their
+            values.
+
+        """
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        """Close the ImageResource.
+
+        This method allows a plugin to behave similar to the python build-in ``open``::
+
+            image_file = my_plugin(Request, "r")
+            ...
+            image_file.close()
+
+        It is used by the context manager and deconstructor below to avoid leaking
+        ImageResources. If the plugin has no other cleanup to do it doesn't have
+        to overwrite this method itself and can rely on the implementation
+        below.
+
+        """
+
+        self.request.finish()
+
+    @property
+    def request(self) -> Request:
+        return self._request
+
+    def __enter__(self) -> "PluginV3":
+        return self
+
+    def __exit__(self, type, value, traceback) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        self.close()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/plugins/_dicom.py

@@ -0,0 +1,925 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Plugin for reading DICOM files.
+"""
+
+# todo: Use pydicom:
+# * Note: is not py3k ready yet
+# * Allow reading the full meta info
+# I think we can more or less replace the SimpleDicomReader with a
+# pydicom.Dataset For series, only ned to read the full info from one
+# file: speed still high
+# * Perhaps allow writing?
+
+import sys
+import os
+import struct
+import logging
+
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+# Determine endianity of system
+sys_is_little_endian = sys.byteorder == "little"
+
+# Define a dictionary that contains the tags that we would like to know
+MINIDICT = {
+    (0x7FE0, 0x0010): ("PixelData", "OB"),
+    # Date and time
+    (0x0008, 0x0020): ("StudyDate", "DA"),
+    (0x0008, 0x0021): ("SeriesDate", "DA"),
+    (0x0008, 0x0022): ("AcquisitionDate", "DA"),
+    (0x0008, 0x0023): ("ContentDate", "DA"),
+    (0x0008, 0x0030): ("StudyTime", "TM"),
+    (0x0008, 0x0031): ("SeriesTime", "TM"),
+    (0x0008, 0x0032): ("AcquisitionTime", "TM"),
+    (0x0008, 0x0033): ("ContentTime", "TM"),
+    # With what, where, by whom?
+    (0x0008, 0x0060): ("Modality", "CS"),
+    (0x0008, 0x0070): ("Manufacturer", "LO"),
+    (0x0008, 0x0080): ("InstitutionName", "LO"),
+    # Descriptions
+    (0x0008, 0x1030): ("StudyDescription", "LO"),
+    (0x0008, 0x103E): ("SeriesDescription", "LO"),
+    # UID's
+    (0x0008, 0x0016): ("SOPClassUID", "UI"),
+    (0x0008, 0x0018): ("SOPInstanceUID", "UI"),
+    (0x0020, 0x000D): ("StudyInstanceUID", "UI"),
+    (0x0020, 0x000E): ("SeriesInstanceUID", "UI"),
+    (0x0008, 0x0117): ("ContextUID", "UI"),
+    # Numbers
+    (0x0020, 0x0011): ("SeriesNumber", "IS"),
+    (0x0020, 0x0012): ("AcquisitionNumber", "IS"),
+    (0x0020, 0x0013): ("InstanceNumber", "IS"),
+    (0x0020, 0x0014): ("IsotopeNumber", "IS"),
+    (0x0020, 0x0015): ("PhaseNumber", "IS"),
+    (0x0020, 0x0016): ("IntervalNumber", "IS"),
+    (0x0020, 0x0017): ("TimeSlotNumber", "IS"),
+    (0x0020, 0x0018): ("AngleNumber", "IS"),
+    (0x0020, 0x0019): ("ItemNumber", "IS"),
+    (0x0020, 0x0020): ("PatientOrientation", "CS"),
+    (0x0020, 0x0030): ("ImagePosition", "CS"),
+    (0x0020, 0x0032): ("ImagePositionPatient", "CS"),
+    (0x0020, 0x0035): ("ImageOrientation", "CS"),
+    (0x0020, 0x0037): ("ImageOrientationPatient", "CS"),
+    # Patient information
+    (0x0010, 0x0010): ("PatientName", "PN"),
+    (0x0010, 0x0020): ("PatientID", "LO"),
+    (0x0010, 0x0030): ("PatientBirthDate", "DA"),
+    (0x0010, 0x0040): ("PatientSex", "CS"),
+    (0x0010, 0x1010): ("PatientAge", "AS"),
+    (0x0010, 0x1020): ("PatientSize", "DS"),
+    (0x0010, 0x1030): ("PatientWeight", "DS"),
+    # Image specific (required to construct numpy array)
+    (0x0028, 0x0002): ("SamplesPerPixel", "US"),
+    (0x0028, 0x0008): ("NumberOfFrames", "IS"),
+    (0x0028, 0x0100): ("BitsAllocated", "US"),
+    (0x0028, 0x0101): ("BitsStored", "US"),
+    (0x0028, 0x0102): ("HighBit", "US"),
+    (0x0028, 0x0103): ("PixelRepresentation", "US"),
+    (0x0028, 0x0010): ("Rows", "US"),
+    (0x0028, 0x0011): ("Columns", "US"),
+    (0x0028, 0x1052): ("RescaleIntercept", "DS"),
+    (0x0028, 0x1053): ("RescaleSlope", "DS"),
+    # Image specific (for the user)
+    (0x0028, 0x0030): ("PixelSpacing", "DS"),
+    (0x0018, 0x0088): ("SliceSpacing", "DS"),
+}
+
+# Define some special tags:
+# See PS 3.5-2008 section 7.5 (p.40)
+ItemTag = (0xFFFE, 0xE000)  # start of Sequence Item
+ItemDelimiterTag = (0xFFFE, 0xE00D)  # end of Sequence Item
+SequenceDelimiterTag = (0xFFFE, 0xE0DD)  # end of Sequence of undefined length
+
+# Define set of groups that we're interested in (so we can quickly skip others)
+GROUPS = set([key[0] for key in MINIDICT.keys()])
+VRS = set([val[1] for val in MINIDICT.values()])
+
+
+class NotADicomFile(Exception):
+    pass
+
+
+class CompressedDicom(RuntimeError):
+    pass
+
+
+class SimpleDicomReader(object):
+    """
+    This class provides reading of pixel data from DICOM files. It is
+    focussed on getting the pixel data, not the meta info.
+
+    To use, first create an instance of this class (giving it
+    a file object or filename). Next use the info attribute to
+    get a dict of the meta data. The loading of pixel data is
+    deferred until get_numpy_array() is called.
+
+    Comparison with Pydicom
+    -----------------------
+
+    This code focusses on getting the pixel data out, which allows some
+    shortcuts, resulting in the code being much smaller.
+
+    Since the processing of data elements is much cheaper (it skips a lot
+    of tags), this code is about 3x faster than pydicom (except for the
+    deflated DICOM files).
+
+    This class does borrow some code (and ideas) from the pydicom
+    project, and (to the best of our knowledge) has the same limitations
+    as pydicom with regard to the type of files that it can handle.
+
+    Limitations
+    -----------
+
+    For more advanced DICOM processing, please check out pydicom.
+
+      * Only a predefined subset of data elements (meta information) is read.
+      * This is a reader; it can not write DICOM files.
+      * (just like pydicom) it can handle none of the compressed DICOM
+        formats except for "Deflated Explicit VR Little Endian"
+        (1.2.840.10008.1.2.1.99).
+
+    """
+
+    def __init__(self, file):
+        # Open file if filename given
+        if isinstance(file, str):
+            self._filename = file
+            self._file = open(file, "rb")
+        else:
+            self._filename = "<unknown file>"
+            self._file = file
+        # Init variable to store position and size of pixel data
+        self._pixel_data_loc = None
+        # The meta header is always explicit and little endian
+        self.is_implicit_VR = False
+        self.is_little_endian = True
+        self._unpackPrefix = "<"
+        # Dict to store data elements of interest in
+        self._info = {}
+        # VR Conversion
+        self._converters = {
+            # Numbers
+            "US": lambda x: self._unpack("H", x),
+            "UL": lambda x: self._unpack("L", x),
+            # Numbers encoded as strings
+            "DS": lambda x: self._splitValues(x, float, "\\"),
+            "IS": lambda x: self._splitValues(x, int, "\\"),
+            # strings
+            "AS": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "DA": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "TM": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "UI": lambda x: x.decode("ascii", "ignore").strip("\x00"),
+            "LO": lambda x: x.decode("utf-8", "ignore").strip("\x00").rstrip(),
+            "CS": lambda x: self._splitValues(x, float, "\\"),
+            "PN": lambda x: x.decode("utf-8", "ignore").strip("\x00").rstrip(),
+        }
+
+        # Initiate reading
+        self._read()
+
+    @property
+    def info(self):
+        return self._info
+
+    def _splitValues(self, x, type, splitter):
+        s = x.decode("ascii").strip("\x00")
+        try:
+            if splitter in s:
+                return tuple([type(v) for v in s.split(splitter) if v.strip()])
+            else:
+                return type(s)
+        except ValueError:
+            return s
+
+    def _unpack(self, fmt, value):
+        return struct.unpack(self._unpackPrefix + fmt, value)[0]
+
+    # Really only so we need minimal changes to _pixel_data_numpy
+    def __iter__(self):
+        return iter(self._info.keys())
+
+    def __getattr__(self, key):
+        info = object.__getattribute__(self, "_info")
+        if key in info:
+            return info[key]
+        return object.__getattribute__(self, key)  # pragma: no cover
+
+    def _read(self):
+        f = self._file
+        # Check prefix after peamble
+        f.seek(128)
+        if f.read(4) != b"DICM":
+            raise NotADicomFile("Not a valid DICOM file.")
+        # Read
+        self._read_header()
+        self._read_data_elements()
+        self._get_shape_and_sampling()
+        # Close if done, reopen if necessary to read pixel data
+        if os.path.isfile(self._filename):
+            self._file.close()
+            self._file = None
+
+    def _readDataElement(self):
+        f = self._file
+        # Get group  and element
+        group = self._unpack("H", f.read(2))
+        element = self._unpack("H", f.read(2))
+        # Get value length
+        if self.is_implicit_VR:
+            vl = self._unpack("I", f.read(4))
+        else:
+            vr = f.read(2)
+            if vr in (b"OB", b"OW", b"SQ", b"UN"):
+                reserved = f.read(2)  # noqa
+                vl = self._unpack("I", f.read(4))
+            else:
+                vl = self._unpack("H", f.read(2))
+        # Get value
+        if group == 0x7FE0 and element == 0x0010:
+            here = f.tell()
+            self._pixel_data_loc = here, vl
+            f.seek(here + vl)
+            return group, element, b"Deferred loading of pixel data"
+        else:
+            if vl == 0xFFFFFFFF:
+                value = self._read_undefined_length_value()
+            else:
+                value = f.read(vl)
+            return group, element, value
+
+    def _read_undefined_length_value(self, read_size=128):
+        """Copied (in compacted form) from PyDicom
+        Copyright Darcy Mason.
+        """
+        fp = self._file
+        # data_start = fp.tell()
+        search_rewind = 3
+        bytes_to_find = struct.pack(
+            self._unpackPrefix + "HH", SequenceDelimiterTag[0], SequenceDelimiterTag[1]
+        )
+
+        found = False
+        value_chunks = []
+        while not found:
+            chunk_start = fp.tell()
+            bytes_read = fp.read(read_size)
+            if len(bytes_read) < read_size:
+                # try again,
+                # if still don't get required amount, this is last block
+                new_bytes = fp.read(read_size - len(bytes_read))
+                bytes_read += new_bytes
+                if len(bytes_read) < read_size:
+                    raise EOFError(
+                        "End of file reached before sequence " "delimiter found."
+                    )
+            index = bytes_read.find(bytes_to_find)
+            if index != -1:
+                found = True
+                value_chunks.append(bytes_read[:index])
+                fp.seek(chunk_start + index + 4)  # rewind to end of delimiter
+                length = fp.read(4)
+                if length != b"\0\0\0\0":
+                    logger.warning(
+                        "Expected 4 zero bytes after undefined length " "delimiter"
+                    )
+            else:
+                fp.seek(fp.tell() - search_rewind)  # rewind a bit
+                # accumulate the bytes read (not including the rewind)
+                value_chunks.append(bytes_read[:-search_rewind])
+
+        # if get here then have found the byte string
+        return b"".join(value_chunks)
+
+    def _read_header(self):
+        f = self._file
+        TransferSyntaxUID = None
+
+        # Read all elements, store transferSyntax when we encounter it
+        try:
+            while True:
+                fp_save = f.tell()
+                # Get element
+                group, element, value = self._readDataElement()
+                if group == 0x02:
+                    if group == 0x02 and element == 0x10:
+                        TransferSyntaxUID = value.decode("ascii").strip("\x00")
+                else:
+                    # No more group 2: rewind and break
+                    # (don't trust group length)
+                    f.seek(fp_save)
+                    break
+        except (EOFError, struct.error):  # pragma: no cover
+            raise RuntimeError("End of file reached while still in header.")
+
+        # Handle transfer syntax
+        self._info["TransferSyntaxUID"] = TransferSyntaxUID
+        #
+        if TransferSyntaxUID is None:
+            # Assume ExplicitVRLittleEndian
+            is_implicit_VR, is_little_endian = False, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.1":
+            # ExplicitVRLittleEndian
+            is_implicit_VR, is_little_endian = False, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.2":
+            # ExplicitVRBigEndian
+            is_implicit_VR, is_little_endian = False, False
+        elif TransferSyntaxUID == "1.2.840.10008.1.2":
+            # implicit VR little endian
+            is_implicit_VR, is_little_endian = True, True
+        elif TransferSyntaxUID == "1.2.840.10008.1.2.1.99":
+            # DeflatedExplicitVRLittleEndian:
+            is_implicit_VR, is_little_endian = False, True
+            self._inflate()
+        else:
+            # http://www.dicomlibrary.com/dicom/transfer-syntax/
+            t, extra_info = TransferSyntaxUID, ""
+            if "1.2.840.10008.1.2.4.50" <= t < "1.2.840.10008.1.2.4.99":
+                extra_info = " (JPEG)"
+            if "1.2.840.10008.1.2.4.90" <= t < "1.2.840.10008.1.2.4.99":
+                extra_info = " (JPEG 2000)"
+            if t == "1.2.840.10008.1.2.5":
+                extra_info = " (RLE)"
+            if t == "1.2.840.10008.1.2.6.1":
+                extra_info = " (RFC 2557)"
+            raise CompressedDicom(
+                "The dicom reader can only read files with "
+                "uncompressed image data - not %r%s. You "
+                "can try using dcmtk or gdcm to convert the "
+                "image." % (t, extra_info)
+            )
+
+        # From hereon, use implicit/explicit big/little endian
+        self.is_implicit_VR = is_implicit_VR
+        self.is_little_endian = is_little_endian
+        self._unpackPrefix = "><"[is_little_endian]
+
+    def _read_data_elements(self):
+        info = self._info
+        try:
+            while True:
+                # Get element
+                group, element, value = self._readDataElement()
+                # Is it a group we are interested in?
+                if group in GROUPS:
+                    key = (group, element)
+                    name, vr = MINIDICT.get(key, (None, None))
+                    # Is it an element we are interested in?
+                    if name:
+                        # Store value
+                        converter = self._converters.get(vr, lambda x: x)
+                        info[name] = converter(value)
+        except (EOFError, struct.error):
+            pass  # end of file ...
+
+    def get_numpy_array(self):
+        """Get numpy arra for this DICOM file, with the correct shape,
+        and pixel values scaled appropriately.
+        """
+        # Is there pixel data at all?
+        if "PixelData" not in self:
+            raise TypeError("No pixel data found in this dataset.")
+
+        # Load it now if it was not already loaded
+        if self._pixel_data_loc and len(self.PixelData) < 100:
+            # Reopen file?
+            close_file = False
+            if self._file is None:
+                close_file = True
+                self._file = open(self._filename, "rb")
+            # Read data
+            self._file.seek(self._pixel_data_loc[0])
+            if self._pixel_data_loc[1] == 0xFFFFFFFF:
+                value = self._read_undefined_length_value()
+            else:
+                value = self._file.read(self._pixel_data_loc[1])
+            # Close file
+            if close_file:
+                self._file.close()
+                self._file = None
+            # Overwrite
+            self._info["PixelData"] = value
+
+        # Get data
+        data = self._pixel_data_numpy()
+        data = self._apply_slope_and_offset(data)
+
+        # Remove data again to preserve memory
+        # Note that the data for the original file is loaded twice ...
+        self._info["PixelData"] = (
+            b"Data converted to numpy array, " + b"raw data removed to preserve memory"
+        )
+        return data
+
+    def _get_shape_and_sampling(self):
+        """Get shape and sampling without actuall using the pixel data.
+        In this way, the user can get an idea what's inside without having
+        to load it.
+        """
+        # Get shape (in the same way that pydicom does)
+        if "NumberOfFrames" in self and self.NumberOfFrames > 1:
+            if self.SamplesPerPixel > 1:
+                shape = (
+                    self.SamplesPerPixel,
+                    self.NumberOfFrames,
+                    self.Rows,
+                    self.Columns,
+                )
+            else:
+                shape = self.NumberOfFrames, self.Rows, self.Columns
+        elif "SamplesPerPixel" in self:
+            if self.SamplesPerPixel > 1:
+                if self.BitsAllocated == 8:
+                    shape = self.SamplesPerPixel, self.Rows, self.Columns
+                else:
+                    raise NotImplementedError(
+                        "DICOM plugin only handles "
+                        "SamplesPerPixel > 1 if Bits "
+                        "Allocated = 8"
+                    )
+            else:
+                shape = self.Rows, self.Columns
+        else:
+            raise RuntimeError(
+                "DICOM file has no SamplesPerPixel " "(perhaps this is a report?)"
+            )
+
+        # Try getting sampling between pixels
+        if "PixelSpacing" in self:
+            sampling = float(self.PixelSpacing[0]), float(self.PixelSpacing[1])
+        else:
+            sampling = 1.0, 1.0
+        if "SliceSpacing" in self:
+            sampling = (abs(self.SliceSpacing),) + sampling
+
+        # Ensure that sampling has as many elements as shape
+        sampling = (1.0,) * (len(shape) - len(sampling)) + sampling[-len(shape) :]
+
+        # Set shape and sampling
+        self._info["shape"] = shape
+        self._info["sampling"] = sampling
+
+    def _pixel_data_numpy(self):
+        """Return a NumPy array of the pixel data."""
+        # Taken from pydicom
+        # Copyright (c) 2008-2012 Darcy Mason
+
+        if "PixelData" not in self:
+            raise TypeError("No pixel data found in this dataset.")
+
+        # determine the type used for the array
+        need_byteswap = self.is_little_endian != sys_is_little_endian
+
+        # Make NumPy format code, e.g. "uint16", "int32" etc
+        # from two pieces of info:
+        #    self.PixelRepresentation -- 0 for unsigned, 1 for signed;
+        #    self.BitsAllocated -- 8, 16, or 32
+        format_str = "%sint%d" % (
+            ("u", "")[self.PixelRepresentation],
+            self.BitsAllocated,
+        )
+        try:
+            numpy_format = np.dtype(format_str)
+        except TypeError:  # pragma: no cover
+            raise TypeError(
+                "Data type not understood by NumPy: format='%s', "
+                " PixelRepresentation=%d, BitsAllocated=%d"
+                % (numpy_format, self.PixelRepresentation, self.BitsAllocated)
+            )
+
+        # Have correct Numpy format, so create the NumPy array
+        arr = np.frombuffer(self.PixelData, numpy_format).copy()
+
+        # XXX byte swap - may later handle this in read_file!!?
+        if need_byteswap:
+            arr.byteswap(True)  # True means swap in-place, don't make new copy
+
+        # Note the following reshape operations return a new *view* onto arr,
+        # but don't copy the data
+        arr = arr.reshape(*self._info["shape"])
+        return arr
+
+    def _apply_slope_and_offset(self, data):
+        """
+        If RescaleSlope and RescaleIntercept are present in the data,
+        apply them. The data type of the data is changed if necessary.
+        """
+        # Obtain slope and offset
+        slope, offset = 1, 0
+        needFloats, needApplySlopeOffset = False, False
+        if "RescaleSlope" in self:
+            needApplySlopeOffset = True
+            slope = self.RescaleSlope
+        if "RescaleIntercept" in self:
+            needApplySlopeOffset = True
+            offset = self.RescaleIntercept
+        if int(slope) != slope or int(offset) != offset:
+            needFloats = True
+        if not needFloats:
+            slope, offset = int(slope), int(offset)
+
+        # Apply slope and offset
+        if needApplySlopeOffset:
+            # Maybe we need to change the datatype?
+            if data.dtype in [np.float32, np.float64]:
+                pass
+            elif needFloats:
+                data = data.astype(np.float32)
+            else:
+                # Determine required range
+                minReq, maxReq = data.min(), data.max()
+                minReq = min([minReq, minReq * slope + offset, maxReq * slope + offset])
+                maxReq = max([maxReq, minReq * slope + offset, maxReq * slope + offset])
+
+                # Determine required datatype from that
+                dtype = None
+                if minReq < 0:
+                    # Signed integer type
+                    maxReq = max([-minReq, maxReq])
+                    if maxReq < 2**7:
+                        dtype = np.int8
+                    elif maxReq < 2**15:
+                        dtype = np.int16
+                    elif maxReq < 2**31:
+                        dtype = np.int32
+                    else:
+                        dtype = np.float32
+                else:
+                    # Unsigned integer type
+                    if maxReq < 2**8:
+                        dtype = np.int8
+                    elif maxReq < 2**16:
+                        dtype = np.int16
+                    elif maxReq < 2**32:
+                        dtype = np.int32
+                    else:
+                        dtype = np.float32
+                # Change datatype
+                if dtype != data.dtype:
+                    data = data.astype(dtype)
+
+            # Apply slope and offset
+            data *= slope
+            data += offset
+
+        # Done
+        return data
+
+    def _inflate(self):
+        # Taken from pydicom
+        # Copyright (c) 2008-2012 Darcy Mason
+        import zlib
+        from io import BytesIO
+
+        # See PS3.6-2008 A.5 (p 71) -- when written, the entire dataset
+        #   following the file metadata was prepared the normal way,
+        #   then "deflate" compression applied.
+        #  All that is needed here is to decompress and then
+        #      use as normal in a file-like object
+        zipped = self._file.read()
+        # -MAX_WBITS part is from comp.lang.python answer:
+        # groups.google.com/group/comp.lang.python/msg/e95b3b38a71e6799
+        unzipped = zlib.decompress(zipped, -zlib.MAX_WBITS)
+        self._file = BytesIO(unzipped)  # a file-like object
+
+
+class DicomSeries(object):
+    """DicomSeries
+    This class represents a serie of dicom files (SimpleDicomReader
+    objects) that belong together. If these are multiple files, they
+    represent the slices of a volume (like for CT or MRI).
+    """
+
+    def __init__(self, suid, progressIndicator):
+        # Init dataset list and the callback
+        self._entries = []
+
+        # Init props
+        self._suid = suid
+        self._info = {}
+        self._progressIndicator = progressIndicator
+
+    def __len__(self):
+        return len(self._entries)
+
+    def __iter__(self):
+        return iter(self._entries)
+
+    def __getitem__(self, index):
+        return self._entries[index]
+
+    @property
+    def suid(self):
+        return self._suid
+
+    @property
+    def shape(self):
+        """The shape of the data (nz, ny, nx)."""
+        return self._info["shape"]
+
+    @property
+    def sampling(self):
+        """The sampling (voxel distances) of the data (dz, dy, dx)."""
+        return self._info["sampling"]
+
+    @property
+    def info(self):
+        """A dictionary containing the information as present in the
+        first dicomfile of this serie. None if there are no entries."""
+        return self._info
+
+    @property
+    def description(self):
+        """A description of the dicom series. Used fields are
+        PatientName, shape of the data, SeriesDescription, and
+        ImageComments.
+        """
+        info = self.info
+
+        # If no info available, return simple description
+        if not info:  # pragma: no cover
+            return "DicomSeries containing %i images" % len(self)
+
+        fields = []
+        # Give patient name
+        if "PatientName" in info:
+            fields.append("" + info["PatientName"])
+        # Also add dimensions
+        if self.shape:
+            tmp = [str(d) for d in self.shape]
+            fields.append("x".join(tmp))
+        # Try adding more fields
+        if "SeriesDescription" in info:
+            fields.append("'" + info["SeriesDescription"] + "'")
+        if "ImageComments" in info:
+            fields.append("'" + info["ImageComments"] + "'")
+
+        # Combine
+        return " ".join(fields)
+
+    def __repr__(self):
+        adr = hex(id(self)).upper()
+        return "<DicomSeries with %i images at %s>" % (len(self), adr)
+
+    def get_numpy_array(self):
+        """Get (load) the data that this DicomSeries represents, and return
+        it as a numpy array. If this serie contains multiple images, the
+        resulting array is 3D, otherwise it's 2D.
+        """
+
+        # It's easy if no file or if just a single file
+        if len(self) == 0:
+            raise ValueError("Serie does not contain any files.")
+        elif len(self) == 1:
+            return self[0].get_numpy_array()
+
+        # Check info
+        if self.info is None:
+            raise RuntimeError("Cannot return volume if series not finished.")
+
+        # Init data (using what the dicom packaged produces as a reference)
+        slice = self[0].get_numpy_array()
+        vol = np.zeros(self.shape, dtype=slice.dtype)
+        vol[0] = slice
+
+        # Fill volume
+        self._progressIndicator.start("loading data", "", len(self))
+        for z in range(1, len(self)):
+            vol[z] = self[z].get_numpy_array()
+            self._progressIndicator.set_progress(z + 1)
+        self._progressIndicator.finish()
+
+        # Done
+        import gc
+
+        gc.collect()
+        return vol
+
+    def _append(self, dcm):
+        self._entries.append(dcm)
+
+    def _sort(self):
+        self._entries.sort(key=lambda k: k.InstanceNumber)
+
+    def _finish(self):
+        """
+        Evaluate the series of dicom files. Together they should make up
+        a volumetric dataset. This means the files should meet certain
+        conditions. Also some additional information has to be calculated,
+        such as the distance between the slices. This method sets the
+        attributes for "shape", "sampling" and "info".
+
+        This method checks:
+          * that there are no missing files
+          * that the dimensions of all images match
+          * that the pixel spacing of all images match
+        """
+
+        # The datasets list should be sorted by instance number
+        L = self._entries
+        if len(L) == 0:
+            return
+        elif len(L) == 1:
+            self._info = L[0].info
+            return
+
+        # Get previous
+        ds1 = L[0]
+        # Init measures to calculate average of
+        distance_sum = 0.0
+        # Init measures to check (these are in 2D)
+        dimensions = ds1.Rows, ds1.Columns
+        # sampling = float(ds1.PixelSpacing[0]), float(ds1.PixelSpacing[1])
+        sampling = ds1.info["sampling"][:2]  # row, column
+
+        for index in range(len(L)):
+            # The first round ds1 and ds2 will be the same, for the
+            # distance calculation this does not matter
+            # Get current
+            ds2 = L[index]
+            # Get positions
+            pos1 = float(ds1.ImagePositionPatient[2])
+            pos2 = float(ds2.ImagePositionPatient[2])
+            # Update distance_sum to calculate distance later
+            distance_sum += abs(pos1 - pos2)
+            # Test measures
+            dimensions2 = ds2.Rows, ds2.Columns
+            # sampling2 = float(ds2.PixelSpacing[0]), float(ds2.PixelSpacing[1])
+            sampling2 = ds2.info["sampling"][:2]  # row, column
+            if dimensions != dimensions2:
+                # We cannot produce a volume if the dimensions match
+                raise ValueError("Dimensions of slices does not match.")
+            if sampling != sampling2:
+                # We can still produce a volume, but we should notify the user
+                self._progressIndicator.write("Warn: sampling does not match.")
+            # Store previous
+            ds1 = ds2
+
+        # Finish calculating average distance
+        # (Note that there are len(L)-1 distances)
+        distance_mean = distance_sum / (len(L) - 1)
+
+        # Set info dict
+        self._info = L[0].info.copy()
+
+        # Store information that is specific for the serie
+        self._info["shape"] = (len(L),) + ds2.info["shape"]
+        self._info["sampling"] = (distance_mean,) + ds2.info["sampling"]
+
+
+def list_files(files, path):
+    """List all files in the directory, recursively."""
+    for item in os.listdir(path):
+        item = os.path.join(path, item)
+        if os.path.isdir(item):
+            list_files(files, item)
+        elif os.path.isfile(item):
+            files.append(item)
+
+
+def process_directory(request, progressIndicator, readPixelData=False):
+    """
+    Reads dicom files and returns a list of DicomSeries objects, which
+    contain information about the data, and can be used to load the
+    image or volume data.
+
+    if readPixelData is True, the pixel data of all series is read. By
+    default the loading of pixeldata is deferred until it is requested
+    using the DicomSeries.get_pixel_array() method. In general, both
+    methods should be equally fast.
+    """
+    # Get directory to examine
+    if os.path.isdir(request.filename):
+        path = request.filename
+    elif os.path.isfile(request.filename):
+        path = os.path.dirname(request.filename)
+    else:  # pragma: no cover - tested earlier
+        raise ValueError(
+            "Dicom plugin needs a valid filename to examine " "the directory"
+        )
+
+    # Check files
+    files = []
+    list_files(files, path)  # Find files recursively
+
+    # Gather file data and put in DicomSeries
+    series = {}
+    count = 0
+    progressIndicator.start("examining files", "files", len(files))
+    for filename in files:
+        # Show progress (note that we always start with a 0.0)
+        count += 1
+        progressIndicator.set_progress(count)
+        # Skip DICOMDIR files
+        if filename.count("DICOMDIR"):  # pragma: no cover
+            continue
+        # Try loading dicom ...
+        try:
+            dcm = SimpleDicomReader(filename)
+        except NotADicomFile:
+            continue  # skip non-dicom file
+        except Exception as why:  # pragma: no cover
+            progressIndicator.write(str(why))
+            continue
+        # Get SUID and register the file with an existing or new series object
+        try:
+            suid = dcm.SeriesInstanceUID
+        except AttributeError:  # pragma: no cover
+            continue  # some other kind of dicom file
+        if suid not in series:
+            series[suid] = DicomSeries(suid, progressIndicator)
+        series[suid]._append(dcm)
+
+    # Finish progress
+    # progressIndicator.finish('Found %i series.' % len(series))
+
+    # Make a list and sort, so that the order is deterministic
+    series = list(series.values())
+    series.sort(key=lambda x: x.suid)
+
+    # Split series if necessary
+    for serie in reversed([serie for serie in series]):
+        splitSerieIfRequired(serie, series, progressIndicator)
+
+    # Finish all series
+    # progressIndicator.start('analyse series', '', len(series))
+    series_ = []
+    for i in range(len(series)):
+        try:
+            series[i]._finish()
+            series_.append(series[i])
+        except Exception as err:  # pragma: no cover
+            progressIndicator.write(str(err))
+            pass  # Skip serie (probably report-like file without pixels)
+        # progressIndicator.set_progress(i+1)
+    progressIndicator.finish("Found %i correct series." % len(series_))
+
+    # Done
+    return series_
+
+
+def splitSerieIfRequired(serie, series, progressIndicator):
+    """
+    Split the serie in multiple series if this is required. The choice
+    is based on examing the image position relative to the previous
+    image. If it differs too much, it is assumed that there is a new
+    dataset. This can happen for example in unspitted gated CT data.
+    """
+
+    # Sort the original list and get local name
+    serie._sort()
+    L = serie._entries
+    # Init previous slice
+    ds1 = L[0]
+    # Check whether we can do this
+    if "ImagePositionPatient" not in ds1:
+        return
+    # Initialize a list of new lists
+    L2 = [[ds1]]
+    # Init slice distance estimate
+    distance = 0
+
+    for index in range(1, len(L)):
+        # Get current slice
+        ds2 = L[index]
+        # Get positions
+        pos1 = float(ds1.ImagePositionPatient[2])
+        pos2 = float(ds2.ImagePositionPatient[2])
+        # Get distances
+        newDist = abs(pos1 - pos2)
+        # deltaDist = abs(firstPos-pos2)
+        # If the distance deviates more than 2x from what we've seen,
+        # we can agree it's a new dataset.
+        if distance and newDist > 2.1 * distance:
+            L2.append([])
+            distance = 0
+        else:
+            # Test missing file
+            if distance and newDist > 1.5 * distance:
+                progressIndicator.write(
+                    "Warning: missing file after %r" % ds1._filename
+                )
+            distance = newDist
+        # Add to last list
+        L2[-1].append(ds2)
+        # Store previous
+        ds1 = ds2
+
+    # Split if we should
+    if len(L2) > 1:
+        # At what position are we now?
+        i = series.index(serie)
+        # Create new series
+        series2insert = []
+        for L in L2:
+            newSerie = DicomSeries(serie.suid, progressIndicator)
+            newSerie._entries = L
+            series2insert.append(newSerie)
+        # Insert series and remove self
+        for newSerie in reversed(series2insert):
+            series.insert(i, newSerie)
+        series.remove(serie)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/plugins/example.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Example plugin. You can use this as a template for your own plugin.
+"""
+
+import numpy as np
+
+from .. import formats
+from ..core import Format
+
+
+class DummyFormat(Format):
+    """The dummy format is an example format that does nothing.
+    It will never indicate that it can read or write a file. When
+    explicitly asked to read, it will simply read the bytes. When
+    explicitly asked to write, it will raise an error.
+
+    This documentation is shown when the user does ``help('thisformat')``.
+
+    Parameters for reading
+    ----------------------
+    Specify arguments in numpy doc style here.
+
+    Parameters for saving
+    ---------------------
+    Specify arguments in numpy doc style here.
+
+    """
+
+    def _can_read(self, request):
+        # This method is called when the format manager is searching
+        # for a format to read a certain image. Return True if this format
+        # can do it.
+        #
+        # The format manager is aware of the extensions and the modes
+        # that each format can handle. It will first ask all formats
+        # that *seem* to be able to read it whether they can. If none
+        # can, it will ask the remaining formats if they can: the
+        # extension might be missing, and this allows formats to provide
+        # functionality for certain extensions, while giving preference
+        # to other plugins.
+        #
+        # If a format says it can, it should live up to it. The format
+        # would ideally check the request.firstbytes and look for a
+        # header of some kind.
+        #
+        # The request object has:
+        # request.filename: a representation of the source (only for reporting)
+        # request.firstbytes: the first 256 bytes of the file.
+        # request.mode[0]: read or write mode
+        # request.mode[1]: what kind of data the user expects: one of 'iIvV?'
+
+        if request.mode[1] in (self.modes + "?"):
+            if request.extension in self.extensions:
+                return True
+
+    def _can_write(self, request):
+        # This method is called when the format manager is searching
+        # for a format to write a certain image. It will first ask all
+        # formats that *seem* to be able to write it whether they can.
+        # If none can, it will ask the remaining formats if they can.
+        #
+        # Return True if the format can do it.
+
+        # In most cases, this code does suffice:
+        if request.mode[1] in (self.modes + "?"):
+            if request.extension in self.extensions:
+                return True
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, some_option=False, length=1):
+            # Specify kwargs here. Optionally, the user-specified kwargs
+            # can also be accessed via the request.kwargs object.
+            #
+            # The request object provides two ways to get access to the
+            # data. Use just one:
+            #  - Use request.get_file() for a file object (preferred)
+            #  - Use request.get_local_filename() for a file on the system
+            self._fp = self.request.get_file()
+            self._length = length  # passed as an arg in this case for testing
+            self._data = None
+
+        def _close(self):
+            # Close the reader.
+            # Note that the request object will close self._fp
+            pass
+
+        def _get_length(self):
+            # Return the number of images. Can be np.inf
+            return self._length
+
+        def _get_data(self, index):
+            # Return the data and meta data for the given index
+            if index >= self._length:
+                raise IndexError("Image index %i > %i" % (index, self._length))
+            # Read all bytes
+            if self._data is None:
+                self._data = self._fp.read()
+            # Put in a numpy array
+            im = np.frombuffer(self._data, "uint8")
+            im.shape = len(im), 1
+            # Return array and dummy meta data
+            return im, {}
+
+        def _get_meta_data(self, index):
+            # Get the meta data for the given index. If index is None, it
+            # should return the global meta data.
+            return {}  # This format does not support meta data
+
+    # -- writer
+
+    class Writer(Format.Writer):
+        def _open(self, flags=0):
+            # Specify kwargs here. Optionally, the user-specified kwargs
+            # can also be accessed via the request.kwargs object.
+            #
+            # The request object provides two ways to write the data.
+            # Use just one:
+            #  - Use request.get_file() for a file object (preferred)
+            #  - Use request.get_local_filename() for a file on the system
+            self._fp = self.request.get_file()
+
+        def _close(self):
+            # Close the reader.
+            # Note that the request object will close self._fp
+            pass
+
+        def _append_data(self, im, meta):
+            # Process the given data and meta data.
+            raise RuntimeError("The dummy format cannot write image data.")
+
+        def set_meta_data(self, meta):
+            # Process the given meta data (global for all images)
+            # It is not mandatory to support this.
+            raise RuntimeError("The dummy format cannot write meta data.")
+
+
+# Register. You register an *instance* of a Format class. Here specify:
+format = DummyFormat(
+    "dummy",  # short name
+    "An example format that does nothing.",  # one line descr.
+    ".foobar .nonexistentext",  # list of extensions
+    "iI",  # modes, characters in iIvV
+)
+formats.add_format(format)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/plugins/gdal.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read GDAL files.
+
+Backend: `GDAL <https://gdal.org/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[gdal]
+
+Parameters
+----------
+none
+"""
+
+from ..core import Format, has_module
+
+_gdal = None  # lazily loaded in load_lib()
+
+
+def load_lib():
+    global _gdal
+    try:
+        import osgeo.gdal as _gdal
+    except ImportError:
+        raise ImportError(
+            "The GDAL format relies on the GDAL package."
+            "Please refer to http://www.gdal.org/"
+            "for further instructions."
+        )
+    return _gdal
+
+
+GDAL_FORMATS = (".tiff", " .tif", ".img", ".ecw", ".jpg", ".jpeg")
+
+
+class GdalFormat(Format):
+    """See :mod:`imageio.plugins.gdal`"""
+
+    def _can_read(self, request):
+        if request.extension in (".ecw",):
+            return True
+        if has_module("osgeo.gdal"):
+            return request.extension in self.extensions
+
+    def _can_write(self, request):
+        return False
+
+    # --
+
+    class Reader(Format.Reader):
+        def _open(self):
+            if not _gdal:
+                load_lib()
+            self._ds = _gdal.Open(self.request.get_local_filename())
+
+        def _close(self):
+            del self._ds
+
+        def _get_length(self):
+            return 1
+
+        def _get_data(self, index):
+            if index != 0:
+                raise IndexError("Gdal file contains only one dataset")
+            return self._ds.ReadAsArray(), self._get_meta_data(index)
+
+        def _get_meta_data(self, index):
+            return self._ds.GetMetadata()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio/plugins/npz.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read/Write NPZ files.
+
+Backend: `Numpy <https://numpy.org/doc/stable/reference/generated/numpy.savez.html>`_
+
+NPZ is a file format by numpy that provides storage of array data using gzip
+compression. This imageio plugin supports data of any shape, and also supports
+multiple images per file. However, the npz format does not provide streaming;
+all data is read/written at once. Further, there is no support for meta data.
+
+See the BSDF format for a similar (but more fully featured) format.
+
+Parameters
+----------
+None
+
+Notes
+-----
+This format is not available on Pypy.
+
+"""
+
+import numpy as np
+
+from ..core import Format
+
+
+class NpzFormat(Format):
+    """See :mod:`imageio.plugins.npz`"""
+
+    def _can_read(self, request):
+        # We support any kind of image data
+        return request.extension in self.extensions
+
+    def _can_write(self, request):
+        # We support any kind of image data
+        return request.extension in self.extensions
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self):
+            # Load npz file, which provides another file like object
+            self._npz = np.load(self.request.get_file())
+            assert isinstance(self._npz, np.lib.npyio.NpzFile)
+            # Get list of names, ordered by name, but smarter
+            self._names = sorted(self._npz.files, key=lambda x: x.split("_")[-1])
+
+        def _close(self):
+            self._npz.close()
+
+        def _get_length(self):
+            return len(self._names)
+
+        def _get_data(self, index):
+            # Get data
+            if index < 0 or index >= len(self._names):
+                raise IndexError("Index out of range while reading from nzp")
+            im = self._npz[self._names[index]]
+            # Return array and empty meta data
+            return im, {}
+
+        def _get_meta_data(self, index):
+            # Get the meta data for the given index
+            raise RuntimeError("The npz format does not support meta data.")
+
+    # -- writer
+
+    class Writer(Format.Writer):
+        def _open(self):
+            # Npz is not such a great format. We cannot stream to the file.
+            # So we remember all images and write them to file at the end.
+            self._images = []
+
+        def _close(self):
+            # Write everything
+            np.savez_compressed(self.request.get_file(), *self._images)
+
+        def _append_data(self, im, meta):
+            self._images.append(im)  # discart meta data
+
+        def set_meta_data(self, meta):
+            raise RuntimeError("The npz format does not support meta data.")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/__pycache__/patches.cpython-38.pyc

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Bold.ttf

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBolIta.ttf

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralItalic.ttf

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