Add files using upload-large-folder tool

.gitattributes

@@ -1255,3 +1255,4 @@ evalkit_tf449/lib/python3.10/lib-dynload/_csv.cpython-310-x86_64-linux-gnu.so fi
 evalkit_tf449/lib/python3.10/lib-dynload/pyexpat.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 evalkit_tf449/lib/python3.10/lib-dynload/_codecs_jp.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/triton/backends/nvidia/bin/ptxas filter=lfs diff=lfs merge=lfs -text
+falcon/bin/x86_64-conda-linux-gnu-ld filter=lfs diff=lfs merge=lfs -text

evalkit_tf437/lib/python3.10/site-packages/imageio/config/plugins.py

@@ -0,0 +1,782 @@
+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"
+)
+known_plugins["tifffile"] = PluginConfig(
+    name="tifffile",
+    class_name="TifffilePlugin",
+    module_name="imageio.plugins.tifffile_v3",
+)
+known_plugins["SPE"] = PluginConfig(
+    name="spe", class_name="SpePlugin", module_name="imageio.plugins.spe"
+)
+known_plugins["rawpy"] = PluginConfig(
+    name="rawpy", class_name="RawPyPlugin", module_name="imageio.plugins.rawpy"
+)
+
+# 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 .h264",
+        "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["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]

evalkit_tf437/lib/python3.10/site-packages/imageio/config/plugins.pyi

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Optional
+from ..core.v3_plugin_api import PluginV3
+
+class PluginConfig:
+    name: str
+    class_name: str
+    module_name: str
+    is_legacy: bool
+    package_name: Optional[str] = None
+    install_name: Optional[str] = None
+    legacy_args: Optional[dict] = None
+    @property
+    def format(self) -> Any: ...
+    @property
+    def plugin_class(self) -> PluginV3: ...
+    def __init__(
+        self,
+        name: str,
+        class_name: str,
+        module_name: str,
+        *,
+        is_legacy: bool = False,
+        package_name: str = None,
+        install_name: str = None,
+        legacy_args: dict = None,
+    ) -> None: ...
+
+known_plugins: Dict[str, PluginConfig]

evalkit_tf437/lib/python3.10/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

evalkit_tf437/lib/python3.10/site-packages/imageio/core/imopen.py

@@ -0,0 +1,281 @@
+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
+
+    plugin : str, Plugin, or None
+        The plugin to use. If set to None 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
+        Deprecated. Use `extension` instead.
+    legacy_mode : bool
+        If true 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)
+
+        else:
+
+            def loader(request, **kwargs):
+                return plugin(request, **kwargs)
+
+        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 occurred 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]
+
+                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]
+
+                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():
+        # 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)

evalkit_tf437/lib/python3.10/site-packages/imageio/core/legacy_plugin_wrapper.pyi

@@ -0,0 +1,27 @@
+import numpy as np
+from typing import Optional, Dict, Any, Union, List, Iterator
+
+from .request import Request
+from .v3_plugin_api import PluginV3, ImageProperties
+from .format import Format
+from ..typing import ArrayLike
+
+class LegacyPlugin(PluginV3):
+    def __init__(self, request: Request, legacy_plugin: Format) -> None: ...
+    def legacy_get_reader(self, **kwargs) -> Format.Reader: ...
+    def read(self, *, index: Optional[int] = 0, **kwargs) -> np.ndarray: ...
+    def legacy_get_writer(self, **kwargs) -> Format.Writer: ...
+    def write(
+        self,
+        ndimage: Union[ArrayLike, List[ArrayLike]],
+        *,
+        is_batch: bool = None,
+        **kwargs
+    ) -> Optional[bytes]: ...
+    def iter(self, **kwargs) -> Iterator[np.ndarray]: ...
+    def properties(self, index: Optional[int] = 0) -> ImageProperties: ...
+    def get_meta(self, *, index: Optional[int] = 0) -> Dict[str, Any]: ...
+    def metadata(
+        self, index: Optional[int] = 0, exclude_applied: bool = True
+    ) -> Dict[str, Any]: ...
+    def __del__(self) -> None: ...

evalkit_tf437/lib/python3.10/site-packages/imageio/core/util.py

@@ -0,0 +1,561 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""
+Various utilities for imageio
+"""
+
+
+from collections import OrderedDict
+import numpy as np
+import os
+import re
+import struct
+import sys
+import time
+import logging
+
+
+logger = logging.getLogger("imageio")
+
+IS_PYPY = "__pypy__" in sys.builtin_module_names
+THIS_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def urlopen(*args, **kwargs):
+    """Compatibility function for the urlopen function. Raises an
+    RuntimeError if urlopen could not be imported (which can occur in
+    frozen applications.
+    """
+    try:
+        from urllib.request import urlopen
+    except ImportError:
+        raise RuntimeError("Could not import urlopen.")
+    return urlopen(*args, **kwargs)
+
+
+def _precision_warn(p1, p2, extra=""):
+    t = (
+        "Lossy conversion from {} to {}. {} Convert image to {} prior to "
+        "saving to suppress this warning."
+    )
+    logger.warning(t.format(p1, p2, extra, p2))
+
+
+def image_as_uint(im, bitdepth=None):
+    """Convert the given image to uint (default: uint8)
+
+    If the dtype already matches the desired format, it is returned
+    as-is. If the image is float, and all values are between 0 and 1,
+    the values are multiplied by np.power(2.0, bitdepth). In all other
+    situations, the values are scaled such that the minimum value
+    becomes 0 and the maximum value becomes np.power(2.0, bitdepth)-1
+    (255 for 8-bit and 65535 for 16-bit).
+    """
+    if not bitdepth:
+        bitdepth = 8
+    if not isinstance(im, np.ndarray):
+        raise ValueError("Image must be a numpy array")
+    if bitdepth == 8:
+        out_type = np.uint8
+    elif bitdepth == 16:
+        out_type = np.uint16
+    else:
+        raise ValueError("Bitdepth must be either 8 or 16")
+    dtype_str1 = str(im.dtype)
+    dtype_str2 = out_type.__name__
+    if (im.dtype == np.uint8 and bitdepth == 8) or (
+        im.dtype == np.uint16 and bitdepth == 16
+    ):
+        # Already the correct format? Return as-is
+        return im
+    if dtype_str1.startswith("float") and np.nanmin(im) >= 0 and np.nanmax(im) <= 1:
+        _precision_warn(dtype_str1, dtype_str2, "Range [0, 1].")
+        im = im.astype(np.float64) * (np.power(2.0, bitdepth) - 1) + 0.499999999
+    elif im.dtype == np.uint16 and bitdepth == 8:
+        _precision_warn(dtype_str1, dtype_str2, "Losing 8 bits of resolution.")
+        im = np.right_shift(im, 8)
+    elif im.dtype == np.uint32:
+        _precision_warn(
+            dtype_str1,
+            dtype_str2,
+            "Losing {} bits of resolution.".format(32 - bitdepth),
+        )
+        im = np.right_shift(im, 32 - bitdepth)
+    elif im.dtype == np.uint64:
+        _precision_warn(
+            dtype_str1,
+            dtype_str2,
+            "Losing {} bits of resolution.".format(64 - bitdepth),
+        )
+        im = np.right_shift(im, 64 - bitdepth)
+    else:
+        mi = np.nanmin(im)
+        ma = np.nanmax(im)
+        if not np.isfinite(mi):
+            raise ValueError("Minimum image value is not finite")
+        if not np.isfinite(ma):
+            raise ValueError("Maximum image value is not finite")
+        if ma == mi:
+            return im.astype(out_type)
+        _precision_warn(dtype_str1, dtype_str2, "Range [{}, {}].".format(mi, ma))
+        # Now make float copy before we scale
+        im = im.astype("float64")
+        # Scale the values between 0 and 1 then multiply by the max value
+        im = (im - mi) / (ma - mi) * (np.power(2.0, bitdepth) - 1) + 0.499999999
+    assert np.nanmin(im) >= 0
+    assert np.nanmax(im) < np.power(2.0, bitdepth)
+    return im.astype(out_type)
+
+
+class Array(np.ndarray):
+    """Array(array, meta=None)
+
+    A subclass of np.ndarray that has a meta attribute. Get the dictionary
+    that contains the meta data using ``im.meta``. Convert to a plain numpy
+    array using ``np.asarray(im)``.
+
+    """
+
+    def __new__(cls, array, meta=None):
+        # Check
+        if not isinstance(array, np.ndarray):
+            raise ValueError("Array expects a numpy array.")
+        if not (meta is None or isinstance(meta, dict)):
+            raise ValueError("Array expects meta data to be a dict.")
+        # Convert and return
+        meta = meta if meta is not None else getattr(array, "meta", {})
+        try:
+            ob = array.view(cls)
+        except AttributeError:  # pragma: no cover
+            # Just return the original; no metadata on the array in Pypy!
+            return array
+        ob._copy_meta(meta)
+        return ob
+
+    def _copy_meta(self, meta):
+        """Make a 2-level deep copy of the meta dictionary."""
+        self._meta = Dict()
+        for key, val in meta.items():
+            if isinstance(val, dict):
+                val = Dict(val)  # Copy this level
+            self._meta[key] = val
+
+    @property
+    def meta(self):
+        """The dict with the meta data of this image."""
+        return self._meta
+
+    def __array_finalize__(self, ob):
+        """So the meta info is maintained when doing calculations with
+        the array.
+        """
+        if isinstance(ob, Array):
+            self._copy_meta(ob.meta)
+        else:
+            self._copy_meta({})
+
+    def __array_wrap__(self, out, context=None):
+        """So that we return a native numpy array (or scalar) when a
+        reducting ufunc is applied (such as sum(), std(), etc.)
+        """
+        if not out.shape:
+            return out.dtype.type(out)  # Scalar
+        elif out.shape != self.shape:
+            return out.view(type=np.ndarray)
+        elif not isinstance(out, Array):
+            return Array(out, self.meta)
+        else:
+            return out  # Type Array
+
+
+Image = Array  # Alias for backwards compatibility
+
+
+def asarray(a):
+    """Pypy-safe version of np.asarray. Pypy's np.asarray consumes a
+    *lot* of memory if the given array is an ndarray subclass. This
+    function does not.
+    """
+    if isinstance(a, np.ndarray):
+        if IS_PYPY:  # pragma: no cover
+            a = a.copy()  # pypy has issues with base views
+        plain = a.view(type=np.ndarray)
+        return plain
+    return np.asarray(a)
+
+
+class Dict(OrderedDict):
+    """A dict in which the keys can be get and set as if they were
+    attributes. Very convenient in combination with autocompletion.
+
+    This Dict still behaves as much as possible as a normal dict, and
+    keys can be anything that are otherwise valid keys. However,
+    keys that are not valid identifiers or that are names of the dict
+    class (such as 'items' and 'copy') cannot be get/set as attributes.
+    """
+
+    __reserved_names__ = dir(OrderedDict())  # Also from OrderedDict
+    __pure_names__ = dir(dict())
+
+    def __getattribute__(self, key):
+        try:
+            return object.__getattribute__(self, key)
+        except AttributeError:
+            if key in self:
+                return self[key]
+            else:
+                raise
+
+    def __setattr__(self, key, val):
+        if key in Dict.__reserved_names__:
+            # Either let OrderedDict do its work, or disallow
+            if key not in Dict.__pure_names__:
+                return OrderedDict.__setattr__(self, key, val)
+            else:
+                raise AttributeError(
+                    "Reserved name, this key can only "
+                    + "be set via ``d[%r] = X``" % key
+                )
+        else:
+            # if isinstance(val, dict): val = Dict(val) -> no, makes a copy!
+            self[key] = val
+
+    def __dir__(self):
+        def isidentifier(x):
+            return bool(re.match(r"[a-z_]\w*$", x, re.I))
+
+        names = [k for k in self.keys() if (isinstance(k, str) and isidentifier(k))]
+        return Dict.__reserved_names__ + names
+
+
+class BaseProgressIndicator(object):
+    """BaseProgressIndicator(name)
+
+    A progress indicator helps display the progress of a task to the
+    user. Progress can be pending, running, finished or failed.
+
+    Each task has:
+      * a name - a short description of what needs to be done.
+      * an action - the current action in performing the task (e.g. a subtask)
+      * progress - how far the task is completed
+      * max - max number of progress units. If 0, the progress is indefinite
+      * unit - the units in which the progress is counted
+      * status - 0: pending, 1: in progress, 2: finished, 3: failed
+
+    This class defines an abstract interface. Subclasses should implement
+    _start, _stop, _update_progress(progressText), _write(message).
+    """
+
+    def __init__(self, name):
+        self._name = name
+        self._action = ""
+        self._unit = ""
+        self._max = 0
+        self._status = 0
+        self._last_progress_update = 0
+
+    def start(self, action="", unit="", max=0):
+        """start(action='', unit='', max=0)
+
+        Start the progress. Optionally specify an action, a unit,
+        and a maximum progress value.
+        """
+        if self._status == 1:
+            self.finish()
+        self._action = action
+        self._unit = unit
+        self._max = max
+        #
+        self._progress = 0
+        self._status = 1
+        self._start()
+
+    def status(self):
+        """status()
+
+        Get the status of the progress - 0: pending, 1: in progress,
+        2: finished, 3: failed
+        """
+        return self._status
+
+    def set_progress(self, progress=0, force=False):
+        """set_progress(progress=0, force=False)
+
+        Set the current progress. To avoid unnecessary progress updates
+        this will only have a visual effect if the time since the last
+        update is > 0.1 seconds, or if force is True.
+        """
+        self._progress = progress
+        # Update or not?
+        if not (force or (time.time() - self._last_progress_update > 0.1)):
+            return
+        self._last_progress_update = time.time()
+        # Compose new string
+        unit = self._unit or ""
+        progressText = ""
+        if unit == "%":
+            progressText = "%2.1f%%" % progress
+        elif self._max > 0:
+            percent = 100 * float(progress) / self._max
+            progressText = "%i/%i %s (%2.1f%%)" % (progress, self._max, unit, percent)
+        elif progress > 0:
+            if isinstance(progress, float):
+                progressText = "%0.4g %s" % (progress, unit)
+            else:
+                progressText = "%i %s" % (progress, unit)
+        # Update
+        self._update_progress(progressText)
+
+    def increase_progress(self, extra_progress):
+        """increase_progress(extra_progress)
+
+        Increase the progress by a certain amount.
+        """
+        self.set_progress(self._progress + extra_progress)
+
+    def finish(self, message=None):
+        """finish(message=None)
+
+        Finish the progress, optionally specifying a message. This will
+        not set the progress to the maximum.
+        """
+        self.set_progress(self._progress, True)  # fore update
+        self._status = 2
+        self._stop()
+        if message is not None:
+            self._write(message)
+
+    def fail(self, message=None):
+        """fail(message=None)
+
+        Stop the progress with a failure, optionally specifying a message.
+        """
+        self.set_progress(self._progress, True)  # fore update
+        self._status = 3
+        self._stop()
+        message = "FAIL " + (message or "")
+        self._write(message)
+
+    def write(self, message):
+        """write(message)
+
+        Write a message during progress (such as a warning).
+        """
+        if self.__class__ == BaseProgressIndicator:
+            # When this class is used as a dummy, print explicit message
+            print(message)
+        else:
+            return self._write(message)
+
+    # Implementing classes should implement these
+
+    def _start(self):
+        pass
+
+    def _stop(self):
+        pass
+
+    def _update_progress(self, progressText):
+        pass
+
+    def _write(self, message):
+        pass
+
+
+class StdoutProgressIndicator(BaseProgressIndicator):
+    """StdoutProgressIndicator(name)
+
+    A progress indicator that shows the progress in stdout. It
+    assumes that the tty can appropriately deal with backspace
+    characters.
+    """
+
+    def _start(self):
+        self._chars_prefix, self._chars = "", ""
+        # Write message
+        if self._action:
+            self._chars_prefix = "%s (%s): " % (self._name, self._action)
+        else:
+            self._chars_prefix = "%s: " % self._name
+        sys.stdout.write(self._chars_prefix)
+        sys.stdout.flush()
+
+    def _update_progress(self, progressText):
+        # If progress is unknown, at least make something move
+        if not progressText:
+            i1, i2, i3, i4 = "-\\|/"
+            M = {i1: i2, i2: i3, i3: i4, i4: i1}
+            progressText = M.get(self._chars, i1)
+        # Store new string and write
+        delChars = "\b" * len(self._chars)
+        self._chars = progressText
+        sys.stdout.write(delChars + self._chars)
+        sys.stdout.flush()
+
+    def _stop(self):
+        self._chars = self._chars_prefix = ""
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+    def _write(self, message):
+        # Write message
+        delChars = "\b" * len(self._chars_prefix + self._chars)
+        sys.stdout.write(delChars + "  " + message + "\n")
+        # Reprint progress text
+        sys.stdout.write(self._chars_prefix + self._chars)
+        sys.stdout.flush()
+
+
+# From pyzolib/paths.py (https://bitbucket.org/pyzo/pyzolib/src/tip/paths.py)
+def appdata_dir(appname=None, roaming=False):
+    """appdata_dir(appname=None, roaming=False)
+
+    Get the path to the application directory, where applications are allowed
+    to write user specific files (e.g. configurations). For non-user specific
+    data, consider using common_appdata_dir().
+    If appname is given, a subdir is appended (and created if necessary).
+    If roaming is True, will prefer a roaming directory (Windows Vista/7).
+    """
+
+    # Define default user directory
+    userDir = os.getenv("IMAGEIO_USERDIR", None)
+    if userDir is None:
+        userDir = os.path.expanduser("~")
+        if not os.path.isdir(userDir):  # pragma: no cover
+            userDir = "/var/tmp"  # issue #54
+
+    # Get system app data dir
+    path = None
+    if sys.platform.startswith("win"):
+        path1, path2 = os.getenv("LOCALAPPDATA"), os.getenv("APPDATA")
+        path = (path2 or path1) if roaming else (path1 or path2)
+    elif sys.platform.startswith("darwin"):
+        path = os.path.join(userDir, "Library", "Application Support")
+    # On Linux and as fallback
+    if not (path and os.path.isdir(path)):
+        path = userDir
+
+    # Maybe we should store things local to the executable (in case of a
+    # portable distro or a frozen application that wants to be portable)
+    prefix = sys.prefix
+    if getattr(sys, "frozen", None):
+        prefix = os.path.abspath(os.path.dirname(sys.executable))
+    for reldir in ("settings", "../settings"):
+        localpath = os.path.abspath(os.path.join(prefix, reldir))
+        if os.path.isdir(localpath):  # pragma: no cover
+            try:
+                open(os.path.join(localpath, "test.write"), "wb").close()
+                os.remove(os.path.join(localpath, "test.write"))
+            except IOError:
+                pass  # We cannot write in this directory
+            else:
+                path = localpath
+                break
+
+    # Get path specific for this app
+    if appname:
+        if path == userDir:
+            appname = "." + appname.lstrip(".")  # Make it a hidden directory
+        path = os.path.join(path, appname)
+        if not os.path.isdir(path):  # pragma: no cover
+            os.makedirs(path, exist_ok=True)
+
+    # Done
+    return path
+
+
+def resource_dirs():
+    """resource_dirs()
+
+    Get a list of directories where imageio resources may be located.
+    The first directory in this list is the "resources" directory in
+    the package itself. The second directory is the appdata directory
+    (~/.imageio on Linux). The list further contains the application
+    directory (for frozen apps), and may include additional directories
+    in the future.
+    """
+    dirs = [resource_package_dir()]
+    # Resource dir baked in the package.
+    # Appdata directory
+    try:
+        dirs.append(appdata_dir("imageio"))
+    except Exception:  # pragma: no cover
+        pass  # The home dir may not be writable
+    # Directory where the app is located (mainly for frozen apps)
+    if getattr(sys, "frozen", None):
+        dirs.append(os.path.abspath(os.path.dirname(sys.executable)))
+    elif sys.path and sys.path[0]:
+        dirs.append(os.path.abspath(sys.path[0]))
+    return dirs
+
+
+def resource_package_dir():
+    """package_dir
+
+    Get the resources directory in the imageio package installation
+    directory.
+
+    Notes
+    -----
+    This is a convenience method that is used by `resource_dirs` and
+    imageio entry point scripts.
+    """
+    # Make pkg_resources optional if setuptools is not available
+    try:
+        # Avoid importing pkg_resources in the top level due to how slow it is
+        # https://github.com/pypa/setuptools/issues/510
+        import pkg_resources
+    except ImportError:
+        pkg_resources = None
+
+    if pkg_resources:
+        # The directory returned by `pkg_resources.resource_filename`
+        # also works with eggs.
+        pdir = pkg_resources.resource_filename("imageio", "resources")
+    else:
+        # If setuptools is not available, use fallback
+        pdir = os.path.abspath(os.path.join(THIS_DIR, "..", "resources"))
+    return pdir
+
+
+def get_platform():
+    """get_platform()
+
+    Get a string that specifies the platform more specific than
+    sys.platform does. The result can be: linux32, linux64, win32,
+    win64, osx32, osx64. Other platforms may be added in the future.
+    """
+    # Get platform
+    if sys.platform.startswith("linux"):
+        plat = "linux%i"
+    elif sys.platform.startswith("win"):
+        plat = "win%i"
+    elif sys.platform.startswith("darwin"):
+        plat = "osx%i"
+    elif sys.platform.startswith("freebsd"):
+        plat = "freebsd%i"
+    else:  # pragma: no cover
+        return None
+
+    return plat % (struct.calcsize("P") * 8)  # 32 or 64 bits
+
+
+def has_module(module_name):
+    """Check to see if a python module is available."""
+    if sys.version_info > (3, 4):
+        import importlib
+
+        name_parts = module_name.split(".")
+        for i in range(len(name_parts)):
+            if importlib.util.find_spec(".".join(name_parts[: i + 1])) is None:
+                return False
+        return True
+    else:  # pragma: no cover
+        import imp
+
+        try:
+            imp.find_module(module_name)
+        except ImportError:
+            return False
+        return True

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/_dicom.py

@@ -0,0 +1,932 @@
+# -*- 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().item(), data.max().item()
+                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,
+                (
+                    k.ImagePositionPatient[2]
+                    if hasattr(k, "ImagePositionPatient")
+                    else None
+                ),
+            )
+        )
+
+    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)

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/example.py

@@ -0,0 +1,145 @@
+# -*- 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
+
+        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.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)

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/feisem.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read TIFF from FEI SEM microscopes.
+
+Backend Library: internal
+
+This format is based on :mod:`TIFF <imageio.plugins.tifffile>`, and supports the
+same parameters. FEI microscopes append metadata as ASCII text at the end of the
+file, which this reader correctly extracts.
+
+Parameters
+----------
+discard_watermark : bool
+    If True (default), discard the bottom rows of the image, which
+    contain no image data, only a watermark with metadata.
+watermark_height : int
+    The height in pixels of the FEI watermark. The default is 70.
+
+See Also
+--------
+    :mod:`imageio.plugins.tifffile`
+
+"""
+
+
+from .tifffile import TiffFormat
+
+
+class FEISEMFormat(TiffFormat):
+    """See :mod:`imageio.plugins.feisem`"""
+
+    def _can_write(self, request):
+        return False  # FEI-SEM only supports reading
+
+    class Reader(TiffFormat.Reader):
+        def _get_data(self, index=0, discard_watermark=True, watermark_height=70):
+            """Get image and metadata from given index.
+
+            FEI images usually (always?) contain a watermark at the
+            bottom of the image, 70 pixels high. We discard this by
+            default as it does not contain any information not present
+            in the metadata.
+            """
+            im, meta = super(FEISEMFormat.Reader, self)._get_data(index)
+            if discard_watermark:
+                im = im[:-watermark_height]
+            return im, meta
+
+        def _get_meta_data(self, index=None):
+            """Read the metadata from an FEI SEM TIFF.
+
+            This metadata is included as ASCII text at the end of the file.
+
+            The index, if provided, is ignored.
+
+            Returns
+            -------
+            metadata : dict
+                Dictionary of metadata.
+            """
+            if hasattr(self, "_fei_meta"):
+                return self._fei_meta
+
+            md = {"root": {}}
+            current_tag = "root"
+            reading_metadata = False
+            filename = self.request.get_local_filename()
+            with open(filename, encoding="utf8", errors="ignore") as fin:
+                for line in fin:
+                    if not reading_metadata:
+                        if not line.startswith("Date="):
+                            continue
+                        else:
+                            reading_metadata = True
+                    line = line.rstrip()
+                    if line.startswith("["):
+                        current_tag = line.lstrip("[").rstrip("]")
+                        md[current_tag] = {}
+                    else:
+                        if "=" in line:  # ignore empty and irrelevant lines
+                            key, val = line.split("=", maxsplit=1)
+                            for tag_type in (int, float):
+                                try:
+                                    val = tag_type(val)
+                                except ValueError:
+                                    continue
+                                else:
+                                    break
+                            md[current_tag][key] = val
+            if not md["root"] and len(md) == 1:
+                raise ValueError("Input file %s contains no FEI metadata." % filename)
+
+            self._fei_meta = md
+            return md

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/grab.py

@@ -0,0 +1,105 @@
+"""
+PIL-based formats to take screenshots and grab from the clipboard.
+"""
+
+import threading
+
+import numpy as np
+
+from ..core import Format
+
+
+class BaseGrabFormat(Format):
+    """Base format for grab formats."""
+
+    _pillow_imported = False
+    _ImageGrab = None
+
+    def __init__(self, *args, **kwargs):
+        super(BaseGrabFormat, self).__init__(*args, **kwargs)
+        self._lock = threading.RLock()
+
+    def _can_write(self, request):
+        return False
+
+    def _init_pillow(self):
+        with self._lock:
+            if not self._pillow_imported:
+                self._pillow_imported = True  # more like tried to import
+                import PIL
+
+                if not hasattr(PIL, "__version__"):  # pragma: no cover
+                    raise ImportError("Imageio Pillow requires " "Pillow, not PIL!")
+                try:
+                    from PIL import ImageGrab
+                except ImportError:
+                    return None
+                self._ImageGrab = ImageGrab
+        return self._ImageGrab
+
+    class Reader(Format.Reader):
+        def _open(self):
+            pass
+
+        def _close(self):
+            pass
+
+        def _get_data(self, index):
+            return self.format._get_data(index)
+
+
+class ScreenGrabFormat(BaseGrabFormat):
+    """The ScreenGrabFormat provided a means to grab screenshots using
+    the uri of "<screen>".
+
+    This functionality is provided via Pillow. Note that "<screen>" is
+    only supported on Windows and OS X.
+
+    Parameters for reading
+    ----------------------
+    No parameters.
+    """
+
+    def _can_read(self, request):
+        if request.filename != "<screen>":
+            return False
+        return bool(self._init_pillow())
+
+    def _get_data(self, index):
+        ImageGrab = self._init_pillow()
+        assert ImageGrab
+
+        pil_im = ImageGrab.grab()
+        assert pil_im is not None
+        im = np.asarray(pil_im)
+        return im, {}
+
+
+class ClipboardGrabFormat(BaseGrabFormat):
+    """The ClipboardGrabFormat provided a means to grab image data from
+    the clipboard, using the uri "<clipboard>"
+
+    This functionality is provided via Pillow. Note that "<clipboard>" is
+    only supported on Windows.
+
+    Parameters for reading
+    ----------------------
+    No parameters.
+    """
+
+    def _can_read(self, request):
+        if request.filename != "<clipboard>":
+            return False
+        return bool(self._init_pillow())
+
+    def _get_data(self, index):
+        ImageGrab = self._init_pillow()
+        assert ImageGrab
+
+        pil_im = ImageGrab.grabclipboard()
+        if pil_im is None:
+            raise RuntimeError(
+                "There seems to be no image data on the " "clipboard now."
+            )
+        im = np.asarray(pil_im)
+        return im, {}

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/opencv.py

@@ -0,0 +1,313 @@
+"""Read/Write images using OpenCV.
+
+Backend Library: `OpenCV <https://opencv.org/>`_
+
+This plugin wraps OpenCV (also known as ``cv2``), a popular image processing
+library. Currently, it exposes OpenCVs image reading capability (no video or GIF
+support yet); however, this may be added in future releases.
+
+Methods
+-------
+.. note::
+    Check the respective function for a list of supported kwargs and their
+    documentation.
+
+.. autosummary::
+    :toctree:
+
+    OpenCVPlugin.read
+    OpenCVPlugin.iter
+    OpenCVPlugin.write
+    OpenCVPlugin.properties
+    OpenCVPlugin.metadata
+
+Pixel Formats (Colorspaces)
+---------------------------
+
+OpenCV is known to process images in BGR; however, most of the python ecosystem
+(in particular matplotlib and other pydata libraries) use the RGB. As such,
+images are converted to RGB, RGBA, or grayscale (where applicable) by default.
+
+"""
+
+import warnings
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import cv2
+import numpy as np
+
+from ..core import Request
+from ..core.request import URI_BYTES, InitializationError, IOMode
+from ..core.v3_plugin_api import ImageProperties, PluginV3
+from ..typing import ArrayLike
+
+
+class OpenCVPlugin(PluginV3):
+    def __init__(self, request: Request) -> None:
+        super().__init__(request)
+
+        self.file_handle = request.get_local_filename()
+        if request._uri_type is URI_BYTES:
+            self.filename = "<bytes>"
+        else:
+            self.filename = request.raw_uri
+
+        mode = request.mode.io_mode
+        if mode == IOMode.read and not cv2.haveImageReader(self.file_handle):
+            raise InitializationError(f"OpenCV can't read `{self.filename}`.")
+        elif mode == IOMode.write and not cv2.haveImageWriter(self.file_handle):
+            raise InitializationError(f"OpenCV can't write to `{self.filename}`.")
+
+    def read(
+        self,
+        *,
+        index: int = None,
+        colorspace: Union[int, str] = None,
+        flags: int = cv2.IMREAD_COLOR,
+    ) -> np.ndarray:
+        """Read an image from the ImageResource.
+
+        Parameters
+        ----------
+        index : int, Ellipsis
+            If int, read the index-th image from the ImageResource. If ``...``,
+            read all images from the ImageResource and stack them along a new,
+            prepended, batch dimension. If None (default), use ``index=0`` if
+            the image contains exactly one image and ``index=...`` otherwise.
+        colorspace : str, int
+            The colorspace to convert into after loading and before returning
+            the image. If None (default) keep grayscale images as is, convert
+            images with an alpha channel to ``RGBA`` and all other images to
+            ``RGB``. If int, interpret ``colorspace`` as one of OpenCVs
+            `conversion flags
+            <https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_
+            and use it for conversion. If str, convert the image into the given
+            colorspace. Possible string values are: ``"RGB"``, ``"BGR"``,
+            ``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``.
+        flags : int
+            The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs
+            <https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_
+            for details.
+
+        Returns
+        -------
+        ndimage : np.ndarray
+            The decoded image as a numpy array.
+
+        """
+
+        if index is None:
+            n_images = cv2.imcount(self.file_handle, flags)
+            index = 0 if n_images == 1 else ...
+
+        if index is ...:
+            retval, img = cv2.imreadmulti(self.file_handle, flags=flags)
+            is_batch = True
+        else:
+            retval, img = cv2.imreadmulti(self.file_handle, index, 1, flags=flags)
+            is_batch = False
+
+        if retval is False:
+            raise ValueError(f"Could not read index `{index}` from `{self.filename}`.")
+
+        if img[0].ndim == 2:
+            in_colorspace = "GRAY"
+            out_colorspace = colorspace or "GRAY"
+        elif img[0].shape[-1] == 4:
+            in_colorspace = "BGRA"
+            out_colorspace = colorspace or "RGBA"
+        else:
+            in_colorspace = "BGR"
+            out_colorspace = colorspace or "RGB"
+
+        if isinstance(colorspace, int):
+            cvt_space = colorspace
+        elif in_colorspace == out_colorspace.upper():
+            cvt_space = None
+        else:
+            out_colorspace = out_colorspace.upper()
+            cvt_space = getattr(cv2, f"COLOR_{in_colorspace}2{out_colorspace}")
+
+        if cvt_space is not None:
+            img = np.stack([cv2.cvtColor(x, cvt_space) for x in img])
+        else:
+            img = np.stack(img)
+
+        return img if is_batch else img[0]
+
+    def iter(
+        self,
+        colorspace: Union[int, str] = None,
+        flags: int = cv2.IMREAD_COLOR,
+    ) -> np.ndarray:
+        """Yield images from the ImageResource.
+
+        Parameters
+        ----------
+        colorspace : str, int
+            The colorspace to convert into after loading and before returning
+            the image. If None (default) keep grayscale images as is, convert
+            images with an alpha channel to ``RGBA`` and all other images to
+            ``RGB``. If int, interpret ``colorspace`` as one of OpenCVs
+            `conversion flags
+            <https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_
+            and use it for conversion. If str, convert the image into the given
+            colorspace. Possible string values are: ``"RGB"``, ``"BGR"``,
+            ``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``.
+        flags : int
+            The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs
+            <https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_
+            for details.
+
+        Yields
+        ------
+        ndimage : np.ndarray
+            The decoded image as a numpy array.
+
+        """
+        for idx in range(cv2.imcount(self.file_handle)):
+            yield self.read(index=idx, flags=flags, colorspace=colorspace)
+
+    def write(
+        self,
+        ndimage: Union[ArrayLike, List[ArrayLike]],
+        is_batch: bool = False,
+        params: List[int] = None,
+    ) -> Optional[bytes]:
+        """Save an ndimage in the ImageResource.
+
+        Parameters
+        ----------
+        ndimage : ArrayLike, List[ArrayLike]
+            The image data that will be written to the file. It is either a
+            single image, a batch of images, or a list of images.
+        is_batch : bool
+            If True, the provided ndimage is a batch of images. If False (default), the
+            provided ndimage is a single image. If the provided ndimage is a list of images,
+            this parameter has no effect.
+        params : List[int]
+            A list of parameters that will be passed to OpenCVs imwrite or
+            imwritemulti functions. Possible values are documented in the
+            `OpenCV documentation
+            <https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce>`_.
+
+        Returns
+        -------
+        encoded_image : bytes, None
+            If the ImageResource is ``"<bytes>"`` the call to write returns the
+            encoded image as a bytes string. Otherwise it returns None.
+
+        """
+
+        if isinstance(ndimage, list):
+            ndimage = np.stack(ndimage, axis=0)
+        elif not is_batch:
+            ndimage = ndimage[None, ...]
+
+        if ndimage[0].ndim == 2:
+            n_channels = 1
+        else:
+            n_channels = ndimage[0].shape[-1]
+
+        if n_channels == 1:
+            ndimage_cv2 = [x for x in ndimage]
+        elif n_channels == 4:
+            ndimage_cv2 = [cv2.cvtColor(x, cv2.COLOR_RGBA2BGRA) for x in ndimage]
+        else:
+            ndimage_cv2 = [cv2.cvtColor(x, cv2.COLOR_RGB2BGR) for x in ndimage]
+
+        retval = cv2.imwritemulti(self.file_handle, ndimage_cv2, params)
+
+        if retval is False:
+            # not sure what scenario would trigger this, but
+            # it can occur theoretically.
+            raise IOError("OpenCV failed to write.")  # pragma: no cover
+
+        if self.request._uri_type == URI_BYTES:
+            return Path(self.file_handle).read_bytes()
+
+    def properties(
+        self,
+        index: int = None,
+        colorspace: Union[int, str] = None,
+        flags: int = cv2.IMREAD_COLOR,
+    ) -> ImageProperties:
+        """Standardized image metadata.
+
+        Parameters
+        ----------
+        index : int, Ellipsis
+            If int, get the properties of the index-th image in the
+            ImageResource. If ``...``, get the properties of the image stack
+            that contains all images. If None (default), use ``index=0`` if the
+            image contains exactly one image and ``index=...`` otherwise.
+        colorspace : str, int
+            The colorspace to convert into after loading and before returning
+            the image. If None (default) keep grayscale images as is, convert
+            images with an alpha channel to ``RGBA`` and all other images to
+            ``RGB``. If int, interpret ``colorspace`` as one of OpenCVs
+            `conversion flags
+            <https://docs.opencv.org/4.x/d8/d01/group__imgproc__color__conversions.html>`_
+            and use it for conversion. If str, convert the image into the given
+            colorspace. Possible string values are: ``"RGB"``, ``"BGR"``,
+            ``"RGBA"``, ``"BGRA"``, ``"GRAY"``, ``"HSV"``, or ``"LAB"``.
+        flags : int
+            The OpenCV flag(s) to pass to the reader. Refer to the `OpenCV docs
+            <https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56>`_
+            for details.
+
+        Returns
+        -------
+        props : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        Notes
+        -----
+        Reading properties with OpenCV involves decoding pixel data, because
+        OpenCV doesn't provide a direct way to access metadata.
+
+        """
+
+        if index is None:
+            n_images = cv2.imcount(self.file_handle, flags)
+            is_batch = n_images > 1
+        elif index is Ellipsis:
+            n_images = cv2.imcount(self.file_handle, flags)
+            is_batch = True
+        else:
+            is_batch = False
+
+        # unfortunately, OpenCV doesn't allow reading shape without reading pixel data
+        if is_batch:
+            img = self.read(index=0, flags=flags, colorspace=colorspace)
+            return ImageProperties(
+                shape=(n_images, *img.shape),
+                dtype=img.dtype,
+                n_images=n_images,
+                is_batch=True,
+            )
+
+        img = self.read(index=index, flags=flags, colorspace=colorspace)
+        return ImageProperties(shape=img.shape, dtype=img.dtype, is_batch=False)
+
+    def metadata(
+        self, index: int = None, exclude_applied: bool = True
+    ) -> Dict[str, Any]:
+        """Format-specific metadata.
+
+        .. warning::
+            OpenCV does not support reading metadata. When called, this function
+            will raise a ``NotImplementedError``.
+
+        Parameters
+        ----------
+        index : int
+            This parameter has no effect.
+        exclude_applied : bool
+            This parameter has no effect.
+
+        """
+
+        warnings.warn("OpenCV does not support reading metadata.", UserWarning)
+        return dict()

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/pillow_info.py

@@ -0,0 +1,1053 @@
+# -*- coding: utf-8 -*-
+
+# styletest: ignore E122 E123 E501
+
+"""
+Module that contain info about the Pillow formats. The first part of
+this module generates this info and writes it to its own bottom half
+if run as a script.
+"""
+
+import warnings
+
+warnings.warn(
+    "The `PillowFormat` plugin is deprecated and will be removed in ImageIO v3."
+    " Use the new `PillowPlugin` instead.",
+    DeprecationWarning,
+)
+
+
+def generate_info():  # pragma: no cover
+    from urllib.request import urlopen
+    import PIL
+    from PIL import Image
+
+    Image.init()
+
+    ids = []
+    formats = []
+    docs = {}
+
+    # Collect formats and their summary from plugin modules
+    for mod_name in dir(PIL):
+        if "ImagePlugin" in mod_name:
+            mod = getattr(PIL, mod_name)
+            for ob_name in dir(mod):
+                ob = getattr(mod, ob_name)
+                if isinstance(ob, type) and issubclass(ob, Image.Image):
+                    if ob.format in ids:
+                        print("Found duplicate for", ob.format)
+                    else:
+                        ids.append(ob.format)
+                        formats.append((ob.format, ob.format_description))
+
+    # Add extension info
+    for i in range(len(formats)):
+        id, summary = formats[i]
+        ext = " ".join([e for e in Image.EXTENSION if Image.EXTENSION[e] == id])
+        formats[i] = id, summary, ext
+
+    # Get documentation of formats
+    url = "https://raw.githubusercontent.com/python-pillow/Pillow/master/docs/handbook/image-file-formats.rst"  # noqa
+    lines = urlopen(url).read().decode().splitlines()
+    lines.append("End")
+    lines.append("---")  # for the end
+
+    # Parse documentation
+    cur_name = ""
+    cur_part = []
+    for i in range(len(lines)):
+        line = lines[i]
+        if line.startswith(("^^^", "---", "===")):
+            if cur_name and cur_name in ids:
+                text = "\n".join(cur_part[:-1])
+                text = text.replace("versionadded::", "versionadded:: Pillow ")
+                text = text.replace("Image.open`", "Image.write`")
+                docs[cur_name] = text
+            cur_part = []
+            cur_name = lines[i - 1].strip().replace(" ", "").upper()
+        else:
+            cur_part.append("    " + line)
+
+    # Fill in the blancs
+    for id in ids:
+        if id in docs:
+            docs[id] = "*From the Pillow docs:*\n\n" + docs[id]
+        else:
+            docs[id] = "No docs for %s." % id
+            print("no docs for", id)
+
+    # Sort before writing
+    formats.sort(key=lambda x: x[0])
+    ids.sort()
+
+    # Read file ...
+    code = open(__file__, "rb").read().decode()
+    code, divider, _ = code.partition("## BELOW IS " + "AUTOGENERATED")
+    code += divider + "\n\n"
+
+    # Write formats
+    code += "pillow_formats = [\n"
+    for i in range(len(formats)):
+        print(formats[i])
+        code += "    (%r, %r, %r),\n" % formats[i]
+    code += "    ]\n\n\n"
+
+    # Write docs
+    code += "pillow_docs = {\n"
+    for id in ids:
+        code += '%r:\nu"""%s""",\n' % (id, docs[id])
+    code += "}\n"
+
+    # Write back
+    with open(__file__, "wb") as f:
+        f.write(code.encode())
+
+
+if __name__ == "__main__":
+    generate_info()
+
+
+# BELOW IS AUTOGENERATED
+
+pillow_formats = [
+    ("BMP", "Windows Bitmap", ".bmp"),
+    ("BUFR", "BUFR", ".bufr"),
+    ("CUR", "Windows Cursor", ".cur"),
+    ("DCX", "Intel DCX", ".dcx"),
+    ("DDS", "DirectDraw Surface", ".dds"),
+    ("DIB", "Windows Bitmap", ""),
+    ("EPS", "Encapsulated Postscript", ".ps .eps"),
+    ("FITS", "FITS", ".fit .fits"),
+    ("FLI", "Autodesk FLI/FLC Animation", ".fli .flc"),
+    ("FPX", "FlashPix", ".fpx"),
+    ("FTEX", "Texture File Format (IW2:EOC)", ".ftc .ftu"),
+    ("GBR", "GIMP brush file", ".gbr"),
+    ("GIF", "Compuserve GIF", ".gif"),
+    ("GRIB", "GRIB", ".grib"),
+    ("HDF5", "HDF5", ".h5 .hdf"),
+    ("ICNS", "Mac OS icns resource", ".icns"),
+    ("ICO", "Windows Icon", ".ico"),
+    ("IM", "IFUNC Image Memory", ".im"),
+    ("IMT", "IM Tools", ""),
+    ("IPTC", "IPTC/NAA", ".iim"),
+    ("JPEG", "JPEG (ISO 10918)", ".jfif .jpe .jpg .jpeg"),
+    ("JPEG2000", "JPEG 2000 (ISO 15444)", ".jp2 .j2k .jpc .jpf .jpx .j2c"),
+    ("MCIDAS", "McIdas area file", ""),
+    ("MIC", "Microsoft Image Composer", ".mic"),
+    ("MPEG", "MPEG", ".mpg .mpeg"),
+    ("MPO", "MPO (CIPA DC-007)", ".mpo"),
+    ("MSP", "Windows Paint", ".msp"),
+    ("PCD", "Kodak PhotoCD", ".pcd"),
+    ("PCX", "Paintbrush", ".pcx"),
+    ("PIXAR", "PIXAR raster image", ".pxr"),
+    ("PNG", "Portable network graphics", ".png"),
+    ("PPM", "Pbmplus image", ".pbm .pgm .ppm"),
+    ("PSD", "Adobe Photoshop", ".psd"),
+    ("SGI", "SGI Image File Format", ".bw .rgb .rgba .sgi"),
+    ("SPIDER", "Spider 2D image", ""),
+    ("SUN", "Sun Raster File", ".ras"),
+    ("TGA", "Targa", ".tga"),
+    ("TIFF", "Adobe TIFF", ".tif .tiff"),
+    ("WMF", "Windows Metafile", ".wmf .emf"),
+    ("XBM", "X11 Bitmap", ".xbm"),
+    ("XPM", "X11 Pixel Map", ".xpm"),
+    ("XVThumb", "XV thumbnail image", ""),
+]
+
+
+pillow_docs = {
+    "BMP": """*From the Pillow docs:*
+
+
+    PIL reads and writes Windows and OS/2 BMP files containing ``1``, ``L``, ``P``,
+    or ``RGB`` data. 16-colour images are read as ``P`` images. Run-length encoding
+    is not supported.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **compression**
+        Set to ``bmp_rle`` if the file is run-length encoded.
+    """,
+    "BUFR": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  1.1.3
+
+    PIL provides a stub driver for BUFR files.
+
+    To add read or write support to your application, use
+    :py:func:`PIL.BufrStubImagePlugin.register_handler`.
+    """,
+    "CUR": """*From the Pillow docs:*
+
+
+    CUR is used to store cursors on Windows. The CUR decoder reads the largest
+    available cursor. Animated cursors are not supported.
+    """,
+    "DCX": """*From the Pillow docs:*
+
+
+    DCX is a container file format for PCX files, defined by Intel. The DCX format
+    is commonly used in fax applications. The DCX decoder can read files containing
+    ``1``, ``L``, ``P``, or ``RGB`` data.
+
+    When the file is opened, only the first image is read. You can use
+    :py:meth:`~file.seek` or :py:mod:`~PIL.ImageSequence` to read other images.
+
+    """,
+    "DDS": """*From the Pillow docs:*
+
+
+    DDS is a popular container texture format used in video games and natively
+    supported by DirectX.
+    Currently, DXT1, DXT3, and DXT5 pixel formats are supported and only in ``RGBA``
+    mode.
+
+    .. versionadded:: Pillow  3.4.0 DXT3
+    """,
+    "DIB": """No docs for DIB.""",
+    "EPS": """*From the Pillow docs:*
+
+
+    PIL identifies EPS files containing image data, and can read files that contain
+    embedded raster images (ImageData descriptors). If Ghostscript is available,
+    other EPS files can be read as well. The EPS driver can also write EPS
+    images. The EPS driver can read EPS images in ``L``, ``LAB``, ``RGB`` and
+    ``CMYK`` mode, but Ghostscript may convert the images to ``RGB`` mode rather
+    than leaving them in the original color space. The EPS driver can write images
+    in ``L``, ``RGB`` and ``CMYK`` modes.
+
+    If Ghostscript is available, you can call the :py:meth:`~PIL.Image.Image.load`
+    method with the following parameter to affect how Ghostscript renders the EPS
+
+    **scale**
+        Affects the scale of the resultant rasterized image. If the EPS suggests
+        that the image be rendered at 100px x 100px, setting this parameter to
+        2 will make the Ghostscript render a 200px x 200px image instead. The
+        relative position of the bounding box is maintained::
+
+            im = Image.open(...)
+            im.size #(100,100)
+            im.load(scale=2)
+            im.size #(200,200)
+    """,
+    "FITS": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  1.1.5
+
+    PIL provides a stub driver for FITS files.
+
+    To add read or write support to your application, use
+    :py:func:`PIL.FitsStubImagePlugin.register_handler`.
+    """,
+    "FLI": """No docs for FLI.""",
+    "FPX": """*From the Pillow docs:*
+
+
+    PIL reads Kodak FlashPix files. In the current version, only the highest
+    resolution image is read from the file, and the viewing transform is not taken
+    into account.
+
+    .. note::
+
+        To enable full FlashPix support, you need to build and install the IJG JPEG
+        library before building the Python Imaging Library. See the distribution
+        README for details.
+    """,
+    "FTEX": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  3.2.0
+
+    The FTEX decoder reads textures used for 3D objects in
+    Independence War 2: Edge Of Chaos. The plugin reads a single texture
+    per file, in the compressed and uncompressed formats.
+    """,
+    "GBR": """*From the Pillow docs:*
+
+
+    The GBR decoder reads GIMP brush files, version 1 and 2.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **comment**
+        The brush name.
+
+    **spacing**
+        The spacing between the brushes, in pixels. Version 2 only.
+
+    GD
+    ^^
+
+    PIL reads uncompressed GD files. Note that this file format cannot be
+    automatically identified, so you must use :py:func:`PIL.GdImageFile.open` to
+    read such a file.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **transparency**
+        Transparency color index. This key is omitted if the image is not
+        transparent.
+    """,
+    "GIF": """*From the Pillow docs:*
+
+
+    PIL reads GIF87a and GIF89a versions of the GIF file format. The library writes
+    run-length encoded files in GIF87a by default, unless GIF89a features
+    are used or GIF89a is already in use.
+
+    Note that GIF files are always read as grayscale (``L``)
+    or palette mode (``P``) images.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **background**
+        Default background color (a palette color index).
+
+    **transparency**
+        Transparency color index. This key is omitted if the image is not
+        transparent.
+
+    **version**
+        Version (either ``GIF87a`` or ``GIF89a``).
+
+    **duration**
+        May not be present. The time to display the current frame
+        of the GIF, in milliseconds.
+
+    **loop**
+        May not be present. The number of times the GIF should loop.
+
+    Reading sequences
+    ~~~~~~~~~~~~~~~~~
+
+    The GIF loader supports the :py:meth:`~file.seek` and :py:meth:`~file.tell`
+    methods. You can seek to the next frame (``im.seek(im.tell() + 1)``), or rewind
+    the file by seeking to the first frame. Random access is not supported.
+
+    ``im.seek()`` raises an ``EOFError`` if you try to seek after the last frame.
+
+    Saving
+    ~~~~~~
+
+    When calling :py:meth:`~PIL.Image.Image.save`, the following options
+    are available::
+
+        im.save(out, save_all=True, append_images=[im1, im2, ...])
+
+    **save_all**
+        If present and true, all frames of the image will be saved. If
+        not, then only the first frame of a multiframe image will be saved.
+
+    **append_images**
+        A list of images to append as additional frames. Each of the
+        images in the list can be single or multiframe images.
+        This is currently only supported for GIF, PDF, TIFF, and WebP.
+
+    **duration**
+        The display duration of each frame of the multiframe gif, in
+        milliseconds. Pass a single integer for a constant duration, or a
+        list or tuple to set the duration for each frame separately.
+
+    **loop**
+        Integer number of times the GIF should loop.
+
+    **optimize**
+        If present and true, attempt to compress the palette by
+        eliminating unused colors. This is only useful if the palette can
+        be compressed to the next smaller power of 2 elements.
+
+    **palette**
+        Use the specified palette for the saved image. The palette should
+        be a bytes or bytearray object containing the palette entries in
+        RGBRGB... form. It should be no more than 768 bytes. Alternately,
+        the palette can be passed in as an
+        :py:class:`PIL.ImagePalette.ImagePalette` object.
+
+    **disposal**
+        Indicates the way in which the graphic is to be treated after being displayed.
+
+        * 0 - No disposal specified.
+        * 1 - Do not dispose.
+        * 2 - Restore to background color.
+        * 3 - Restore to previous content.
+
+         Pass a single integer for a constant disposal, or a list or tuple
+         to set the disposal for each frame separately.
+
+    Reading local images
+    ~~~~~~~~~~~~~~~~~~~~
+
+    The GIF loader creates an image memory the same size as the GIF file’s *logical
+    screen size*, and pastes the actual pixel data (the *local image*) into this
+    image. If you only want the actual pixel rectangle, you can manipulate the
+    :py:attr:`~PIL.Image.Image.size` and :py:attr:`~PIL.Image.Image.tile`
+    attributes before loading the file::
+
+        im = Image.open(...)
+
+        if im.tile[0][0] == "gif":
+            # only read the first "local image" from this GIF file
+            tag, (x0, y0, x1, y1), offset, extra = im.tile[0]
+            im.size = (x1 - x0, y1 - y0)
+            im.tile = [(tag, (0, 0) + im.size, offset, extra)]
+    """,
+    "GRIB": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  1.1.5
+
+    PIL provides a stub driver for GRIB files.
+
+    The driver requires the file to start with a GRIB header. If you have files
+    with embedded GRIB data, or files with multiple GRIB fields, your application
+    has to seek to the header before passing the file handle to PIL.
+
+    To add read or write support to your application, use
+    :py:func:`PIL.GribStubImagePlugin.register_handler`.
+    """,
+    "HDF5": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  1.1.5
+
+    PIL provides a stub driver for HDF5 files.
+
+    To add read or write support to your application, use
+    :py:func:`PIL.Hdf5StubImagePlugin.register_handler`.
+    """,
+    "ICNS": """*From the Pillow docs:*
+
+
+    PIL reads and (macOS only) writes macOS ``.icns`` files.  By default, the
+    largest available icon is read, though you can override this by setting the
+    :py:attr:`~PIL.Image.Image.size` property before calling
+    :py:meth:`~PIL.Image.Image.load`.  The :py:meth:`~PIL.Image.Image.write` method
+    sets the following :py:attr:`~PIL.Image.Image.info` property:
+
+    **sizes**
+        A list of supported sizes found in this icon file; these are a
+        3-tuple, ``(width, height, scale)``, where ``scale`` is 2 for a retina
+        icon and 1 for a standard icon.  You *are* permitted to use this 3-tuple
+        format for the :py:attr:`~PIL.Image.Image.size` property if you set it
+        before calling :py:meth:`~PIL.Image.Image.load`; after loading, the size
+        will be reset to a 2-tuple containing pixel dimensions (so, e.g. if you
+        ask for ``(512, 512, 2)``, the final value of
+        :py:attr:`~PIL.Image.Image.size` will be ``(1024, 1024)``).
+    """,
+    "ICO": """*From the Pillow docs:*
+
+
+    ICO is used to store icons on Windows. The largest available icon is read.
+
+    The :py:meth:`~PIL.Image.Image.save` method supports the following options:
+
+    **sizes**
+        A list of sizes including in this ico file; these are a 2-tuple,
+        ``(width, height)``; Default to ``[(16, 16), (24, 24), (32, 32), (48, 48),
+        (64, 64), (128, 128), (256, 256)]``. Any sizes bigger than the original
+        size or 256 will be ignored.
+
+    IM
+    ^^
+
+    IM is a format used by LabEye and other applications based on the IFUNC image
+    processing library. The library reads and writes most uncompressed interchange
+    versions of this format.
+
+    IM is the only format that can store all internal PIL formats.
+    """,
+    "IM": """No docs for IM.""",
+    "IMT": """*From the Pillow docs:*
+
+
+    PIL reads Image Tools images containing ``L`` data.
+    """,
+    "IPTC": """No docs for IPTC.""",
+    "JPEG": """*From the Pillow docs:*
+
+
+    PIL reads JPEG, JFIF, and Adobe JPEG files containing ``L``, ``RGB``, or
+    ``CMYK`` data. It writes standard and progressive JFIF files.
+
+    Using the :py:meth:`~PIL.Image.Image.draft` method, you can speed things up by
+    converting ``RGB`` images to ``L``, and resize images to 1/2, 1/4 or 1/8 of
+    their original size while loading them.
+
+    The :py:meth:`~PIL.Image.Image.write` method may set the following
+    :py:attr:`~PIL.Image.Image.info` properties if available:
+
+    **jfif**
+        JFIF application marker found. If the file is not a JFIF file, this key is
+        not present.
+
+    **jfif_version**
+        A tuple representing the jfif version, (major version, minor version).
+
+    **jfif_density**
+        A tuple representing the pixel density of the image, in units specified
+        by jfif_unit.
+
+    **jfif_unit**
+        Units for the jfif_density:
+
+        * 0 - No Units
+        * 1 - Pixels per Inch
+        * 2 - Pixels per Centimeter
+
+    **dpi**
+        A tuple representing the reported pixel density in pixels per inch, if
+        the file is a jfif file and the units are in inches.
+
+    **adobe**
+        Adobe application marker found. If the file is not an Adobe JPEG file, this
+        key is not present.
+
+    **adobe_transform**
+        Vendor Specific Tag.
+
+    **progression**
+        Indicates that this is a progressive JPEG file.
+
+    **icc_profile**
+        The ICC color profile for the image.
+
+    **exif**
+        Raw EXIF data from the image.
+
+
+    The :py:meth:`~PIL.Image.Image.save` method supports the following options:
+
+    **quality**
+        The image quality, on a scale from 1 (worst) to 95 (best). The default is
+        75. Values above 95 should be avoided; 100 disables portions of the JPEG
+        compression algorithm, and results in large files with hardly any gain in
+        image quality.
+
+    **optimize**
+        If present and true, indicates that the encoder should make an extra pass
+        over the image in order to select optimal encoder settings.
+
+    **progressive**
+        If present and true, indicates that this image should be stored as a
+        progressive JPEG file.
+
+    **dpi**
+        A tuple of integers representing the pixel density, ``(x,y)``.
+
+    **icc_profile**
+        If present and true, the image is stored with the provided ICC profile.
+        If this parameter is not provided, the image will be saved with no profile
+        attached. To preserve the existing profile::
+
+            im.save(filename, 'jpeg', icc_profile=im.info.get('icc_profile'))
+
+    **exif**
+        If present, the image will be stored with the provided raw EXIF data.
+
+    **subsampling**
+        If present, sets the subsampling for the encoder.
+
+        * ``keep``: Only valid for JPEG files, will retain the original image setting.
+        * ``4:4:4``, ``4:2:2``, ``4:2:0``: Specific sampling values
+        * ``-1``: equivalent to ``keep``
+        * ``0``: equivalent to ``4:4:4``
+        * ``1``: equivalent to ``4:2:2``
+        * ``2``: equivalent to ``4:2:0``
+
+    **qtables**
+        If present, sets the qtables for the encoder. This is listed as an
+        advanced option for wizards in the JPEG documentation. Use with
+        caution. ``qtables`` can be one of several types of values:
+
+        *  a string, naming a preset, e.g. ``keep``, ``web_low``, or ``web_high``
+        *  a list, tuple, or dictionary (with integer keys =
+           range(len(keys))) of lists of 64 integers. There must be
+           between 2 and 4 tables.
+
+        .. versionadded:: Pillow  2.5.0
+
+
+    .. note::
+
+        To enable JPEG support, you need to build and install the IJG JPEG library
+        before building the Python Imaging Library. See the distribution README for
+        details.
+    """,
+    "JPEG2000": """*From the Pillow docs:*
+
+
+    .. versionadded:: Pillow  2.4.0
+
+    PIL reads and writes JPEG 2000 files containing ``L``, ``LA``, ``RGB`` or
+    ``RGBA`` data.  It can also read files containing ``YCbCr`` data, which it
+    converts on read into ``RGB`` or ``RGBA`` depending on whether or not there is
+    an alpha channel.  PIL supports JPEG 2000 raw codestreams (``.j2k`` files), as
+    well as boxed JPEG 2000 files (``.j2p`` or ``.jpx`` files).  PIL does *not*
+    support files whose components have different sampling frequencies.
+
+    When loading, if you set the ``mode`` on the image prior to the
+    :py:meth:`~PIL.Image.Image.load` method being invoked, you can ask PIL to
+    convert the image to either ``RGB`` or ``RGBA`` rather than choosing for
+    itself.  It is also possible to set ``reduce`` to the number of resolutions to
+    discard (each one reduces the size of the resulting image by a factor of 2),
+    and ``layers`` to specify the number of quality layers to load.
+
+    The :py:meth:`~PIL.Image.Image.save` method supports the following options:
+
+    **offset**
+        The image offset, as a tuple of integers, e.g. (16, 16)
+
+    **tile_offset**
+        The tile offset, again as a 2-tuple of integers.
+
+    **tile_size**
+        The tile size as a 2-tuple.  If not specified, or if set to None, the
+        image will be saved without tiling.
+
+    **quality_mode**
+        Either `"rates"` or `"dB"` depending on the units you want to use to
+        specify image quality.
+
+    **quality_layers**
+        A sequence of numbers, each of which represents either an approximate size
+        reduction (if quality mode is `"rates"`) or a signal to noise ratio value
+        in decibels.  If not specified, defaults to a single layer of full quality.
+
+    **num_resolutions**
+        The number of different image resolutions to be stored (which corresponds
+        to the number of Discrete Wavelet Transform decompositions plus one).
+
+    **codeblock_size**
+        The code-block size as a 2-tuple.  Minimum size is 4 x 4, maximum is 1024 x
+        1024, with the additional restriction that no code-block may have more
+        than 4096 coefficients (i.e. the product of the two numbers must be no
+        greater than 4096).
+
+    **precinct_size**
+        The precinct size as a 2-tuple.  Must be a power of two along both axes,
+        and must be greater than the code-block size.
+
+    **irreversible**
+        If ``True``, use the lossy Irreversible Color Transformation
+        followed by DWT 9-7.  Defaults to ``False``, which means to use the
+        Reversible Color Transformation with DWT 5-3.
+
+    **progression**
+        Controls the progression order; must be one of ``"LRCP"``, ``"RLCP"``,
+        ``"RPCL"``, ``"PCRL"``, ``"CPRL"``.  The letters stand for Component,
+        Position, Resolution and Layer respectively and control the order of
+        encoding, the idea being that e.g. an image encoded using LRCP mode can
+        have its quality layers decoded as they arrive at the decoder, while one
+        encoded using RLCP mode will have increasing resolutions decoded as they
+        arrive, and so on.
+
+    **cinema_mode**
+        Set the encoder to produce output compliant with the digital cinema
+        specifications.  The options here are ``"no"`` (the default),
+        ``"cinema2k-24"`` for 24fps 2K, ``"cinema2k-48"`` for 48fps 2K, and
+        ``"cinema4k-24"`` for 24fps 4K.  Note that for compliant 2K files,
+        *at least one* of your image dimensions must match 2048 x 1080, while
+        for compliant 4K files, *at least one* of the dimensions must match
+        4096 x 2160.
+
+    .. note::
+
+       To enable JPEG 2000 support, you need to build and install the OpenJPEG
+       library, version 2.0.0 or higher, before building the Python Imaging
+       Library.
+
+       Windows users can install the OpenJPEG binaries available on the
+       OpenJPEG website, but must add them to their PATH in order to use PIL (if
+       you fail to do this, you will get errors about not being able to load the
+       ``_imaging`` DLL).
+    """,
+    "MCIDAS": """*From the Pillow docs:*
+
+
+    PIL identifies and reads 8-bit McIdas area files.
+    """,
+    "MIC": """*From the Pillow docs:*
+
+
+    PIL identifies and reads Microsoft Image Composer (MIC) files. When opened, the
+    first sprite in the file is loaded. You can use :py:meth:`~file.seek` and
+    :py:meth:`~file.tell` to read other sprites from the file.
+
+    Note that there may be an embedded gamma of 2.2 in MIC files.
+    """,
+    "MPEG": """*From the Pillow docs:*
+
+
+    PIL identifies MPEG files.
+    """,
+    "MPO": """*From the Pillow docs:*
+
+
+    Pillow identifies and reads Multi Picture Object (MPO) files, loading the primary
+    image when first opened. The :py:meth:`~file.seek` and :py:meth:`~file.tell`
+    methods may be used to read other pictures from the file. The pictures are
+    zero-indexed and random access is supported.
+    """,
+    "MSP": """*From the Pillow docs:*
+
+
+    PIL identifies and reads MSP files from Windows 1 and 2. The library writes
+    uncompressed (Windows 1) versions of this format.
+    """,
+    "PCD": """*From the Pillow docs:*
+
+
+    PIL reads PhotoCD files containing ``RGB`` data. This only reads the 768x512
+    resolution image from the file. Higher resolutions are encoded in a proprietary
+    encoding.
+    """,
+    "PCX": """*From the Pillow docs:*
+
+
+    PIL reads and writes PCX files containing ``1``, ``L``, ``P``, or ``RGB`` data.
+    """,
+    "PIXAR": """*From the Pillow docs:*
+
+
+    PIL provides limited support for PIXAR raster files. The library can identify
+    and read “dumped” RGB files.
+
+    The format code is ``PIXAR``.
+    """,
+    "PNG": """*From the Pillow docs:*
+
+
+    PIL identifies, reads, and writes PNG files containing ``1``, ``L``, ``P``,
+    ``RGB``, or ``RGBA`` data. Interlaced files are supported as of v1.1.7.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties, when appropriate:
+
+    **chromaticity**
+        The chromaticity points, as an 8 tuple of floats. (``White Point
+        X``, ``White Point Y``, ``Red X``, ``Red Y``, ``Green X``, ``Green
+        Y``, ``Blue X``, ``Blue Y``)
+
+    **gamma**
+        Gamma, given as a floating point number.
+
+    **srgb**
+        The sRGB rendering intent as an integer.
+
+          * 0 Perceptual
+          * 1 Relative Colorimetric
+          * 2 Saturation
+          * 3 Absolute Colorimetric
+
+    **transparency**
+        For ``P`` images: Either the palette index for full transparent pixels,
+        or a byte string with alpha values for each palette entry.
+
+        For ``L`` and ``RGB`` images, the color that represents full transparent
+        pixels in this image.
+
+        This key is omitted if the image is not a transparent palette image.
+
+    ``Open`` also sets ``Image.text`` to a list of the values of the
+    ``tEXt``, ``zTXt``, and ``iTXt`` chunks of the PNG image. Individual
+    compressed chunks are limited to a decompressed size of
+    ``PngImagePlugin.MAX_TEXT_CHUNK``, by default 1MB, to prevent
+    decompression bombs. Additionally, the total size of all of the text
+    chunks is limited to ``PngImagePlugin.MAX_TEXT_MEMORY``, defaulting to
+    64MB.
+
+    The :py:meth:`~PIL.Image.Image.save` method supports the following options:
+
+    **optimize**
+        If present and true, instructs the PNG writer to make the output file as
+        small as possible. This includes extra processing in order to find optimal
+        encoder settings.
+
+    **transparency**
+        For ``P``, ``L``, and ``RGB`` images, this option controls what
+        color image to mark as transparent.
+
+        For ``P`` images, this can be a either the palette index,
+        or a byte string with alpha values for each palette entry.
+
+    **dpi**
+        A tuple of two numbers corresponding to the desired dpi in each direction.
+
+    **pnginfo**
+        A :py:class:`PIL.PngImagePlugin.PngInfo` instance containing text tags.
+
+    **compress_level**
+        ZLIB compression level, a number between 0 and 9: 1 gives best speed,
+        9 gives best compression, 0 gives no compression at all. Default is 6.
+        When ``optimize`` option is True ``compress_level`` has no effect
+        (it is set to 9 regardless of a value passed).
+
+    **icc_profile**
+        The ICC Profile to include in the saved file.
+
+    **bits (experimental)**
+        For ``P`` images, this option controls how many bits to store. If omitted,
+        the PNG writer uses 8 bits (256 colors).
+
+    **dictionary (experimental)**
+        Set the ZLIB encoder dictionary.
+
+    .. note::
+
+        To enable PNG support, you need to build and install the ZLIB compression
+        library before building the Python Imaging Library. See the installation
+        documentation for details.
+    """,
+    "PPM": """*From the Pillow docs:*
+
+
+    PIL reads and writes PBM, PGM and PPM files containing ``1``, ``L`` or ``RGB``
+    data.
+    """,
+    "PSD": """*From the Pillow docs:*
+
+
+    PIL identifies and reads PSD files written by Adobe Photoshop 2.5 and 3.0.
+
+    """,
+    "SGI": """*From the Pillow docs:*
+
+
+    Pillow reads and writes uncompressed ``L``, ``RGB``, and ``RGBA`` files.
+
+    """,
+    "SPIDER": """*From the Pillow docs:*
+
+
+    PIL reads and writes SPIDER image files of 32-bit floating point data
+    ("F;32F").
+
+    PIL also reads SPIDER stack files containing sequences of SPIDER images. The
+    :py:meth:`~file.seek` and :py:meth:`~file.tell` methods are supported, and
+    random access is allowed.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following attributes:
+
+    **format**
+        Set to ``SPIDER``
+
+    **istack**
+        Set to 1 if the file is an image stack, else 0.
+
+    **nimages**
+        Set to the number of images in the stack.
+
+    A convenience method, :py:meth:`~PIL.Image.Image.convert2byte`, is provided for
+    converting floating point data to byte data (mode ``L``)::
+
+        im = Image.open('image001.spi').convert2byte()
+
+    Writing files in SPIDER format
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    The extension of SPIDER files may be any 3 alphanumeric characters. Therefore
+    the output format must be specified explicitly::
+
+        im.save('newimage.spi', format='SPIDER')
+
+    For more information about the SPIDER image processing package, see the
+    `SPIDER homepage`_ at `Wadsworth Center`_.
+
+    .. _SPIDER homepage: https://spider.wadsworth.org/spider_doc/spider/docs/spider.html
+    .. _Wadsworth Center: https://www.wadsworth.org/
+    """,
+    "SUN": """No docs for SUN.""",
+    "TGA": """*From the Pillow docs:*
+
+
+    PIL reads 24- and 32-bit uncompressed and run-length encoded TGA files.
+    """,
+    "TIFF": """*From the Pillow docs:*
+
+
+    Pillow reads and writes TIFF files. It can read both striped and tiled
+    images, pixel and plane interleaved multi-band images. If you have
+    libtiff and its headers installed, PIL can read and write many kinds
+    of compressed TIFF files. If not, PIL will only read and write
+    uncompressed files.
+
+    .. note::
+
+        Beginning in version 5.0.0, Pillow requires libtiff to read or
+        write compressed files. Prior to that release, Pillow had buggy
+        support for reading Packbits, LZW and JPEG compressed TIFFs
+        without using libtiff.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **compression**
+        Compression mode.
+
+        .. versionadded:: Pillow  2.0.0
+
+    **dpi**
+        Image resolution as an ``(xdpi, ydpi)`` tuple, where applicable. You can use
+        the :py:attr:`~PIL.Image.Image.tag` attribute to get more detailed
+        information about the image resolution.
+
+        .. versionadded:: Pillow  1.1.5
+
+    **resolution**
+        Image resolution as an ``(xres, yres)`` tuple, where applicable. This is a
+        measurement in whichever unit is specified by the file.
+
+        .. versionadded:: Pillow  1.1.5
+
+
+    The :py:attr:`~PIL.Image.Image.tag_v2` attribute contains a dictionary
+    of TIFF metadata. The keys are numerical indexes from
+    :py:attr:`~PIL.TiffTags.TAGS_V2`.  Values are strings or numbers for single
+    items, multiple values are returned in a tuple of values. Rational
+    numbers are returned as a :py:class:`~PIL.TiffImagePlugin.IFDRational`
+    object.
+
+        .. versionadded:: Pillow  3.0.0
+
+    For compatibility with legacy code, the
+    :py:attr:`~PIL.Image.Image.tag` attribute contains a dictionary of
+    decoded TIFF fields as returned prior to version 3.0.0.  Values are
+    returned as either strings or tuples of numeric values. Rational
+    numbers are returned as a tuple of ``(numerator, denominator)``.
+
+        .. deprecated:: 3.0.0
+
+
+    Saving Tiff Images
+    ~~~~~~~~~~~~~~~~~~
+
+    The :py:meth:`~PIL.Image.Image.save` method can take the following keyword arguments:
+
+    **save_all**
+        If true, Pillow will save all frames of the image to a multiframe tiff document.
+
+        .. versionadded:: Pillow  3.4.0
+
+    **tiffinfo**
+        A :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v2` object or dict
+        object containing tiff tags and values. The TIFF field type is
+        autodetected for Numeric and string values, any other types
+        require using an :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v2`
+        object and setting the type in
+        :py:attr:`~PIL.TiffImagePlugin.ImageFileDirectory_v2.tagtype` with
+        the appropriate numerical value from
+        ``TiffTags.TYPES``.
+
+        .. versionadded:: Pillow  2.3.0
+
+        Metadata values that are of the rational type should be passed in
+        using a :py:class:`~PIL.TiffImagePlugin.IFDRational` object.
+
+        .. versionadded:: Pillow  3.1.0
+
+        For compatibility with legacy code, a
+        :py:class:`~PIL.TiffImagePlugin.ImageFileDirectory_v1` object may
+        be passed in this field. However, this is deprecated.
+
+        .. versionadded:: Pillow  3.0.0
+
+     .. note::
+
+        Only some tags are currently supported when writing using
+        libtiff. The supported list is found in
+        :py:attr:`~PIL:TiffTags.LIBTIFF_CORE`.
+
+    **compression**
+        A string containing the desired compression method for the
+        file. (valid only with libtiff installed) Valid compression
+        methods are: ``None``, ``"tiff_ccitt"``, ``"group3"``,
+        ``"group4"``, ``"tiff_jpeg"``, ``"tiff_adobe_deflate"``,
+        ``"tiff_thunderscan"``, ``"tiff_deflate"``, ``"tiff_sgilog"``,
+        ``"tiff_sgilog24"``, ``"tiff_raw_16"``
+
+    These arguments to set the tiff header fields are an alternative to
+    using the general tags available through tiffinfo.
+
+    **description**
+
+    **software**
+
+    **date_time**
+
+    **artist**
+
+    **copyright**
+        Strings
+
+    **resolution_unit**
+        A string of "inch", "centimeter" or "cm"
+
+    **resolution**
+
+    **x_resolution**
+
+    **y_resolution**
+
+    **dpi**
+        Either a Float, 2 tuple of (numerator, denominator) or a
+        :py:class:`~PIL.TiffImagePlugin.IFDRational`. Resolution implies
+        an equal x and y resolution, dpi also implies a unit of inches.
+
+    """,
+    "WMF": """*From the Pillow docs:*
+
+
+    PIL can identify playable WMF files.
+
+    In PIL 1.1.4 and earlier, the WMF driver provides some limited rendering
+    support, but not enough to be useful for any real application.
+
+    In PIL 1.1.5 and later, the WMF driver is a stub driver. To add WMF read or
+    write support to your application, use
+    :py:func:`PIL.WmfImagePlugin.register_handler` to register a WMF handler.
+
+    ::
+
+        from PIL import Image
+        from PIL import WmfImagePlugin
+
+        class WmfHandler:
+            def open(self, im):
+                ...
+            def load(self, im):
+                ...
+                return image
+            def save(self, im, fp, filename):
+                ...
+
+        wmf_handler = WmfHandler()
+
+        WmfImagePlugin.register_handler(wmf_handler)
+
+        im = Image.open("sample.wmf")""",
+    "XBM": """*From the Pillow docs:*
+
+
+    PIL reads and writes X bitmap files (mode ``1``).
+    """,
+    "XPM": """*From the Pillow docs:*
+
+
+    PIL reads X pixmap files (mode ``P``) with 256 colors or less.
+
+    The :py:meth:`~PIL.Image.Image.write` method sets the following
+    :py:attr:`~PIL.Image.Image.info` properties:
+
+    **transparency**
+        Transparency color index. This key is omitted if the image is not
+        transparent.
+    """,
+    "XVThumb": """No docs for XVThumb.""",
+}

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/pillow_legacy.py

@@ -0,0 +1,823 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write images using pillow/PIL (legacy).
+
+Backend Library: `Pillow <https://pillow.readthedocs.io/en/stable/>`_
+
+Pillow is a friendly fork of PIL (Python Image Library) and supports
+reading and writing of common formats (jpg, png, gif, tiff, ...). While
+these docs provide an overview of some of its features, pillow is
+constantly improving. Hence, the complete list of features can be found
+in pillows official docs (see the Backend Library link).
+
+Parameters for Reading
+----------------------
+pilmode : str
+    (Available for all formats except GIF-PIL)
+    From the Pillow documentation:
+
+    * 'L' (8-bit pixels, grayscale)
+    * 'P' (8-bit pixels, mapped to any other mode using a color palette)
+    * 'RGB' (3x8-bit pixels, true color)
+    * 'RGBA' (4x8-bit pixels, true color with transparency mask)
+    * 'CMYK' (4x8-bit pixels, color separation)
+    * 'YCbCr' (3x8-bit pixels, color video format)
+    * 'I' (32-bit signed integer pixels)
+    * 'F' (32-bit floating point pixels)
+
+    PIL also provides limited support for a few special modes, including
+    'LA' ('L' with alpha), 'RGBX' (true color with padding) and 'RGBa'
+    (true color with premultiplied alpha).
+
+    When translating a color image to grayscale (mode 'L', 'I' or 'F'),
+    the library uses the ITU-R 601-2 luma transform::
+
+        L = R * 299/1000 + G * 587/1000 + B * 114/1000
+as_gray : bool
+    (Available for all formats except GIF-PIL)
+    If True, the image is converted using mode 'F'. When `mode` is
+    not None and `as_gray` is True, the image is first converted
+    according to `mode`, and the result is then "flattened" using
+    mode 'F'.
+ignoregamma : bool
+    (Only available in PNG-PIL)
+    Avoid gamma correction. Default True.
+exifrotate : bool
+    (Only available in JPEG-PIL)
+    Automatically rotate the image according to exif flag. Default True.
+
+
+Parameters for saving
+---------------------
+optimize : bool
+    (Only available in PNG-PIL)
+    If present and true, instructs the PNG writer to make the output file
+    as small as possible. This includes extra processing in order to find
+    optimal encoder settings.
+transparency:
+    (Only available in PNG-PIL)
+    This option controls what color image to mark as transparent.
+dpi: tuple of two scalars
+    (Only available in PNG-PIL)
+    The desired dpi in each direction.
+pnginfo: PIL.PngImagePlugin.PngInfo
+    (Only available in PNG-PIL)
+    Object containing text tags.
+compress_level: int
+    (Only available in PNG-PIL)
+    ZLIB compression level, a number between 0 and 9: 1 gives best speed,
+    9 gives best compression, 0 gives no compression at all. Default is 9.
+    When ``optimize`` option is True ``compress_level`` has no effect
+    (it is set to 9 regardless of a value passed).
+compression: int
+    (Only available in PNG-PIL)
+    Compatibility with the freeimage PNG format. If given, it overrides
+    compress_level.
+icc_profile:
+    (Only available in PNG-PIL)
+    The ICC Profile to include in the saved file.
+bits (experimental): int
+    (Only available in PNG-PIL)
+    This option controls how many bits to store. If omitted,
+    the PNG writer uses 8 bits (256 colors).
+quantize:
+    (Only available in PNG-PIL)
+    Compatibility with the freeimage PNG format. If given, it overrides
+    bits. In this case, given as a number between 1-256.
+dictionary (experimental): dict
+    (Only available in PNG-PIL)
+    Set the ZLIB encoder dictionary.
+prefer_uint8: bool
+    (Only available in PNG-PIL)
+    Let the PNG writer truncate uint16 image arrays to uint8 if their values fall
+    within the range [0, 255]. Defaults to true for legacy compatibility, however
+    it is recommended to set this to false to avoid unexpected behavior when
+    saving e.g. weakly saturated images.
+
+quality : scalar
+    (Only available in JPEG-PIL)
+    The compression factor of the saved image (1..100), higher
+    numbers result in higher quality but larger file size. Default 75.
+progressive : bool
+    (Only available in JPEG-PIL)
+    Save as a progressive JPEG file (e.g. for images on the web).
+    Default False.
+optimize : bool
+    (Only available in JPEG-PIL)
+    On saving, compute optimal Huffman coding tables (can reduce a few
+    percent of file size). Default False.
+dpi : tuple of int
+    (Only available in JPEG-PIL)
+    The pixel density, ``(x,y)``.
+icc_profile : object
+    (Only available in JPEG-PIL)
+    If present and true, the image is stored with the provided ICC profile.
+    If this parameter is not provided, the image will be saved with no
+    profile attached.
+exif : dict
+    (Only available in JPEG-PIL)
+    If present, the image will be stored with the provided raw EXIF data.
+subsampling : str
+    (Only available in JPEG-PIL)
+    Sets the subsampling for the encoder. See Pillow docs for details.
+qtables : object
+    (Only available in JPEG-PIL)
+    Set the qtables for the encoder. See Pillow docs for details.
+quality_mode : str
+    (Only available in JPEG2000-PIL)
+    Either `"rates"` or `"dB"` depending on the units you want to use to
+    specify image quality.
+quality : float
+    (Only available in JPEG2000-PIL)
+    Approximate size reduction (if quality mode is `rates`) or a signal to noise ratio
+    in decibels (if quality mode is `dB`).
+loop : int
+    (Only available in GIF-PIL)
+    The number of iterations. Default 0 (meaning loop indefinitely).
+duration : {float, list}
+    (Only available in GIF-PIL)
+    The duration (in milliseconds) of each frame. Either specify one value
+    that is used for all frames, or one value for each frame.
+fps : float
+    (Only available in GIF-PIL)
+    The number of frames per second. If duration is not given, the
+    duration for each frame is set to 1/fps. Default 10.
+palettesize : int
+    (Only available in GIF-PIL)
+    The number of colors to quantize the image to. Is rounded to
+    the nearest power of two. Default 256.
+subrectangles : bool
+    (Only available in GIF-PIL)
+    If True, will try and optimize the GIF by storing only the
+    rectangular parts of each frame that change with respect to the
+    previous. Default False.
+
+Notes
+-----
+To enable JPEG 2000 support, you need to build and install the OpenJPEG library,
+version 2.0.0 or higher, before building the Python Imaging Library. Windows
+users can install the OpenJPEG binaries available on the OpenJPEG website, but
+must add them to their PATH in order to use PIL (if you fail to do this, you
+will get errors about not being able to load the ``_imaging`` DLL).
+
+GIF images read with this plugin are always RGBA. The alpha channel is ignored
+when saving RGB images.
+"""
+
+import logging
+import threading
+
+import numpy as np
+
+from ..core import Format, image_as_uint
+from ..core.request import URI_FILE, URI_BYTES
+
+
+logger = logging.getLogger(__name__)
+
+
+# todo: Pillow ImageGrab module supports grabbing the screen on Win and OSX.
+
+
+GENERIC_DOCS = """
+    Parameters for reading
+    ----------------------
+
+    pilmode : str
+        From the Pillow documentation:
+
+        * 'L' (8-bit pixels, grayscale)
+        * 'P' (8-bit pixels, mapped to any other mode using a color palette)
+        * 'RGB' (3x8-bit pixels, true color)
+        * 'RGBA' (4x8-bit pixels, true color with transparency mask)
+        * 'CMYK' (4x8-bit pixels, color separation)
+        * 'YCbCr' (3x8-bit pixels, color video format)
+        * 'I' (32-bit signed integer pixels)
+        * 'F' (32-bit floating point pixels)
+
+        PIL also provides limited support for a few special modes, including
+        'LA' ('L' with alpha), 'RGBX' (true color with padding) and 'RGBa'
+        (true color with premultiplied alpha).
+
+        When translating a color image to grayscale (mode 'L', 'I' or 'F'),
+        the library uses the ITU-R 601-2 luma transform::
+
+            L = R * 299/1000 + G * 587/1000 + B * 114/1000
+    as_gray : bool
+        If True, the image is converted using mode 'F'. When `mode` is
+        not None and `as_gray` is True, the image is first converted
+        according to `mode`, and the result is then "flattened" using
+        mode 'F'.
+"""
+
+
+class PillowFormat(Format):
+    """
+    Base format class for Pillow formats.
+    """
+
+    _pillow_imported = False
+    _Image = None
+    _modes = "i"
+    _description = ""
+
+    def __init__(self, *args, plugin_id: str = None, **kwargs):
+        super(PillowFormat, self).__init__(*args, **kwargs)
+        # Used to synchronize _init_pillow(), see #244
+        self._lock = threading.RLock()
+
+        self._plugin_id = plugin_id
+
+    @property
+    def plugin_id(self):
+        """The PIL plugin id."""
+        return self._plugin_id  # Set when format is created
+
+    def _init_pillow(self):
+        with self._lock:
+            if not self._pillow_imported:
+                self._pillow_imported = True  # more like tried to import
+                import PIL
+
+                if not hasattr(PIL, "__version__"):  # pragma: no cover
+                    raise ImportError(
+                        "Imageio Pillow plugin requires " "Pillow, not PIL!"
+                    )
+                from PIL import Image
+
+                self._Image = Image
+            elif self._Image is None:  # pragma: no cover
+                raise RuntimeError("Imageio Pillow plugin requires " "Pillow lib.")
+            Image = self._Image
+
+        if self.plugin_id in ("PNG", "JPEG", "BMP", "GIF", "PPM"):
+            Image.preinit()
+        else:
+            Image.init()
+        return Image
+
+    def _can_read(self, request):
+        Image = self._init_pillow()
+        if self.plugin_id in Image.OPEN:
+            factory, accept = Image.OPEN[self.plugin_id]
+            if accept:
+                if request.firstbytes and accept(request.firstbytes):
+                    return True
+
+    def _can_write(self, request):
+        Image = self._init_pillow()
+        if request.extension in self.extensions or request._uri_type in [
+            URI_FILE,
+            URI_BYTES,
+        ]:
+            if self.plugin_id in Image.SAVE:
+                return True
+
+    class Reader(Format.Reader):
+        def _open(self, pilmode=None, as_gray=False):
+            Image = self.format._init_pillow()
+            try:
+                factory, accept = Image.OPEN[self.format.plugin_id]
+            except KeyError:
+                raise RuntimeError("Format %s cannot read images." % self.format.name)
+            self._fp = self._get_file()
+            self._im = factory(self._fp, "")
+            if hasattr(Image, "_decompression_bomb_check"):
+                Image._decompression_bomb_check(self._im.size)
+            # Save the raw mode used by the palette for a BMP because it may not be the number of channels
+            # When the data is read, imageio hands the palette to PIL to handle and clears the rawmode argument
+            # However, there is a bug in PIL with handling animated GIFs with a different color palette on each frame.
+            # This issue is resolved by using the raw palette data but the rawmode information is now lost. So we
+            # store the raw mode for later use
+            if self._im.palette and self._im.palette.dirty:
+                self._im.palette.rawmode_saved = self._im.palette.rawmode
+            pil_try_read(self._im)
+            # Store args
+            self._kwargs = dict(
+                as_gray=as_gray, is_gray=_palette_is_grayscale(self._im)
+            )
+            # setting mode=None is not the same as just not providing it
+            if pilmode is not None:
+                self._kwargs["mode"] = pilmode
+            # Set length
+            self._length = 1
+            if hasattr(self._im, "n_frames"):
+                self._length = self._im.n_frames
+
+        def _get_file(self):
+            self._we_own_fp = False
+            return self.request.get_file()
+
+        def _close(self):
+            save_pillow_close(self._im)
+            if self._we_own_fp:
+                self._fp.close()
+            # else: request object handles closing the _fp
+
+        def _get_length(self):
+            return self._length
+
+        def _seek(self, index):
+            try:
+                self._im.seek(index)
+            except EOFError:
+                raise IndexError("Could not seek to index %i" % index)
+
+        def _get_data(self, index):
+            if index >= self._length:
+                raise IndexError("Image index %i > %i" % (index, self._length))
+            i = self._im.tell()
+            if i > index:
+                self._seek(index)  # just try
+            else:
+                while i < index:  # some formats need to be read in sequence
+                    i += 1
+                    self._seek(i)
+            if self._im.palette and self._im.palette.dirty:
+                self._im.palette.rawmode_saved = self._im.palette.rawmode
+            self._im.getdata()[0]
+            im = pil_get_frame(self._im, **self._kwargs)
+            return im, self._im.info
+
+        def _get_meta_data(self, index):
+            if not (index is None or index == 0):
+                raise IndexError()
+            return self._im.info
+
+    class Writer(Format.Writer):
+        def _open(self):
+            Image = self.format._init_pillow()
+            try:
+                self._save_func = Image.SAVE[self.format.plugin_id]
+            except KeyError:
+                raise RuntimeError("Format %s cannot write images." % self.format.name)
+            self._fp = self.request.get_file()
+            self._meta = {}
+            self._written = False
+
+        def _close(self):
+            pass  # request object handled closing _fp
+
+        def _append_data(self, im, meta):
+            if self._written:
+                raise RuntimeError(
+                    "Format %s only supports single images." % self.format.name
+                )
+            # Pop unit dimension for grayscale images
+            if im.ndim == 3 and im.shape[-1] == 1:
+                im = im[:, :, 0]
+            self._written = True
+            self._meta.update(meta)
+            img = ndarray_to_pil(
+                im, self.format.plugin_id, self._meta.pop("prefer_uint8", True)
+            )
+            if "bits" in self._meta:
+                img = img.quantize()  # Make it a P image, so bits arg is used
+            img.save(self._fp, format=self.format.plugin_id, **self._meta)
+            save_pillow_close(img)
+
+        def set_meta_data(self, meta):
+            self._meta.update(meta)
+
+
+class PNGFormat(PillowFormat):
+    """See :mod:`imageio.plugins.pillow_legacy`"""
+
+    class Reader(PillowFormat.Reader):
+        def _open(self, pilmode=None, as_gray=False, ignoregamma=True):
+            return PillowFormat.Reader._open(self, pilmode=pilmode, as_gray=as_gray)
+
+        def _get_data(self, index):
+            im, info = PillowFormat.Reader._get_data(self, index)
+            if not self.request.kwargs.get("ignoregamma", True):
+                # The gamma value in the file represents the gamma factor for the
+                # hardware on the system where the file was created, and is meant
+                # to be able to match the colors with the system on which the
+                # image is shown. See also issue #366
+                try:
+                    gamma = float(info["gamma"])
+                except (KeyError, ValueError):
+                    pass
+                else:
+                    scale = float(65536 if im.dtype == np.uint16 else 255)
+                    gain = 1.0
+                    im[:] = ((im / scale) ** gamma) * scale * gain + 0.4999
+            return im, info
+
+    # --
+
+    class Writer(PillowFormat.Writer):
+        def _open(self, compression=None, quantize=None, interlaced=False, **kwargs):
+            # Better default for compression
+            kwargs["compress_level"] = kwargs.get("compress_level", 9)
+
+            if compression is not None:
+                if compression < 0 or compression > 9:
+                    raise ValueError("Invalid PNG compression level: %r" % compression)
+                kwargs["compress_level"] = compression
+            if quantize is not None:
+                for bits in range(1, 9):
+                    if 2**bits == quantize:
+                        break
+                else:
+                    raise ValueError(
+                        "PNG quantize must be power of two, " "not %r" % quantize
+                    )
+                kwargs["bits"] = bits
+            if interlaced:
+                logger.warning("PIL PNG writer cannot produce interlaced images.")
+
+            ok_keys = (
+                "optimize",
+                "transparency",
+                "dpi",
+                "pnginfo",
+                "bits",
+                "compress_level",
+                "icc_profile",
+                "dictionary",
+                "prefer_uint8",
+            )
+            for key in kwargs:
+                if key not in ok_keys:
+                    raise TypeError("Invalid arg for PNG writer: %r" % key)
+
+            PillowFormat.Writer._open(self)
+            self._meta.update(kwargs)
+
+        def _append_data(self, im, meta):
+            if str(im.dtype) == "uint16" and (im.ndim == 2 or im.shape[-1] == 1):
+                im = image_as_uint(im, bitdepth=16)
+            else:
+                im = image_as_uint(im, bitdepth=8)
+            PillowFormat.Writer._append_data(self, im, meta)
+
+
+class JPEGFormat(PillowFormat):
+    """See :mod:`imageio.plugins.pillow_legacy`"""
+
+    class Reader(PillowFormat.Reader):
+        def _open(self, pilmode=None, as_gray=False, exifrotate=True):
+            return PillowFormat.Reader._open(self, pilmode=pilmode, as_gray=as_gray)
+
+        def _get_file(self):
+            # Pillow uses seek for JPG, so we cannot directly stream from web
+            if self.request.filename.startswith(
+                ("http://", "https://")
+            ) or ".zip/" in self.request.filename.replace("\\", "/"):
+                self._we_own_fp = True
+                return open(self.request.get_local_filename(), "rb")
+            else:
+                self._we_own_fp = False
+                return self.request.get_file()
+
+        def _get_data(self, index):
+            im, info = PillowFormat.Reader._get_data(self, index)
+
+            # Handle exif
+            if "exif" in info:
+                from PIL.ExifTags import TAGS
+
+                info["EXIF_MAIN"] = {}
+                for tag, value in self._im._getexif().items():
+                    decoded = TAGS.get(tag, tag)
+                    info["EXIF_MAIN"][decoded] = value
+
+            im = self._rotate(im, info)
+            return im, info
+
+        def _rotate(self, im, meta):
+            """Use Orientation information from EXIF meta data to
+            orient the image correctly. Similar code as in FreeImage plugin.
+            """
+            if self.request.kwargs.get("exifrotate", True):
+                try:
+                    ori = meta["EXIF_MAIN"]["Orientation"]
+                except KeyError:  # pragma: no cover
+                    pass  # Orientation not available
+                else:  # pragma: no cover - we cannot touch all cases
+                    # www.impulseadventure.com/photo/exif-orientation.html
+                    if ori in [1, 2]:
+                        pass
+                    if ori in [3, 4]:
+                        im = np.rot90(im, 2)
+                    if ori in [5, 6]:
+                        im = np.rot90(im, 3)
+                    if ori in [7, 8]:
+                        im = np.rot90(im)
+                    if ori in [2, 4, 5, 7]:  # Flipped cases (rare)
+                        im = np.fliplr(im)
+            return im
+
+    # --
+
+    class Writer(PillowFormat.Writer):
+        def _open(self, quality=75, progressive=False, optimize=False, **kwargs):
+            # The JPEG quality can be between 0 (worst) and 100 (best)
+            quality = int(quality)
+            if quality < 0 or quality > 100:
+                raise ValueError("JPEG quality should be between 0 and 100.")
+
+            kwargs["quality"] = quality
+            kwargs["progressive"] = bool(progressive)
+            kwargs["optimize"] = bool(progressive)
+
+            PillowFormat.Writer._open(self)
+            self._meta.update(kwargs)
+
+        def _append_data(self, im, meta):
+            if im.ndim == 3 and im.shape[-1] == 4:
+                raise IOError("JPEG does not support alpha channel.")
+            im = image_as_uint(im, bitdepth=8)
+            PillowFormat.Writer._append_data(self, im, meta)
+            return
+
+
+class JPEG2000Format(PillowFormat):
+    """See :mod:`imageio.plugins.pillow_legacy`"""
+
+    class Reader(PillowFormat.Reader):
+        def _open(self, pilmode=None, as_gray=False):
+            return PillowFormat.Reader._open(self, pilmode=pilmode, as_gray=as_gray)
+
+        def _get_file(self):
+            # Pillow uses seek for JPG, so we cannot directly stream from web
+            if self.request.filename.startswith(
+                ("http://", "https://")
+            ) or ".zip/" in self.request.filename.replace("\\", "/"):
+                self._we_own_fp = True
+                return open(self.request.get_local_filename(), "rb")
+            else:
+                self._we_own_fp = False
+                return self.request.get_file()
+
+        def _get_data(self, index):
+            im, info = PillowFormat.Reader._get_data(self, index)
+
+            # Handle exif
+            if "exif" in info:
+                from PIL.ExifTags import TAGS
+
+                info["EXIF_MAIN"] = {}
+                for tag, value in self._im._getexif().items():
+                    decoded = TAGS.get(tag, tag)
+                    info["EXIF_MAIN"][decoded] = value
+
+            im = self._rotate(im, info)
+            return im, info
+
+        def _rotate(self, im, meta):
+            """Use Orientation information from EXIF meta data to
+            orient the image correctly. Similar code as in FreeImage plugin.
+            """
+            if self.request.kwargs.get("exifrotate", True):
+                try:
+                    ori = meta["EXIF_MAIN"]["Orientation"]
+                except KeyError:  # pragma: no cover
+                    pass  # Orientation not available
+                else:  # pragma: no cover - we cannot touch all cases
+                    # www.impulseadventure.com/photo/exif-orientation.html
+                    if ori in [1, 2]:
+                        pass
+                    if ori in [3, 4]:
+                        im = np.rot90(im, 2)
+                    if ori in [5, 6]:
+                        im = np.rot90(im, 3)
+                    if ori in [7, 8]:
+                        im = np.rot90(im)
+                    if ori in [2, 4, 5, 7]:  # Flipped cases (rare)
+                        im = np.fliplr(im)
+            return im
+
+    # --
+
+    class Writer(PillowFormat.Writer):
+        def _open(self, quality_mode="rates", quality=5, **kwargs):
+            # Check quality - in Pillow it should be no higher than 95
+            if quality_mode not in {"rates", "dB"}:
+                raise ValueError("Quality mode should be either 'rates' or 'dB'")
+
+            quality = float(quality)
+
+            if quality_mode == "rates" and (quality < 1 or quality > 1000):
+                raise ValueError(
+                    "The quality value {} seems to be an invalid rate!".format(quality)
+                )
+            elif quality_mode == "dB" and (quality < 15 or quality > 100):
+                raise ValueError(
+                    "The quality value {} seems to be an invalid PSNR!".format(quality)
+                )
+
+            kwargs["quality_mode"] = quality_mode
+            kwargs["quality_layers"] = [quality]
+
+            PillowFormat.Writer._open(self)
+            self._meta.update(kwargs)
+
+        def _append_data(self, im, meta):
+            if im.ndim == 3 and im.shape[-1] == 4:
+                raise IOError(
+                    "The current implementation of JPEG 2000 does not support alpha channel."
+                )
+            im = image_as_uint(im, bitdepth=8)
+            PillowFormat.Writer._append_data(self, im, meta)
+            return
+
+
+def save_pillow_close(im):
+    # see issue #216 and #300
+    if hasattr(im, "close"):
+        if hasattr(getattr(im, "fp", None), "close"):
+            im.close()
+
+
+# Func from skimage
+
+# This cells contains code from scikit-image, in particular from
+# http://github.com/scikit-image/scikit-image/blob/master/
+# skimage/io/_plugins/pil_plugin.py
+# The scikit-image license applies.
+
+
+def pil_try_read(im):
+    try:
+        # this will raise an IOError if the file is not readable
+        im.getdata()[0]
+    except IOError as e:
+        site = "http://pillow.readthedocs.io/en/latest/installation.html"
+        site += "#external-libraries"
+        pillow_error_message = str(e)
+        error_message = (
+            'Could not load "%s" \n'
+            'Reason: "%s"\n'
+            "Please see documentation at: %s"
+            % (im.filename, pillow_error_message, site)
+        )
+        raise ValueError(error_message)
+
+
+def _palette_is_grayscale(pil_image):
+    if pil_image.mode != "P":
+        return False
+    elif pil_image.info.get("transparency", None):  # see issue #475
+        return False
+    # get palette as an array with R, G, B columns
+    # Note: starting in pillow 9.1 palettes may have less than 256 entries
+    palette = np.asarray(pil_image.getpalette()).reshape((-1, 3))
+    # Not all palette colors are used; unused colors have junk values.
+    start, stop = pil_image.getextrema()
+    valid_palette = palette[start : stop + 1]
+    # Image is grayscale if channel differences (R - G and G - B)
+    # are all zero.
+    return np.allclose(np.diff(valid_palette), 0)
+
+
+def pil_get_frame(im, is_gray=None, as_gray=None, mode=None, dtype=None):
+    """
+    is_gray: Whether the image *is* gray (by inspecting its palette).
+    as_gray: Whether the resulting image must be converted to gaey.
+    mode: The mode to convert to.
+    """
+
+    if is_gray is None:
+        is_gray = _palette_is_grayscale(im)
+
+    frame = im
+
+    # Convert ...
+    if mode is not None:
+        # Mode is explicitly given ...
+        if mode != im.mode:
+            frame = im.convert(mode)
+    elif as_gray:
+        pass  # don't do any auto-conversions (but do the explicit one above)
+    elif im.mode == "P" and is_gray:
+        # Paletted images that are already gray by their palette
+        # are converted so that the resulting numpy array is 2D.
+        frame = im.convert("L")
+    elif im.mode == "P":
+        # Paletted images are converted to RGB/RGBA. We jump some loops to make
+        # this work well.
+        if im.info.get("transparency", None) is not None:
+            # Let Pillow apply the transparency, see issue #210 and #246
+            frame = im.convert("RGBA")
+        elif im.palette.mode in ("RGB", "RGBA"):
+            # We can do this ourselves. Pillow seems to sometimes screw
+            # this up if a  multi-gif has a palette for each frame ...
+            # Create palette array
+            p = np.frombuffer(im.palette.getdata()[1], np.uint8)
+            # Restore the raw mode that was saved to be used to parse the palette
+            if hasattr(im.palette, "rawmode_saved"):
+                im.palette.rawmode = im.palette.rawmode_saved
+            mode = im.palette.rawmode if im.palette.rawmode else im.palette.mode
+            nchannels = len(mode)
+            # Shape it.
+            p.shape = -1, nchannels
+            if p.shape[1] == 3 or (p.shape[1] == 4 and mode[-1] == "X"):
+                p = np.column_stack((p[:, :3], 255 * np.ones(p.shape[0], p.dtype)))
+            # Swap the axes if the mode is in BGR and not RGB
+            if mode.startswith("BGR"):
+                p = p[:, [2, 1, 0]] if p.shape[1] == 3 else p[:, [2, 1, 0, 3]]
+            # Apply palette
+            frame_paletted = np.array(im, np.uint8)
+            try:
+                frame = p[frame_paletted]
+            except Exception:
+                # Ok, let PIL do it. The introduction of the branch that
+                # tests `im.info['transparency']` should make this happen
+                # much less often, but let's keep it, to be safe.
+                frame = im.convert("RGBA")
+        else:
+            # Let Pillow do it. Unlinke skimage, we always convert
+            # to RGBA; palettes can be RGBA.
+            if True:  # im.format == 'PNG' and 'transparency' in im.info:
+                frame = im.convert("RGBA")
+            else:
+                frame = im.convert("RGB")
+    elif "A" in im.mode:
+        frame = im.convert("RGBA")
+    elif im.mode == "CMYK":
+        frame = im.convert("RGB")
+    elif im.format == "GIF" and im.mode == "RGB":
+        # pillow9 returns RGBA images for subsequent frames so that it can deal
+        # with multi-frame GIF that use frame-level palettes and don't dispose
+        # all areas.
+
+        # For backwards compatibility, we promote everything to RGBA.
+        frame = im.convert("RGBA")
+
+    # Apply a post-convert if necessary
+    if as_gray:
+        frame = frame.convert("F")  # Scipy compat
+    elif not isinstance(frame, np.ndarray) and frame.mode == "1":
+        # Workaround for crash in PIL. When im is 1-bit, the call array(im)
+        # can cause a segfault, or generate garbage. See
+        # https://github.com/scipy/scipy/issues/2138 and
+        # https://github.com/python-pillow/Pillow/issues/350.
+        #
+        # This converts im from a 1-bit image to an 8-bit image.
+        frame = frame.convert("L")
+
+    # Convert to numpy array
+    if im.mode.startswith("I;16"):
+        # e.g. in16 PNG's
+        shape = im.size
+        dtype = ">u2" if im.mode.endswith("B") else "<u2"
+        if "S" in im.mode:
+            dtype = dtype.replace("u", "i")
+        frame = np.frombuffer(frame.tobytes(), dtype).copy()
+        frame.shape = shape[::-1]
+    else:
+        # Use uint16 for PNG's in mode I
+        if im.format == "PNG" and im.mode == "I" and dtype is None:
+            dtype = "uint16"
+        frame = np.array(frame, dtype=dtype)
+
+    return frame
+
+
+def ndarray_to_pil(arr, format_str=None, prefer_uint8=True):
+    from PIL import Image
+
+    if arr.ndim == 3:
+        arr = image_as_uint(arr, bitdepth=8)
+        mode = {3: "RGB", 4: "RGBA"}[arr.shape[2]]
+
+    elif format_str in ["png", "PNG"]:
+        mode = "I;16"
+        mode_base = "I"
+
+        if arr.dtype.kind == "f":
+            arr = image_as_uint(arr)
+
+        elif prefer_uint8 and arr.max() < 256 and arr.min() >= 0:
+            arr = arr.astype(np.uint8)
+            mode = mode_base = "L"
+
+        else:
+            arr = image_as_uint(arr, bitdepth=16)
+
+    else:
+        arr = image_as_uint(arr, bitdepth=8)
+        mode = "L"
+        mode_base = "L"
+
+    if mode == "I;16" and int(getattr(Image, "__version__", "0").split(".")[0]) < 6:
+        # Pillow < v6.0.0 has limited support for the "I;16" mode,
+        # requiring us to fall back to this expensive workaround.
+        # tobytes actually creates a copy of the image, which is costly.
+        array_buffer = arr.tobytes()
+        if arr.ndim == 2:
+            im = Image.new(mode_base, arr.T.shape)
+            im.frombytes(array_buffer, "raw", mode)
+        else:
+            image_shape = (arr.shape[1], arr.shape[0])
+            im = Image.frombytes(mode, image_shape, array_buffer)
+        return im
+    else:
+        return Image.fromarray(arr, mode)
+
+
+# imported for backwards compatibility
+from .pillowmulti import GIFFormat, TIFFFormat  # noqa: E402, F401

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/simpleitk.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write images using SimpleITK.
+
+Backend: `Insight Toolkit <https://itk.org/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[itk]
+
+The ItkFormat uses the ITK or SimpleITK library to support a range of
+ITK-related formats. It also supports a few common formats (e.g. PNG and JPEG).
+
+Parameters
+----------
+None
+
+"""
+
+from ..core import Format, has_module
+
+_itk = None  # Defer loading to load_lib() function.
+
+
+def load_lib():
+    global _itk, _read_function, _write_function
+    try:
+        import itk as _itk
+
+        _read_function = _itk.imread
+        _write_function = _itk.imwrite
+    except ImportError:
+        try:
+            import SimpleITK as _itk
+
+            _read_function = _itk.ReadImage
+            _write_function = _itk.WriteImage
+        except ImportError:
+            raise ImportError(
+                "itk could not be found. "
+                "Please try "
+                "  python -m pip install itk "
+                "or "
+                "  python -m pip install simpleitk "
+                "or refer to "
+                "  https://itkpythonpackage.readthedocs.io/ "
+                "for further instructions."
+            )
+    return _itk
+
+
+# Split up in real ITK and all supported formats.
+ITK_FORMATS = (
+    ".gipl",
+    ".ipl",
+    ".mha",
+    ".mhd",
+    ".nhdr",
+    "nia",
+    "hdr",
+    ".nrrd",
+    ".nii",
+    ".nii.gz",
+    ".img",
+    ".img.gz",
+    ".vtk",
+    "hdf5",
+    "lsm",
+    "mnc",
+    "mnc2",
+    "mgh",
+    "mnc",
+    "pic",
+)
+ALL_FORMATS = ITK_FORMATS + (
+    ".bmp",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".tiff",
+    ".tif",
+    ".dicom",
+    ".dcm",
+    ".gdcm",
+)
+
+
+class ItkFormat(Format):
+    """See :mod:`imageio.plugins.simpleitk`"""
+
+    def _can_read(self, request):
+        # If the request is a format that only this plugin can handle,
+        # we report that we can do it; a useful error will be raised
+        # when simpleitk is not installed. For the more common formats
+        # we only report that we can read if the library is installed.
+        if request.extension in ITK_FORMATS:
+            return True
+        if has_module("itk.ImageIOBase") or has_module("SimpleITK"):
+            return request.extension in ALL_FORMATS
+
+    def _can_write(self, request):
+        if request.extension in ITK_FORMATS:
+            return True
+        if has_module("itk.ImageIOBase") or has_module("SimpleITK"):
+            return request.extension in ALL_FORMATS
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, pixel_type=None, fallback_only=None, **kwargs):
+            if not _itk:
+                load_lib()
+            args = ()
+            if pixel_type is not None:
+                args += (pixel_type,)
+                if fallback_only is not None:
+                    args += (fallback_only,)
+            self._img = _read_function(self.request.get_local_filename(), *args)
+
+        def _get_length(self):
+            return 1
+
+        def _close(self):
+            pass
+
+        def _get_data(self, index):
+            # Get data
+            if index != 0:
+                error_msg = "Index out of range while reading from itk file"
+                raise IndexError(error_msg)
+
+            # Return array and empty meta data
+            return _itk.GetArrayFromImage(self._img), {}
+
+        def _get_meta_data(self, index):
+            error_msg = "The itk plugin does not support meta data, currently."
+            raise RuntimeError(error_msg)
+
+    # -- writer
+    class Writer(Format.Writer):
+        def _open(self):
+            if not _itk:
+                load_lib()
+
+        def _close(self):
+            pass
+
+        def _append_data(self, im, meta):
+            _itk_img = _itk.GetImageFromArray(im)
+            _write_function(_itk_img, self.request.get_local_filename())
+
+        def set_meta_data(self, meta):
+            error_msg = "The itk plugin does not support meta data, currently."
+            raise RuntimeError(error_msg)

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/swf.py

@@ -0,0 +1,336 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write SWF files.
+
+Backend: internal
+
+Shockwave flash (SWF) is a media format designed for rich and
+interactive animations. This plugin makes use of this format to
+store a series of images in a lossless format with good compression
+(zlib). The resulting images can be shown as an animation using
+a flash player (such as the browser).
+
+SWF stores images in RGBA format. RGB or grayscale images are
+automatically converted. SWF does not support meta data.
+
+Parameters for reading
+----------------------
+loop : bool
+    If True, the video will rewind as soon as a frame is requested
+    beyond the last frame. Otherwise, IndexError is raised. Default False.
+
+Parameters for saving
+---------------------
+fps : int
+    The speed to play the animation. Default 12.
+loop : bool
+    If True, add a tag to the end of the file to play again from
+    the first frame. Most flash players will then play the movie
+    in a loop. Note that the imageio SWF Reader does not check this
+    tag. Default True.
+html : bool
+    If the output is a file on the file system, write an html file
+    (in HTML5) that shows the animation. Default False.
+compress : bool
+    Whether to compress the swf file. Default False. You probably don't
+    want to use this. This does not decrease the file size since
+    the images are already compressed. It will result in slower
+    read and write time. The only purpose of this feature is to
+    create compressed SWF files, so that we can test the
+    functionality to read them.
+
+"""
+
+import os
+import zlib
+import logging
+from io import BytesIO
+
+import numpy as np
+
+from ..core import Format, read_n_bytes, image_as_uint
+
+
+logger = logging.getLogger(__name__)
+
+_swf = None  # lazily loaded in lib()
+
+
+def load_lib():
+    global _swf
+    from . import _swf
+
+    return _swf
+
+
+class SWFFormat(Format):
+    """See :mod:`imageio.plugins.swf`"""
+
+    def _can_read(self, request):
+        tmp = request.firstbytes[0:3].decode("ascii", "ignore")
+        if tmp in ("FWS", "CWS"):
+            return True
+
+    def _can_write(self, request):
+        if request.extension in self.extensions:
+            return True
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, loop=False):
+            if not _swf:
+                load_lib()
+
+            self._arg_loop = bool(loop)
+
+            self._fp = self.request.get_file()
+
+            # Check file ...
+            tmp = self.request.firstbytes[0:3].decode("ascii", "ignore")
+            if tmp == "FWS":
+                pass  # OK
+            elif tmp == "CWS":
+                # Compressed, we need to decompress
+                bb = self._fp.read()
+                bb = bb[:8] + zlib.decompress(bb[8:])
+                # Wrap up in a file object
+                self._fp = BytesIO(bb)
+            else:
+                raise IOError("This does not look like a valid SWF file")
+
+            # Skip first bytes. This also tests support got seeking ...
+            try:
+                self._fp.seek(8)
+                self._streaming_mode = False
+            except Exception:
+                self._streaming_mode = True
+                self._fp_read(8)
+
+            # Skip header
+            # Note that the number of frames is there, which we could
+            # potentially use, but the number of frames does not necessarily
+            # correspond to the number of images.
+            nbits = _swf.bits2int(self._fp_read(1), 5)
+            nbits = 5 + nbits * 4
+            Lrect = nbits / 8.0
+            if Lrect % 1:
+                Lrect += 1
+            Lrect = int(Lrect)
+            self._fp_read(Lrect + 3)
+
+            # Now the rest is basically tags ...
+            self._imlocs = []  # tuple (loc, sze, T, L1)
+            if not self._streaming_mode:
+                # Collect locations of frame, while skipping through the data
+                # This does not read any of the tag *data*.
+                try:
+                    while True:
+                        isimage, sze, T, L1 = self._read_one_tag()
+                        loc = self._fp.tell()
+                        if isimage:
+                            # Still need to check if the format is right
+                            format = ord(self._fp_read(3)[2:])
+                            if format == 5:  # RGB or RGBA lossless
+                                self._imlocs.append((loc, sze, T, L1))
+                        self._fp.seek(loc + sze)  # Skip over tag
+                except IndexError:
+                    pass  # done reading
+
+        def _fp_read(self, n):
+            return read_n_bytes(self._fp, n)
+
+        def _close(self):
+            pass
+
+        def _get_length(self):
+            if self._streaming_mode:
+                return np.inf
+            else:
+                return len(self._imlocs)
+
+        def _get_data(self, index):
+            # Check index
+            if index < 0:
+                raise IndexError("Index in swf file must be > 0")
+            if not self._streaming_mode:
+                if self._arg_loop and self._imlocs:
+                    index = index % len(self._imlocs)
+                if index >= len(self._imlocs):
+                    raise IndexError("Index out of bounds")
+
+            if self._streaming_mode:
+                # Walk over tags until we find an image
+                while True:
+                    isimage, sze, T, L1 = self._read_one_tag()
+                    bb = self._fp_read(sze)  # always read data
+                    if isimage:
+                        im = _swf.read_pixels(bb, 0, T, L1)  # can be None
+                        if im is not None:
+                            return im, {}
+
+            else:
+                # Go to corresponding location, read data, and convert to image
+                loc, sze, T, L1 = self._imlocs[index]
+                self._fp.seek(loc)
+                bb = self._fp_read(sze)
+                # Read_pixels should return ndarry, since we checked format
+                im = _swf.read_pixels(bb, 0, T, L1)
+                return im, {}
+
+        def _read_one_tag(self):
+            """
+            Return (True, loc, size, T, L1) if an image that we can read.
+            Return (False, loc, size, T, L1) if any other tag.
+            """
+
+            # Get head
+            head = self._fp_read(6)
+            if not head:  # pragma: no cover
+                raise IndexError("Reached end of swf movie")
+
+            # Determine type and length
+            T, L1, L2 = _swf.get_type_and_len(head)
+            if not L2:  # pragma: no cover
+                raise RuntimeError("Invalid tag length, could not proceed")
+
+            # Read data
+            isimage = False
+            sze = L2 - 6
+            # bb = self._fp_read(L2 - 6)
+
+            # Parse tag
+            if T == 0:
+                raise IndexError("Reached end of swf movie")
+            elif T in [20, 36]:
+                isimage = True
+                # im = _swf.read_pixels(bb, 0, T, L1)  # can be None
+            elif T in [6, 21, 35, 90]:  # pragma: no cover
+                logger.warning("Ignoring JPEG image: cannot read JPEG.")
+            else:
+                pass  # Not an image tag
+
+            # Done.  Return image. Can be None
+            # return im
+            return isimage, sze, T, L1
+
+        def _get_meta_data(self, index):
+            return {}  # This format does not support meta data
+
+    # -- writer
+
+    class Writer(Format.Writer):
+        def _open(self, fps=12, loop=True, html=False, compress=False):
+            if not _swf:
+                load_lib()
+
+            self._arg_fps = int(fps)
+            self._arg_loop = bool(loop)
+            self._arg_html = bool(html)
+            self._arg_compress = bool(compress)
+
+            self._fp = self.request.get_file()
+            self._framecounter = 0
+            self._framesize = (100, 100)
+
+            # For compress, we use an in-memory file object
+            if self._arg_compress:
+                self._fp_real = self._fp
+                self._fp = BytesIO()
+
+        def _close(self):
+            self._complete()
+            # Get size of (uncompressed) file
+            sze = self._fp.tell()
+            # set nframes, this is in the potentially compressed region
+            self._fp.seek(self._location_to_save_nframes)
+            self._fp.write(_swf.int2uint16(self._framecounter))
+            # Compress body?
+            if self._arg_compress:
+                bb = self._fp.getvalue()
+                self._fp = self._fp_real
+                self._fp.write(bb[:8])
+                self._fp.write(zlib.compress(bb[8:]))
+                sze = self._fp.tell()  # renew sze value
+            # set size
+            self._fp.seek(4)
+            self._fp.write(_swf.int2uint32(sze))
+            self._fp = None  # Disable
+
+            # Write html?
+            if self._arg_html and os.path.isfile(self.request.filename):
+                dirname, fname = os.path.split(self.request.filename)
+                filename = os.path.join(dirname, fname[:-4] + ".html")
+                w, h = self._framesize
+                html = HTML % (fname, w, h, fname)
+                with open(filename, "wb") as f:
+                    f.write(html.encode("utf-8"))
+
+        def _write_header(self, framesize, fps):
+            self._framesize = framesize
+            # Called as soon as we know framesize; when we get first frame
+            bb = b""
+            bb += "FC"[self._arg_compress].encode("ascii")
+            bb += "WS".encode("ascii")  # signature bytes
+            bb += _swf.int2uint8(8)  # version
+            bb += "0000".encode("ascii")  # FileLength (leave open for now)
+            bb += (
+                _swf.Tag().make_rect_record(0, framesize[0], 0, framesize[1]).tobytes()
+            )
+            bb += _swf.int2uint8(0) + _swf.int2uint8(fps)  # FrameRate
+            self._location_to_save_nframes = len(bb)
+            bb += "00".encode("ascii")  # nframes (leave open for now)
+            self._fp.write(bb)
+
+            # Write some initial tags
+            taglist = _swf.FileAttributesTag(), _swf.SetBackgroundTag(0, 0, 0)
+            for tag in taglist:
+                self._fp.write(tag.get_tag())
+
+        def _complete(self):
+            # What if no images were saved?
+            if not self._framecounter:
+                self._write_header((10, 10), self._arg_fps)
+            # Write stop tag if we do not loop
+            if not self._arg_loop:
+                self._fp.write(_swf.DoActionTag("stop").get_tag())
+            # finish with end tag
+            self._fp.write("\x00\x00".encode("ascii"))
+
+        def _append_data(self, im, meta):
+            # Correct shape and type
+            if im.ndim == 3 and im.shape[-1] == 1:
+                im = im[:, :, 0]
+            im = image_as_uint(im, bitdepth=8)
+            # Get frame size
+            wh = im.shape[1], im.shape[0]
+            # Write header on first frame
+            isfirstframe = False
+            if self._framecounter == 0:
+                isfirstframe = True
+                self._write_header(wh, self._arg_fps)
+            # Create tags
+            bm = _swf.BitmapTag(im)
+            sh = _swf.ShapeTag(bm.id, (0, 0), wh)
+            po = _swf.PlaceObjectTag(1, sh.id, move=(not isfirstframe))
+            sf = _swf.ShowFrameTag()
+            # Write tags
+            for tag in [bm, sh, po, sf]:
+                self._fp.write(tag.get_tag())
+            self._framecounter += 1
+
+        def set_meta_data(self, meta):
+            pass
+
+
+HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Show Flash animation %s</title>
+</head>
+<body>
+    <embed width="%i" height="%i" src="%s">
+</html>
+"""

evalkit_tf437/lib/python3.10/site-packages/imageio/plugins/tifffile.py

@@ -0,0 +1,561 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write TIFF files.
+
+Backend: internal
+
+Provides support for a wide range of Tiff images using the tifffile
+backend.
+
+Parameters for reading
+----------------------
+offset : int
+    Optional start position of embedded file. By default this is
+    the current file position.
+size : int
+    Optional size of embedded file. By default this is the number
+    of bytes from the 'offset' to the end of the file.
+multifile : bool
+    If True (default), series may include pages from multiple files.
+    Currently applies to OME-TIFF only.
+multifile_close : bool
+    If True (default), keep the handles of other files in multifile
+    series closed. This is inefficient when few files refer to
+    many pages. If False, the C runtime may run out of resources.
+
+Parameters for saving
+---------------------
+bigtiff : bool
+    If True, the BigTIFF format is used.
+byteorder : {'<', '>'}
+    The endianness of the data in the file.
+    By default this is the system's native byte order.
+software : str
+    Name of the software used to create the image.
+    Saved with the first page only.
+
+Metadata for reading
+--------------------
+planar_configuration : {'contig', 'planar'}
+    Specifies if samples are stored contiguous or in separate planes.
+    By default this setting is inferred from the data shape.
+    'contig': last dimension contains samples.
+    'planar': third last dimension contains samples.
+resolution_unit : int
+    The resolution unit stored in the TIFF tag. Usually 1 means no/unknown unit,
+    2 means dpi (inch), 3 means dpc (centimeter).
+resolution : (float, float, str)
+    A tuple formatted as (X_resolution, Y_resolution, unit). The unit is a
+    string representing one of the following units::
+
+        NONE        # No unit or unit unknown
+        INCH        # dpi
+        CENTIMETER  # cpi
+        MILLIMETER
+        MICROMETER
+
+compression : int
+    Value indicating the compression algorithm used, e.g. 5 is LZW,
+    7 is JPEG, 8 is deflate.
+    If 1, data are uncompressed.
+predictor : int
+    Value 2 indicates horizontal differencing was used before compression,
+    while 3 indicates floating point horizontal differencing.
+    If 1, no prediction scheme was used before compression.
+orientation : {'top_left', 'bottom_right', ...}
+    Oriented of image array.
+is_rgb : bool
+    True if page contains a RGB image.
+is_contig : bool
+    True if page contains a contiguous image.
+is_tiled : bool
+    True if page contains tiled image.
+is_palette : bool
+    True if page contains a palette-colored image and not OME or STK.
+is_reduced : bool
+    True if page is a reduced image of another image.
+is_shaped : bool
+    True if page contains shape in image_description tag.
+is_fluoview : bool
+    True if page contains FluoView MM_STAMP tag.
+is_nih : bool
+    True if page contains NIH image header.
+is_micromanager : bool
+    True if page contains Micro-Manager metadata.
+is_ome : bool
+    True if page contains OME-XML in image_description tag.
+is_sgi : bool
+    True if page contains SGI image and tile depth tags.
+is_mdgel : bool
+    True if page contains md_file_tag tag.
+is_mediacy : bool
+    True if page contains Media Cybernetics Id tag.
+is_stk : bool
+    True if page contains UIC2Tag tag.
+is_lsm : bool
+    True if page contains LSM CZ_LSM_INFO tag.
+description : str
+    Image description
+description1 : str
+    Additional description
+is_imagej : None or str
+    ImageJ metadata
+software : str
+    Software used to create the TIFF file
+datetime : datetime.datetime
+    Creation date and time
+
+Metadata for writing
+--------------------
+photometric : {'minisblack', 'miniswhite', 'rgb'}
+    The color space of the image data.
+    By default this setting is inferred from the data shape.
+planarconfig : {'contig', 'planar'}
+    Specifies if samples are stored contiguous or in separate planes.
+    By default this setting is inferred from the data shape.
+    'contig': last dimension contains samples.
+    'planar': third last dimension contains samples.
+resolution : (float, float) or ((int, int), (int, int))
+    X and Y resolution in dots per inch as float or rational numbers.
+description : str
+    The subject of the image. Saved with the first page only.
+compress : int
+    Values from 0 to 9 controlling the level of zlib (deflate) compression.
+    If 0, data are written uncompressed (default).
+compression : str, (int, int)
+    Compression scheme used while writing the image. If omitted (default) the
+    image is not uncompressed. Compression cannot be used to write contiguous
+    series. Compressors may require certain data shapes, types or value ranges.
+    For example, JPEG compression requires grayscale or RGB(A), uint8 or 12-bit
+    uint16. JPEG compression is experimental. JPEG markers and TIFF tags may not
+    match. Only a limited set of compression schemes are implemented. 'ZLIB' is
+    short for ADOBE_DEFLATE. The value is written to the Compression tag.
+compressionargs:
+    Extra arguments passed to compression codec, e.g., compression level. Refer
+    to the Imagecodecs implementation for supported arguments.
+predictor : bool
+    If True, horizontal differencing is applied before compression.
+    Note that using an int literal 1 actually means no prediction scheme
+    will be used.
+volume : bool
+    If True, volume data are stored in one tile (if applicable) using
+    the SGI image_depth and tile_depth tags.
+    Image width and depth must be multiple of 16.
+    Few software can read this format, e.g. MeVisLab.
+writeshape : bool
+    If True, write the data shape to the image_description tag
+    if necessary and no other description is given.
+extratags: sequence of tuples
+    Additional tags as [(code, dtype, count, value, writeonce)].
+
+    code : int
+        The TIFF tag Id.
+    dtype : str
+        Data type of items in 'value' in Python struct format.
+        One of B, s, H, I, 2I, b, h, i, f, d, Q, or q.
+    count : int
+        Number of data values. Not used for string values.
+    value : sequence
+        'Count' values compatible with 'dtype'.
+    writeonce : bool
+        If True, the tag is written to the first page only.
+
+Notes
+-----
+Global metadata is stored with the first frame in a TIFF file.
+Thus calling :py:meth:`Format.Writer.set_meta_data` after the first frame
+was written has no effect. Also, global metadata is ignored if metadata is
+provided via the `meta` argument of :py:meth:`Format.Writer.append_data`.
+
+If you have installed tifffile as a Python package, imageio will attempt
+to use that as backend instead of the bundled backend. Doing so can
+provide access to new performance improvements and bug fixes.
+
+"""
+
+import datetime
+
+from ..core import Format
+from ..core.request import URI_BYTES, URI_FILE
+
+import numpy as np
+import warnings
+
+
+try:
+    import tifffile as _tifffile
+except ImportError:
+    warnings.warn(
+        "ImageIO's vendored tifffile backend is deprecated and will be"
+        " removed in ImageIO v3. Install the tifffile directly:"
+        " `pip install imageio[tifffile]`",
+        DeprecationWarning,
+    )
+    from . import _tifffile
+
+
+TIFF_FORMATS = (".tif", ".tiff", ".stk", ".lsm")
+WRITE_METADATA_KEYS = (
+    "photometric",
+    "planarconfig",
+    "resolution",
+    "description",
+    "compress",
+    "compression",
+    "compressionargs",
+    "predictor",
+    "volume",
+    "writeshape",
+    "extratags",
+    "datetime",
+)
+READ_METADATA_KEYS = (
+    "planar_configuration",
+    "is_fluoview",
+    "is_nih",
+    "is_contig",
+    "is_micromanager",
+    "is_ome",
+    "is_lsm",
+    "is_palette",
+    "is_reduced",
+    "is_rgb",
+    "is_sgi",
+    "is_shaped",
+    "is_stk",
+    "is_tiled",
+    "is_mdgel",
+    "resolution_unit",
+    "compression",
+    "predictor",
+    "is_mediacy",
+    "orientation",
+    "description",
+    "description1",
+    "is_imagej",
+    "software",
+)
+
+
+class TiffFormat(Format):
+    """Provides support for a wide range of Tiff images using the tifffile
+    backend.
+
+    Images that contain multiple pages can be read using ``imageio.mimread()``
+    to read the individual pages, or ``imageio.volread()`` to obtain a
+    single (higher dimensional) array.
+
+    Note that global metadata is stored with the first frame in a TIFF file.
+    Thus calling :py:meth:`Format.Writer.set_meta_data` after the first frame
+    was written has no effect. Also, global metadata is ignored if metadata is
+    provided via the `meta` argument of :py:meth:`Format.Writer.append_data`.
+
+    If you have installed tifffile as a Python package, imageio will attempt
+    to use that as backend instead of the bundled backend. Doing so can
+    provide access to new performance improvements and bug fixes.
+
+    Parameters for reading
+    ----------------------
+    offset : int
+        Optional start position of embedded file. By default this is
+        the current file position.
+    size : int
+        Optional size of embedded file. By default this is the number
+        of bytes from the 'offset' to the end of the file.
+    multifile : bool
+        If True (default), series may include pages from multiple files.
+        Currently applies to OME-TIFF only.
+    multifile_close : bool
+        If True (default), keep the handles of other files in multifile
+        series closed. This is inefficient when few files refer to
+        many pages. If False, the C runtime may run out of resources.
+
+    Parameters for saving
+    ---------------------
+    bigtiff : bool
+        If True, the BigTIFF format is used.
+    byteorder : {'<', '>'}
+        The endianness of the data in the file.
+        By default this is the system's native byte order.
+    software : str
+        Name of the software used to create the image.
+        Saved with the first page only.
+
+    Metadata for reading
+    --------------------
+    planar_configuration : {'contig', 'planar'}
+        Specifies if samples are stored contiguous or in separate planes.
+        By default this setting is inferred from the data shape.
+        'contig': last dimension contains samples.
+        'planar': third last dimension contains samples.
+    resolution_unit : (float, float) or ((int, int), (int, int))
+        X and Y resolution in dots per inch as float or rational numbers.
+    compression : int
+        Value indicating the compression algorithm used, e.g. 5 is LZW,
+        7 is JPEG, 8 is deflate.
+        If 1, data are uncompressed.
+    predictor : int
+        Value 2 indicates horizontal differencing was used before compression,
+        while 3 indicates floating point horizontal differencing.
+        If 1, no prediction scheme was used before compression.
+    orientation : {'top_left', 'bottom_right', ...}
+        Oriented of image array.
+    is_rgb : bool
+        True if page contains a RGB image.
+    is_contig : bool
+        True if page contains a contiguous image.
+    is_tiled : bool
+        True if page contains tiled image.
+    is_palette : bool
+        True if page contains a palette-colored image and not OME or STK.
+    is_reduced : bool
+        True if page is a reduced image of another image.
+    is_shaped : bool
+        True if page contains shape in image_description tag.
+    is_fluoview : bool
+        True if page contains FluoView MM_STAMP tag.
+    is_nih : bool
+        True if page contains NIH image header.
+    is_micromanager : bool
+        True if page contains Micro-Manager metadata.
+    is_ome : bool
+        True if page contains OME-XML in image_description tag.
+    is_sgi : bool
+        True if page contains SGI image and tile depth tags.
+    is_stk : bool
+        True if page contains UIC2Tag tag.
+    is_mdgel : bool
+        True if page contains md_file_tag tag.
+    is_mediacy : bool
+        True if page contains Media Cybernetics Id tag.
+    is_stk : bool
+        True if page contains UIC2Tag tag.
+    is_lsm : bool
+        True if page contains LSM CZ_LSM_INFO tag.
+    description : str
+        Image description
+    description1 : str
+        Additional description
+    is_imagej : None or str
+        ImageJ metadata
+    software : str
+        Software used to create the TIFF file
+    datetime : datetime.datetime
+        Creation date and time
+
+    Metadata for writing
+    --------------------
+    photometric : {'minisblack', 'miniswhite', 'rgb'}
+        The color space of the image data.
+        By default this setting is inferred from the data shape.
+    planarconfig : {'contig', 'planar'}
+        Specifies if samples are stored contiguous or in separate planes.
+        By default this setting is inferred from the data shape.
+        'contig': last dimension contains samples.
+        'planar': third last dimension contains samples.
+    resolution : (float, float) or ((int, int), (int, int))
+        X and Y resolution in dots per inch as float or rational numbers.
+    description : str
+        The subject of the image. Saved with the first page only.
+    compress : int
+        Values from 0 to 9 controlling the level of zlib (deflate) compression.
+        If 0, data are written uncompressed (default).
+    predictor : bool
+        If True, horizontal differencing is applied before compression.
+        Note that using an int literal 1 actually means no prediction scheme
+        will be used.
+    volume : bool
+        If True, volume data are stored in one tile (if applicable) using
+        the SGI image_depth and tile_depth tags.
+        Image width and depth must be multiple of 16.
+        Few software can read this format, e.g. MeVisLab.
+    writeshape : bool
+        If True, write the data shape to the image_description tag
+        if necessary and no other description is given.
+    extratags: sequence of tuples
+        Additional tags as [(code, dtype, count, value, writeonce)].
+
+        code : int
+            The TIFF tag Id.
+        dtype : str
+            Data type of items in 'value' in Python struct format.
+            One of B, s, H, I, 2I, b, h, i, f, d, Q, or q.
+        count : int
+            Number of data values. Not used for string values.
+        value : sequence
+            'Count' values compatible with 'dtype'.
+        writeonce : bool
+            If True, the tag is written to the first page only.
+    """
+
+    def _can_read(self, request):
+        try:
+            _tifffile.TiffFile(request.get_file(), **request.kwargs)
+        except ValueError:
+            # vendored backend raises value exception
+            return False
+        except _tifffile.TiffFileError:  # pragma: no-cover
+            # current version raises custom exception
+            return False
+        finally:
+            request.get_file().seek(0)
+
+        return True
+
+    def _can_write(self, request):
+        if request._uri_type in [URI_FILE, URI_BYTES]:
+            pass  # special URI
+        elif request.extension not in self.extensions:
+            return False
+
+        try:
+            _tifffile.TiffWriter(request.get_file(), **request.kwargs)
+        except ValueError:
+            # vendored backend raises value exception
+            return False
+        except _tifffile.TiffFileError:  # pragma: no-cover
+            # current version raises custom exception
+            return False
+        finally:
+            request.get_file().seek(0)
+        return True
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, **kwargs):
+            # Allow loading from http; tifffile uses seek, so download first
+            if self.request.filename.startswith(("http://", "https://")):
+                self._f = f = open(self.request.get_local_filename(), "rb")
+            else:
+                self._f = None
+                f = self.request.get_file()
+            self._tf = _tifffile.TiffFile(f, **kwargs)
+
+        def _close(self):
+            self._tf.close()
+            if self._f is not None:
+                self._f.close()
+
+        def _get_length(self):
+            return len(self._tf.series)
+
+        def _get_data(self, index):
+            if index < 0 or index >= self._get_length():
+                raise IndexError("Index out of range while reading from tiff file")
+
+            im = self._tf.asarray(series=index)
+            meta = self._get_meta_data(index)
+
+            return im, meta
+
+        def _get_meta_data(self, index):
+            meta = {}
+            page = self._tf.pages[index or 0]
+            for key in READ_METADATA_KEYS:
+                try:
+                    meta[key] = getattr(page, key)
+                except Exception:
+                    pass
+
+            # tifffile <= 0.12.1 use datetime, newer use DateTime
+            for key in ("datetime", "DateTime"):
+                try:
+                    meta["datetime"] = datetime.datetime.strptime(
+                        page.tags[key].value, "%Y:%m:%d %H:%M:%S"
+                    )
+                    break
+                except Exception:
+                    pass
+
+            if 296 in page.tags:
+                meta["resolution_unit"] = page.tags[296].value.value
+
+            if 282 in page.tags and 283 in page.tags and 296 in page.tags:
+                resolution_x = page.tags[282].value
+                resolution_y = page.tags[283].value
+                if resolution_x[1] == 0 or resolution_y[1] == 0:
+                    warnings.warn(
+                        "Ignoring resolution metadata, "
+                        "because at least one direction has a 0 denominator.",
+                        RuntimeWarning,
+                    )
+                else:
+                    meta["resolution"] = (
+                        resolution_x[0] / resolution_x[1],
+                        resolution_y[0] / resolution_y[1],
+                        page.tags[296].value.name,
+                    )
+
+            return meta
+
+    # -- writer
+    class Writer(Format.Writer):
+        def _open(self, bigtiff=None, byteorder=None, software=None):
+            try:
+                self._tf = _tifffile.TiffWriter(
+                    self.request.get_file(),
+                    bigtiff=bigtiff,
+                    byteorder=byteorder,
+                    software=software,
+                )
+                self._software = None
+            except TypeError:
+                # In tifffile >= 0.15, the `software` arg is passed to
+                # TiffWriter.save
+                self._tf = _tifffile.TiffWriter(
+                    self.request.get_file(), bigtiff=bigtiff, byteorder=byteorder
+                )
+                self._software = software
+
+            self._meta = {}
+            self._frames_written = 0
+
+        def _close(self):
+            self._tf.close()
+
+        def _append_data(self, im, meta):
+            if meta is not None:
+                meta = self._sanitize_meta(meta)
+            else:
+                # Use global metadata for first frame
+                meta = self._meta if self._frames_written == 0 else {}
+            if self._software is not None and self._frames_written == 0:
+                meta["software"] = self._software
+            # No need to check self.request.mode; tifffile figures out whether
+            # this is a single page, or all page data at once.
+            try:
+                # TiffWriter.save has been deprecated in version 2020.9.30
+                write_meth = self._tf.write
+            except AttributeError:
+                write_meth = self._tf.save
+            write_meth(np.asanyarray(im), contiguous=False, **meta)
+            self._frames_written += 1
+
+        @staticmethod
+        def _sanitize_meta(meta):
+            ret = {}
+            for key, value in meta.items():
+                if key in WRITE_METADATA_KEYS:
+                    # Special case of previously read `predictor` int value
+                    # 1(=NONE) translation to False expected by TiffWriter.save
+                    if key == "predictor" and not isinstance(value, bool):
+                        ret[key] = value > 1
+                    elif key == "compress" and value != 0:
+                        warnings.warn(
+                            "The use of `compress` is deprecated. Use `compression` and `compressionargs` instead.",
+                            DeprecationWarning,
+                        )
+
+                        if _tifffile.__version__ < "2022":
+                            ret["compression"] = (8, value)
+                        else:
+                            ret["compression"] = "zlib"
+                            ret["compressionargs"] = {"level": value}
+                    else:
+                        ret[key] = value
+            return ret
+
+        def set_meta_data(self, meta):
+            self._meta = self._sanitize_meta(meta)

evalkit_tf437/lib/python3.10/site-packages/imageio/v3.py

@@ -0,0 +1,259 @@
+import numpy as np
+
+from .core.imopen import imopen
+
+
+def imread(uri, *, index=None, plugin=None, extension=None, format_hint=None, **kwargs):
+    """Read an ndimage from a URI.
+
+    Opens the given URI and reads an ndimage from it. The exact behavior
+    depends on both the file type and plugin used to open the file. To learn
+    about the exact behavior, check the documentation of the relevant plugin.
+    Typically, imread attempts to read all data stored in the URI.
+
+    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.
+    index : {int, Ellipsis, None}
+        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.
+    plugin : {str, None}
+        The plugin to use. If set to None (default) imread will perform a
+        search for a matching plugin. If not None, this takes priority over
+        the provided format hint  (if present).
+    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.
+    format_hint : str
+        Deprecated. Use `extension` instead.
+    **kwargs :
+        Additional keyword arguments will be passed to the plugin's read call.
+
+    Returns
+    -------
+    image : ndimage
+        The ndimage located at the given URI.
+    """
+
+    plugin_kwargs = {
+        "legacy_mode": False,
+        "plugin": plugin,
+        "format_hint": format_hint,
+        "extension": extension,
+    }
+
+    call_kwargs = kwargs
+    if index is not None:
+        call_kwargs["index"] = index
+
+    with imopen(uri, "r", **plugin_kwargs) as img_file:
+        return np.asarray(img_file.read(**call_kwargs))
+
+
+def imiter(uri, *, plugin=None, extension=None, format_hint=None, **kwargs):
+    """Read a sequence of ndimages from a URI.
+
+    Returns an iterable that yields ndimages from the given URI. The exact
+    behavior depends on both, the file type and plugin used to open the file.
+    To learn about the exact behavior, check the documentation of the relevant
+    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.
+    plugin : {str, None}
+        The plugin to use. If set to None (default) imiter will perform a
+        search for a matching plugin. If not None, this takes priority over
+        the provided format hint (if present).
+    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.
+    format_hint : str
+        Deprecated. Use `extension` instead.
+    **kwargs :
+        Additional keyword arguments will be passed to the plugin's ``iter``
+        call.
+
+    Yields
+    ------
+    image : ndimage
+        The next ndimage located at the given URI.
+
+    """
+
+    with imopen(
+        uri,
+        "r",
+        legacy_mode=False,
+        plugin=plugin,
+        format_hint=format_hint,
+        extension=extension,
+    ) as img_file:
+        for image in img_file.iter(**kwargs):
+            # Note: casting to ndarray here to ensure compatibility
+            # with the v2.9 API
+            yield np.asarray(image)
+
+
+def imwrite(uri, image, *, plugin=None, extension=None, format_hint=None, **kwargs):
+    """Write an ndimage to the given URI.
+
+    The exact behavior depends on the file type and plugin used. To learn about
+    the exact behavior, check the documentation of the relevant plugin.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, bytes, file}
+        The resource to save the image to, e.g. a filename, pathlib.Path,
+        http address or file object, check the docs for more info.
+    image : np.ndarray
+        The image to write to disk.
+    plugin : {str, None}
+        The plugin to use. If set to None (default) imwrite will perform a
+        search for a matching plugin. If not None, this takes priority over
+        the provided format hint (if present).
+    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
+        may also influence the format used when encoding.
+    format_hint : str
+        Deprecated. Use `extension` instead.
+    **kwargs :
+        Additional keyword arguments will be passed to the plugin's ``write``
+        call.
+
+    Returns
+    -------
+    encoded_image : None or Bytes
+        Returns ``None`` in all cases, except when ``uri`` is set to ``<bytes>``.
+        In this case it returns the encoded ndimage as a bytes string.
+
+    """
+
+    with imopen(
+        uri,
+        "w",
+        legacy_mode=False,
+        plugin=plugin,
+        format_hint=format_hint,
+        extension=extension,
+    ) as img_file:
+        encoded = img_file.write(image, **kwargs)
+
+    return encoded
+
+
+def improps(uri, *, index=None, plugin=None, extension=None, **kwargs):
+    """Read standardized metadata.
+
+    Opens the given URI and reads the properties of an ndimage from it. The
+    properties represent standardized metadata. This means that they will have
+    the same name regardless of the format being read or plugin/backend being
+    used. Further, any field will be, where possible, populated with a sensible
+    default (may be `None`) if the ImageResource does not declare a value in its
+    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, let the plugin decide.
+    plugin : {str, None}
+        The plugin to be used. If None, performs a search for a matching
+        plugin.
+    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.
+    **kwargs :
+        Additional keyword arguments will be passed to the plugin's ``properties``
+        call.
+
+    Returns
+    -------
+    properties : ImageProperties
+        A dataclass filled with standardized image metadata.
+
+    Notes
+    -----
+    Where possible, this will avoid loading pixel data.
+
+    See Also
+    --------
+    imageio.core.v3_plugin_api.ImageProperties
+
+    """
+
+    plugin_kwargs = {"legacy_mode": False, "plugin": plugin, "extension": extension}
+
+    call_kwargs = kwargs
+    if index is not None:
+        call_kwargs["index"] = index
+
+    with imopen(uri, "r", **plugin_kwargs) as img_file:
+        properties = img_file.properties(**call_kwargs)
+
+    return properties
+
+
+def immeta(
+    uri, *, index=None, plugin=None, extension=None, exclude_applied=True, **kwargs
+):
+    """Read format-specific metadata.
+
+    Opens the given URI and reads metadata for an ndimage from it. The contents
+    of the returned metadata dictionary is specific to both the image format and
+    plugin used to open the ImageResource. To learn about the exact behavior,
+    check the documentation of the relevant plugin. Typically, immeta returns a
+    dictionary specific to the image format, where keys match metadata field
+    names and values are a field's contents.
+
+    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.
+    index : {int, None}
+        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, let the plugin decide the default.
+    plugin : {str, None}
+        The plugin to be used. If None (default), performs a search for a
+        matching plugin.
+    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.
+    **kwargs :
+        Additional keyword arguments will be passed to the plugin's metadata
+        method.
+
+    Returns
+    -------
+    image : ndimage
+        The ndimage located at the given URI.
+
+    """
+
+    plugin_kwargs = {"legacy_mode": False, "plugin": plugin, "extension": extension}
+
+    call_kwargs = kwargs
+    call_kwargs["exclude_applied"] = exclude_applied
+    if index is not None:
+        call_kwargs["index"] = index
+
+    with imopen(uri, "r", **plugin_kwargs) as img_file:
+        metadata = img_file.metadata(**call_kwargs)
+
+    return metadata
+
+
+__all__ = ["imopen", "imread", "imwrite", "imiter", "improps", "immeta"]

falcon/bin/accelerate-merge-weights

@@ -0,0 +1,8 @@
+#!/root/envs/falcon/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from accelerate.commands.merge import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

falcon/bin/bzgrep

@@ -0,0 +1,85 @@
+#!/bin/sh
+
+# Bzgrep wrapped for bzip2, 
+# adapted from zgrep by Philippe Troin <[email protected]> for Debian GNU/Linux.
+## zgrep notice:
+## zgrep -- a wrapper around a grep program that decompresses files as needed
+## Adapted from a version sent by Charles Levert <[email protected]>
+
+PATH="/usr/bin:$PATH"; export PATH
+
+prog=`echo $0 | sed 's|.*/||'`
+case "$prog" in
+	*egrep)	grep=${EGREP-egrep}	;;
+	*fgrep)	grep=${FGREP-fgrep}	;;
+	*)	grep=${GREP-grep}	;;
+esac
+pat=""
+while test $# -ne 0; do
+  case "$1" in
+  -e | -f) opt="$opt $1"; shift; pat="$1"
+           if test "$grep" = grep; then  # grep is buggy with -e on SVR4
+             grep=egrep
+           fi;;
+  -A | -B) opt="$opt $1 $2"; shift;;
+  -*)	   opt="$opt $1";;
+   *)      if test -z "$pat"; then
+	     pat="$1"
+	   else
+	     break;
+           fi;;
+  esac
+  shift
+done
+
+if test -z "$pat"; then
+  echo "grep through bzip2 files"
+  echo "usage: $prog [grep_options] pattern [files]"
+  exit 1
+fi
+
+list=0
+silent=0
+op=`echo "$opt" | sed -e 's/ //g' -e 's/-//g'`
+case "$op" in
+  *l*) list=1
+esac
+case "$op" in
+  *h*) silent=1
+esac
+
+if test $# -eq 0; then
+  bzip2 -cdfq | $grep $opt "$pat"
+  exit $?
+fi
+
+res=0
+for i do
+  if test -f "$i"; then :; else if test -f "$i.bz2"; then i="$i.bz2"; fi; fi
+  if test $list -eq 1; then
+    bzip2 -cdfq "$i" | $grep $opt "$pat" 2>&1 > /dev/null && echo $i
+    r=$?
+  elif test $# -eq 1 -o $silent -eq 1; then
+    bzip2 -cdfq "$i" | $grep $opt "$pat"
+    r=$?
+  else
+    j=$(echo "$i" | sed 's/\\/&&/g;s/|/\\&/g;s/&/\\&/g')
+    j=`printf "%s" "$j" | tr '\n' ' '`
+    # A trick adapted from
+    # https://groups.google.com/forum/#!original/comp.unix.shell/x1345iu10eg/Nn1n-1r1uU0J
+    # that has the same effect as the following bash code:
+    # bzip2 -cdfq "$i" | $grep $opt "$pat" | sed "s|^|${j}:|"
+    # r=${PIPESTATUS[1]}
+    exec 3>&1
+    eval `
+      exec 4>&1 >&3 3>&-
+      {
+        bzip2 -cdfq "$i" 4>&-
+      } | {
+        $grep $opt "$pat" 4>&-; echo "r=$?;" >&4
+      } | sed "s|^|${j}:|"
+    `
+  fi
+  test "$r" -ne 0 && res="$r"
+done
+exit $res

falcon/bin/convert-caffe2-to-onnx

@@ -0,0 +1,8 @@
+#!/root/envs/falcon/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(caffe2_to_onnx())

falcon/bin/gradio

@@ -0,0 +1,8 @@
+#!/root/envs/falcon/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

falcon/bin/httpx

@@ -0,0 +1,8 @@
+#!/root/envs/falcon/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

falcon/bin/lzless

@@ -0,0 +1,74 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation
+
+# The original version for gzip was written by Paul Eggert.
+# Modified for XZ Utils by Andrew Dudman and Lasse Collin.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+
+#SET_PATH - This line is a placeholder to ease patching this script.
+
+# Instead of unsetting XZ_OPT, just make sure that xz will use file format
+# autodetection. This way memory usage limit and thread limit can be
+# specified via XZ_OPT.
+xz='xz --format=auto'
+
+version='xzless (XZ Utils) 5.6.4'
+
+usage="Usage: ${0##*/} [OPTION]... [FILE]...
+Like 'less', but operate on the uncompressed contents of xz compressed FILEs.
+
+Options are the same as for 'less'.
+
+Report bugs to <[email protected]>."
+
+case $1 in
+	--help)    printf '%s\n' "$usage" || exit 2; exit;;
+	--version) printf '%s\n' "$version" || exit 2; exit;;
+esac
+
+if test "${LESSMETACHARS+set}" != set; then
+	# Work around a bug in less 394 and earlier;
+	# it mishandles the metacharacters '$%=~'.
+	space=' '
+	tab='	'
+	nl='
+'
+	LESSMETACHARS="$space$tab$nl'"';*?"()<>[|&^`#\$%=~'
+fi
+
+VER=$(less -V | { read _ ver _ && echo ${ver%%.*}; })
+if test "$VER" -ge 451; then
+	# less 451 or later: If the compressed file is valid but has
+	# zero bytes of uncompressed data, using two vertical bars ||- makes
+	# "less" check the exit status of xz and if it is zero then display
+	# an empty file. With a single vertical bar |- and no output from xz,
+	# "less" would attempt to display the raw input file instead.
+	LESSOPEN="||-$xz -cdfqQ -- %s"
+elif test "$VER" -ge 429; then
+	# less 429 or later: LESSOPEN pipe will be used on
+	# standard input if $LESSOPEN begins with |-.
+	LESSOPEN="|-$xz -cdfqQ -- %s"
+else
+	LESSOPEN="|$xz -cdfqQ -- %s"
+fi
+
+SHOW_PREPROC_ERRORS=
+if test "$VER" -ge 632; then
+	SHOW_PREPROC_ERRORS=--show-preproc-errors
+fi
+
+export LESSMETACHARS LESSOPEN
+
+exec less $SHOW_PREPROC_ERRORS "$@"