Add files using upload-large-folder tool

.gitattributes

@@ -156,3 +156,6 @@ parrot/lib/python3.10/site-packages/wandb/sdk/internal/__pycache__/internal_api.
 parrot/lib/libgomp.so.1 filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libquadmath.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libquadmath.so.0 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libitm.so.1 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

parrot/lib/libitm.so.1

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

parrot/lib/libquadmath.so.0

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

parrot/lib/python3.10/site-packages/git/index/__init__.py

@@ -0,0 +1,16 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Initialize the index package."""
+
+__all__ = [
+    "BaseIndexEntry",
+    "BlobFilter",
+    "CheckoutError",
+    "IndexEntry",
+    "IndexFile",
+    "StageType",
+]
+
+from .base import CheckoutError, IndexFile
+from .typ import BaseIndexEntry, BlobFilter, IndexEntry, StageType

parrot/lib/python3.10/site-packages/git/index/base.py

@@ -0,0 +1,1518 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Module containing :class:`IndexFile`, an Index implementation facilitating all kinds
+of index manipulations such as querying and merging."""
+
+__all__ = ["IndexFile", "CheckoutError", "StageType"]
+
+import contextlib
+import datetime
+import glob
+from io import BytesIO
+import os
+import os.path as osp
+from stat import S_ISLNK
+import subprocess
+import sys
+import tempfile
+
+from gitdb.base import IStream
+from gitdb.db import MemoryDB
+
+from git.compat import defenc, force_bytes
+import git.diff as git_diff
+from git.exc import CheckoutError, GitCommandError, GitError, InvalidGitRepositoryError
+from git.objects import Blob, Commit, Object, Submodule, Tree
+from git.objects.util import Serializable
+from git.util import (
+    LazyMixin,
+    LockedFD,
+    join_path_native,
+    file_contents_ro,
+    to_native_path_linux,
+    unbare_repo,
+    to_bin_sha,
+)
+
+from .fun import (
+    S_IFGITLINK,
+    aggressive_tree_merge,
+    entry_key,
+    read_cache,
+    run_commit_hook,
+    stat_mode_to_index_mode,
+    write_cache,
+    write_tree_from_cache,
+)
+from .typ import BaseIndexEntry, IndexEntry, StageType
+from .util import TemporaryFileSwap, post_clear_cache, default_index, git_working_dir
+
+# typing -----------------------------------------------------------------------------
+
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Generator,
+    IO,
+    Iterable,
+    Iterator,
+    List,
+    NoReturn,
+    Sequence,
+    TYPE_CHECKING,
+    Tuple,
+    Union,
+)
+
+from git.types import Literal, PathLike
+
+if TYPE_CHECKING:
+    from subprocess import Popen
+
+    from git.refs.reference import Reference
+    from git.repo import Repo
+    from git.util import Actor
+
+
+Treeish = Union[Tree, Commit, str, bytes]
+
+# ------------------------------------------------------------------------------------
+
+
+@contextlib.contextmanager
+def _named_temporary_file_for_subprocess(directory: PathLike) -> Generator[str, None, None]:
+    """Create a named temporary file git subprocesses can open, deleting it afterward.
+
+    :param directory:
+        The directory in which the file is created.
+
+    :return:
+        A context manager object that creates the file and provides its name on entry,
+        and deletes it on exit.
+    """
+    if sys.platform == "win32":
+        fd, name = tempfile.mkstemp(dir=directory)
+        os.close(fd)
+        try:
+            yield name
+        finally:
+            os.remove(name)
+    else:
+        with tempfile.NamedTemporaryFile(dir=directory) as ctx:
+            yield ctx.name
+
+
+class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
+    """An Index that can be manipulated using a native implementation in order to save
+    git command function calls wherever possible.
+
+    This provides custom merging facilities allowing to merge without actually changing
+    your index or your working tree. This way you can perform your own test merges based
+    on the index only without having to deal with the working copy. This is useful in
+    case of partial working trees.
+
+    Entries:
+
+        The index contains an entries dict whose keys are tuples of type
+        :class:`~git.index.typ.IndexEntry` to facilitate access.
+
+        You may read the entries dict or manipulate it using IndexEntry instance, i.e.::
+
+            index.entries[index.entry_key(index_entry_instance)] = index_entry_instance
+
+    Make sure you use :meth:`index.write() <write>` once you are done manipulating the
+    index directly before operating on it using the git command.
+    """
+
+    __slots__ = ("repo", "version", "entries", "_extension_data", "_file_path")
+
+    _VERSION = 2
+    """The latest version we support."""
+
+    S_IFGITLINK = S_IFGITLINK
+    """Flags for a submodule."""
+
+    def __init__(self, repo: "Repo", file_path: Union[PathLike, None] = None) -> None:
+        """Initialize this Index instance, optionally from the given `file_path`.
+
+        If no `file_path` is given, we will be created from the current index file.
+
+        If a stream is not given, the stream will be initialized from the current
+        repository's index on demand.
+        """
+        self.repo = repo
+        self.version = self._VERSION
+        self._extension_data = b""
+        self._file_path: PathLike = file_path or self._index_path()
+
+    def _set_cache_(self, attr: str) -> None:
+        if attr == "entries":
+            try:
+                fd = os.open(self._file_path, os.O_RDONLY)
+            except OSError:
+                # In new repositories, there may be no index, which means we are empty.
+                self.entries: Dict[Tuple[PathLike, StageType], IndexEntry] = {}
+                return
+            # END exception handling
+
+            try:
+                stream = file_contents_ro(fd, stream=True, allow_mmap=True)
+            finally:
+                os.close(fd)
+
+            self._deserialize(stream)
+        else:
+            super()._set_cache_(attr)
+
+    def _index_path(self) -> PathLike:
+        if self.repo.git_dir:
+            return join_path_native(self.repo.git_dir, "index")
+        else:
+            raise GitCommandError("No git directory given to join index path")
+
+    @property
+    def path(self) -> PathLike:
+        """:return: Path to the index file we are representing"""
+        return self._file_path
+
+    def _delete_entries_cache(self) -> None:
+        """Safely clear the entries cache so it can be recreated."""
+        try:
+            del self.entries
+        except AttributeError:
+            # It failed in Python 2.6.5 with AttributeError.
+            # FIXME: Look into whether we can just remove this except clause now.
+            pass
+        # END exception handling
+
+    # { Serializable Interface
+
+    def _deserialize(self, stream: IO) -> "IndexFile":
+        """Initialize this instance with index values read from the given stream."""
+        self.version, self.entries, self._extension_data, _conten_sha = read_cache(stream)
+        return self
+
+    def _entries_sorted(self) -> List[IndexEntry]:
+        """:return: List of entries, in a sorted fashion, first by path, then by stage"""
+        return sorted(self.entries.values(), key=lambda e: (e.path, e.stage))
+
+    def _serialize(self, stream: IO, ignore_extension_data: bool = False) -> "IndexFile":
+        entries = self._entries_sorted()
+        extension_data = self._extension_data  # type: Union[None, bytes]
+        if ignore_extension_data:
+            extension_data = None
+        write_cache(entries, stream, extension_data)
+        return self
+
+    # } END serializable interface
+
+    def write(
+        self,
+        file_path: Union[None, PathLike] = None,
+        ignore_extension_data: bool = False,
+    ) -> None:
+        """Write the current state to our file path or to the given one.
+
+        :param file_path:
+            If ``None``, we will write to our stored file path from which we have been
+            initialized. Otherwise we write to the given file path. Please note that
+            this will change the `file_path` of this index to the one you gave.
+
+        :param ignore_extension_data:
+            If ``True``, the TREE type extension data read in the index will not be
+            written to disk. NOTE that no extension data is actually written. Use this
+            if you have altered the index and would like to use
+            :manpage:`git-write-tree(1)` afterwards to create a tree representing your
+            written changes. If this data is present in the written index,
+            :manpage:`git-write-tree(1)` will instead write the stored/cached tree.
+            Alternatively, use :meth:`write_tree` to handle this case automatically.
+        """
+        # Make sure we have our entries read before getting a write lock.
+        # Otherwise it would be done when streaming.
+        # This can happen if one doesn't change the index, but writes it right away.
+        self.entries  # noqa: B018
+        lfd = LockedFD(file_path or self._file_path)
+        stream = lfd.open(write=True, stream=True)
+
+        try:
+            self._serialize(stream, ignore_extension_data)
+        except BaseException:
+            lfd.rollback()
+            raise
+
+        lfd.commit()
+
+        # Make sure we represent what we have written.
+        if file_path is not None:
+            self._file_path = file_path
+
+    @post_clear_cache
+    @default_index
+    def merge_tree(self, rhs: Treeish, base: Union[None, Treeish] = None) -> "IndexFile":
+        """Merge the given `rhs` treeish into the current index, possibly taking
+        a common base treeish into account.
+
+        As opposed to the :func:`from_tree` method, this allows you to use an already
+        existing tree as the left side of the merge.
+
+        :param rhs:
+            Treeish reference pointing to the 'other' side of the merge.
+
+        :param base:
+            Optional treeish reference pointing to the common base of `rhs` and this
+            index which equals lhs.
+
+        :return:
+            self (containing the merge and possibly unmerged entries in case of
+            conflicts)
+
+        :raise git.exc.GitCommandError:
+            If there is a merge conflict. The error will be raised at the first
+            conflicting path. If you want to have proper merge resolution to be done by
+            yourself, you have to commit the changed index (or make a valid tree from
+            it) and retry with a three-way :meth:`index.from_tree <from_tree>` call.
+        """
+        # -i : ignore working tree status
+        # --aggressive : handle more merge cases
+        # -m : do an actual merge
+        args: List[Union[Treeish, str]] = ["--aggressive", "-i", "-m"]
+        if base is not None:
+            args.append(base)
+        args.append(rhs)
+
+        self.repo.git.read_tree(args)
+        return self
+
+    @classmethod
+    def new(cls, repo: "Repo", *tree_sha: Union[str, Tree]) -> "IndexFile":
+        """Merge the given treeish revisions into a new index which is returned.
+
+        This method behaves like ``git-read-tree --aggressive`` when doing the merge.
+
+        :param repo:
+            The repository treeish are located in.
+
+        :param tree_sha:
+            20 byte or 40 byte tree sha or tree objects.
+
+        :return:
+            New :class:`IndexFile` instance. Its path will be undefined.
+            If you intend to write such a merged Index, supply an alternate
+            ``file_path`` to its :meth:`write` method.
+        """
+        tree_sha_bytes: List[bytes] = [to_bin_sha(str(t)) for t in tree_sha]
+        base_entries = aggressive_tree_merge(repo.odb, tree_sha_bytes)
+
+        inst = cls(repo)
+        # Convert to entries dict.
+        entries: Dict[Tuple[PathLike, int], IndexEntry] = dict(
+            zip(
+                ((e.path, e.stage) for e in base_entries),
+                (IndexEntry.from_base(e) for e in base_entries),
+            )
+        )
+
+        inst.entries = entries
+        return inst
+
+    @classmethod
+    def from_tree(cls, repo: "Repo", *treeish: Treeish, **kwargs: Any) -> "IndexFile":
+        R"""Merge the given treeish revisions into a new index which is returned.
+        The original index will remain unaltered.
+
+        :param repo:
+            The repository treeish are located in.
+
+        :param treeish:
+            One, two or three :class:`~git.objects.tree.Tree` objects,
+            :class:`~git.objects.commit.Commit`\s or 40 byte hexshas.
+
+            The result changes according to the amount of trees:
+
+            1. If 1 Tree is given, it will just be read into a new index.
+            2. If 2 Trees are given, they will be merged into a new index using a two
+               way merge algorithm. Tree 1 is the 'current' tree, tree 2 is the 'other'
+               one. It behaves like a fast-forward.
+            3. If 3 Trees are given, a 3-way merge will be performed with the first tree
+               being the common ancestor of tree 2 and tree 3. Tree 2 is the 'current'
+               tree, tree 3 is the 'other' one.
+
+        :param kwargs:
+            Additional arguments passed to :manpage:`git-read-tree(1)`.
+
+        :return:
+            New :class:`IndexFile` instance. It will point to a temporary index location
+            which does not exist anymore. If you intend to write such a merged Index,
+            supply an alternate ``file_path`` to its :meth:`write` method.
+
+        :note:
+            In the three-way merge case, ``--aggressive`` will be specified to
+            automatically resolve more cases in a commonly correct manner. Specify
+            ``trivial=True`` as a keyword argument to override that.
+
+            As the underlying :manpage:`git-read-tree(1)` command takes into account the
+            current index, it will be temporarily moved out of the way to prevent any
+            unexpected interference.
+        """
+        if len(treeish) == 0 or len(treeish) > 3:
+            raise ValueError("Please specify between 1 and 3 treeish, got %i" % len(treeish))
+
+        arg_list: List[Union[Treeish, str]] = []
+        # Ignore that the working tree and index possibly are out of date.
+        if len(treeish) > 1:
+            # Drop unmerged entries when reading our index and merging.
+            arg_list.append("--reset")
+            # Handle non-trivial cases the way a real merge does.
+            arg_list.append("--aggressive")
+        # END merge handling
+
+        # Create the temporary file in the .git directory to be sure renaming
+        # works - /tmp/ directories could be on another device.
+        with _named_temporary_file_for_subprocess(repo.git_dir) as tmp_index:
+            arg_list.append("--index-output=%s" % tmp_index)
+            arg_list.extend(treeish)
+
+            # Move the current index out of the way - otherwise the merge may fail as it
+            # considers existing entries. Moving it essentially clears the index.
+            # Unfortunately there is no 'soft' way to do it.
+            # The TemporaryFileSwap ensures the original file gets put back.
+            with TemporaryFileSwap(join_path_native(repo.git_dir, "index")):
+                repo.git.read_tree(*arg_list, **kwargs)
+                index = cls(repo, tmp_index)
+                index.entries  # noqa: B018 # Force it to read the file as we will delete the temp-file.
+                return index
+            # END index merge handling
+
+    # UTILITIES
+
+    @unbare_repo
+    def _iter_expand_paths(self: "IndexFile", paths: Sequence[PathLike]) -> Iterator[PathLike]:
+        """Expand the directories in list of paths to the corresponding paths
+        accordingly.
+
+        :note:
+            git will add items multiple times even if a glob overlapped with manually
+            specified paths or if paths where specified multiple times - we respect that
+            and do not prune.
+        """
+
+        def raise_exc(e: Exception) -> NoReturn:
+            raise e
+
+        r = str(self.repo.working_tree_dir)
+        rs = r + os.sep
+        for path in paths:
+            abs_path = str(path)
+            if not osp.isabs(abs_path):
+                abs_path = osp.join(r, path)
+            # END make absolute path
+
+            try:
+                st = os.lstat(abs_path)  # Handles non-symlinks as well.
+            except OSError:
+                # The lstat call may fail as the path may contain globs as well.
+                pass
+            else:
+                if S_ISLNK(st.st_mode):
+                    yield abs_path.replace(rs, "")
+                    continue
+            # END check symlink
+
+            # If the path is not already pointing to an existing file, resolve globs if possible.
+            if not os.path.exists(abs_path) and ("?" in abs_path or "*" in abs_path or "[" in abs_path):
+                resolved_paths = glob.glob(abs_path)
+                # not abs_path in resolved_paths:
+                #   A glob() resolving to the same path we are feeding it with is a
+                #   glob() that failed to resolve. If we continued calling ourselves
+                #   we'd endlessly recurse. If the condition below evaluates to true
+                #   then we are likely dealing with a file whose name contains wildcard
+                #   characters.
+                if abs_path not in resolved_paths:
+                    for f in self._iter_expand_paths(glob.glob(abs_path)):
+                        yield str(f).replace(rs, "")
+                    continue
+            # END glob handling
+            try:
+                for root, _dirs, files in os.walk(abs_path, onerror=raise_exc):
+                    for rela_file in files:
+                        # Add relative paths only.
+                        yield osp.join(root.replace(rs, ""), rela_file)
+                    # END for each file in subdir
+                # END for each subdirectory
+            except OSError:
+                # It was a file or something that could not be iterated.
+                yield abs_path.replace(rs, "")
+            # END path exception handling
+        # END for each path
+
+    def _write_path_to_stdin(
+        self,
+        proc: "Popen",
+        filepath: PathLike,
+        item: PathLike,
+        fmakeexc: Callable[..., GitError],
+        fprogress: Callable[[PathLike, bool, PathLike], None],
+        read_from_stdout: bool = True,
+    ) -> Union[None, str]:
+        """Write path to ``proc.stdin`` and make sure it processes the item, including
+        progress.
+
+        :return:
+            stdout string
+
+        :param read_from_stdout:
+            If ``True``, ``proc.stdout`` will be read after the item was sent to stdin.
+            In that case, it will return ``None``.
+
+        :note:
+            There is a bug in :manpage:`git-update-index(1)` that prevents it from
+            sending reports just in time. This is why we have a version that tries to
+            read stdout and one which doesn't. In fact, the stdout is not important as
+            the piped-in files are processed anyway and just in time.
+
+        :note:
+            Newlines are essential here, git's behaviour is somewhat inconsistent on
+            this depending on the version, hence we try our best to deal with newlines
+            carefully. Usually the last newline will not be sent, instead we will close
+            stdin to break the pipe.
+        """
+        fprogress(filepath, False, item)
+        rval: Union[None, str] = None
+
+        if proc.stdin is not None:
+            try:
+                proc.stdin.write(("%s\n" % filepath).encode(defenc))
+            except IOError as e:
+                # Pipe broke, usually because some error happened.
+                raise fmakeexc() from e
+            # END write exception handling
+            proc.stdin.flush()
+
+        if read_from_stdout and proc.stdout is not None:
+            rval = proc.stdout.readline().strip()
+        fprogress(filepath, True, item)
+        return rval
+
+    def iter_blobs(
+        self, predicate: Callable[[Tuple[StageType, Blob]], bool] = lambda t: True
+    ) -> Iterator[Tuple[StageType, Blob]]:
+        """
+        :return:
+            Iterator yielding tuples of :class:`~git.objects.blob.Blob` objects and
+            stages, tuple(stage, Blob).
+
+        :param predicate:
+            Function(t) returning ``True`` if tuple(stage, Blob) should be yielded by
+            the iterator. A default filter, the `~git.index.typ.BlobFilter`, allows you
+            to yield blobs only if they match a given list of paths.
+        """
+        for entry in self.entries.values():
+            blob = entry.to_blob(self.repo)
+            blob.size = entry.size
+            output = (entry.stage, blob)
+            if predicate(output):
+                yield output
+        # END for each entry
+
+    def unmerged_blobs(self) -> Dict[PathLike, List[Tuple[StageType, Blob]]]:
+        """
+        :return:
+            Dict(path : list(tuple(stage, Blob, ...))), being a dictionary associating a
+            path in the index with a list containing sorted stage/blob pairs.
+
+        :note:
+            Blobs that have been removed in one side simply do not exist in the given
+            stage. That is, a file removed on the 'other' branch whose entries are at
+            stage 3 will not have a stage 3 entry.
+        """
+        is_unmerged_blob = lambda t: t[0] != 0
+        path_map: Dict[PathLike, List[Tuple[StageType, Blob]]] = {}
+        for stage, blob in self.iter_blobs(is_unmerged_blob):
+            path_map.setdefault(blob.path, []).append((stage, blob))
+        # END for each unmerged blob
+        for line in path_map.values():
+            line.sort()
+
+        return path_map
+
+    @classmethod
+    def entry_key(cls, *entry: Union[BaseIndexEntry, PathLike, StageType]) -> Tuple[PathLike, StageType]:
+        return entry_key(*entry)
+
+    def resolve_blobs(self, iter_blobs: Iterator[Blob]) -> "IndexFile":
+        """Resolve the blobs given in blob iterator.
+
+        This will effectively remove the index entries of the respective path at all
+        non-null stages and add the given blob as new stage null blob.
+
+        For each path there may only be one blob, otherwise a :exc:`ValueError` will be
+        raised claiming the path is already at stage 0.
+
+        :raise ValueError:
+            If one of the blobs already existed at stage 0.
+
+        :return:
+            self
+
+        :note:
+            You will have to write the index manually once you are done, i.e.
+            ``index.resolve_blobs(blobs).write()``.
+        """
+        for blob in iter_blobs:
+            stage_null_key = (blob.path, 0)
+            if stage_null_key in self.entries:
+                raise ValueError("Path %r already exists at stage 0" % str(blob.path))
+            # END assert blob is not stage 0 already
+
+            # Delete all possible stages.
+            for stage in (1, 2, 3):
+                try:
+                    del self.entries[(blob.path, stage)]
+                except KeyError:
+                    pass
+                # END ignore key errors
+            # END for each possible stage
+
+            self.entries[stage_null_key] = IndexEntry.from_blob(blob)
+        # END for each blob
+
+        return self
+
+    def update(self) -> "IndexFile":
+        """Reread the contents of our index file, discarding all cached information
+        we might have.
+
+        :note:
+            This is a possibly dangerous operations as it will discard your changes to
+            :attr:`index.entries <entries>`.
+
+        :return:
+            self
+        """
+        self._delete_entries_cache()
+        # Allows to lazily reread on demand.
+        return self
+
+    def write_tree(self) -> Tree:
+        """Write this index to a corresponding :class:`~git.objects.tree.Tree` object
+        into the repository's object database and return it.
+
+        :return:
+            :class:`~git.objects.tree.Tree` object representing this index.
+
+        :note:
+            The tree will be written even if one or more objects the tree refers to does
+            not yet exist in the object database. This could happen if you added entries
+            to the index directly.
+
+        :raise ValueError:
+            If there are no entries in the cache.
+
+        :raise git.exc.UnmergedEntriesError:
+        """
+        # We obtain no lock as we just flush our contents to disk as tree.
+        # If we are a new index, the entries access will load our data accordingly.
+        mdb = MemoryDB()
+        entries = self._entries_sorted()
+        binsha, tree_items = write_tree_from_cache(entries, mdb, slice(0, len(entries)))
+
+        # Copy changed trees only.
+        mdb.stream_copy(mdb.sha_iter(), self.repo.odb)
+
+        # Note: Additional deserialization could be saved if write_tree_from_cache would
+        # return sorted tree entries.
+        root_tree = Tree(self.repo, binsha, path="")
+        root_tree._cache = tree_items
+        return root_tree
+
+    def _process_diff_args(
+        self,
+        args: List[Union[PathLike, "git_diff.Diffable"]],
+    ) -> List[Union[PathLike, "git_diff.Diffable"]]:
+        try:
+            args.pop(args.index(self))
+        except IndexError:
+            pass
+        # END remove self
+        return args
+
+    def _to_relative_path(self, path: PathLike) -> PathLike:
+        """
+        :return:
+            Version of path relative to our git directory or raise :exc:`ValueError` if
+            it is not within our git directory.
+
+        :raise ValueError:
+        """
+        if not osp.isabs(path):
+            return path
+        if self.repo.bare:
+            raise InvalidGitRepositoryError("require non-bare repository")
+        if not str(path).startswith(str(self.repo.working_tree_dir)):
+            raise ValueError("Absolute path %r is not in git repository at %r" % (path, self.repo.working_tree_dir))
+        return os.path.relpath(path, self.repo.working_tree_dir)
+
+    def _preprocess_add_items(
+        self, items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]
+    ) -> Tuple[List[PathLike], List[BaseIndexEntry]]:
+        """Split the items into two lists of path strings and BaseEntries."""
+        paths = []
+        entries = []
+        # if it is a string put in list
+        if isinstance(items, (str, os.PathLike)):
+            items = [items]
+
+        for item in items:
+            if isinstance(item, (str, os.PathLike)):
+                paths.append(self._to_relative_path(item))
+            elif isinstance(item, (Blob, Submodule)):
+                entries.append(BaseIndexEntry.from_blob(item))
+            elif isinstance(item, BaseIndexEntry):
+                entries.append(item)
+            else:
+                raise TypeError("Invalid Type: %r" % item)
+        # END for each item
+        return paths, entries
+
+    def _store_path(self, filepath: PathLike, fprogress: Callable) -> BaseIndexEntry:
+        """Store file at filepath in the database and return the base index entry.
+
+        :note:
+            This needs the :func:`~git.index.util.git_working_dir` decorator active!
+            This must be ensured in the calling code.
+        """
+        st = os.lstat(filepath)  # Handles non-symlinks as well.
+        if S_ISLNK(st.st_mode):
+            # In PY3, readlink is a string, but we need bytes.
+            # In PY2, it was just OS encoded bytes, we assumed UTF-8.
+            open_stream: Callable[[], BinaryIO] = lambda: BytesIO(force_bytes(os.readlink(filepath), encoding=defenc))
+        else:
+            open_stream = lambda: open(filepath, "rb")
+        with open_stream() as stream:
+            fprogress(filepath, False, filepath)
+            istream = self.repo.odb.store(IStream(Blob.type, st.st_size, stream))
+            fprogress(filepath, True, filepath)
+        return BaseIndexEntry(
+            (
+                stat_mode_to_index_mode(st.st_mode),
+                istream.binsha,
+                0,
+                to_native_path_linux(filepath),
+            )
+        )
+
+    @unbare_repo
+    @git_working_dir
+    def _entries_for_paths(
+        self,
+        paths: List[str],
+        path_rewriter: Union[Callable, None],
+        fprogress: Callable,
+        entries: List[BaseIndexEntry],
+    ) -> List[BaseIndexEntry]:
+        entries_added: List[BaseIndexEntry] = []
+        if path_rewriter:
+            for path in paths:
+                if osp.isabs(path):
+                    abspath = path
+                    gitrelative_path = path[len(str(self.repo.working_tree_dir)) + 1 :]
+                else:
+                    gitrelative_path = path
+                    if self.repo.working_tree_dir:
+                        abspath = osp.join(self.repo.working_tree_dir, gitrelative_path)
+                # END obtain relative and absolute paths
+
+                blob = Blob(
+                    self.repo,
+                    Blob.NULL_BIN_SHA,
+                    stat_mode_to_index_mode(os.stat(abspath).st_mode),
+                    to_native_path_linux(gitrelative_path),
+                )
+                # TODO: variable undefined
+                entries.append(BaseIndexEntry.from_blob(blob))
+            # END for each path
+            del paths[:]
+        # END rewrite paths
+
+        # HANDLE PATHS
+        assert len(entries_added) == 0
+        for filepath in self._iter_expand_paths(paths):
+            entries_added.append(self._store_path(filepath, fprogress))
+        # END for each filepath
+        # END path handling
+        return entries_added
+
+    def add(
+        self,
+        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
+        force: bool = True,
+        fprogress: Callable = lambda *args: None,
+        path_rewriter: Union[Callable[..., PathLike], None] = None,
+        write: bool = True,
+        write_extension_data: bool = False,
+    ) -> List[BaseIndexEntry]:
+        R"""Add files from the working tree, specific blobs, or
+        :class:`~git.index.typ.BaseIndexEntry`\s to the index.
+
+        :param items:
+            Multiple types of items are supported, types can be mixed within one call.
+            Different types imply a different handling. File paths may generally be
+            relative or absolute.
+
+            - path string
+
+                Strings denote a relative or absolute path into the repository pointing
+                to an existing file, e.g., ``CHANGES``, `lib/myfile.ext``,
+                ``/home/gitrepo/lib/myfile.ext``.
+
+                Absolute paths must start with working tree directory of this index's
+                repository to be considered valid. For example, if it was initialized
+                with a non-normalized path, like ``/root/repo/../repo``, absolute paths
+                to be added must start with ``/root/repo/../repo``.
+
+                Paths provided like this must exist. When added, they will be written
+                into the object database.
+
+                PathStrings may contain globs, such as ``lib/__init__*``. Or they can be
+                directories like ``lib``, which will add all the files within the
+                directory and subdirectories.
+
+                This equals a straight :manpage:`git-add(1)`.
+
+                They are added at stage 0.
+
+            - :class:~`git.objects.blob.Blob` or
+              :class:`~git.objects.submodule.base.Submodule` object
+
+                Blobs are added as they are assuming a valid mode is set.
+
+                The file they refer to may or may not exist in the file system, but must
+                be a path relative to our repository.
+
+                If their sha is null (40*0), their path must exist in the file system
+                relative to the git repository as an object will be created from the
+                data at the path.
+
+                The handling now very much equals the way string paths are processed,
+                except that the mode you have set will be kept. This allows you to
+                create symlinks by settings the mode respectively and writing the target
+                of the symlink directly into the file. This equals a default Linux
+                symlink which is not dereferenced automatically, except that it can be
+                created on filesystems not supporting it as well.
+
+                Please note that globs or directories are not allowed in
+                :class:`~git.objects.blob.Blob` objects.
+
+                They are added at stage 0.
+
+            - :class:`~git.index.typ.BaseIndexEntry` or type
+
+                Handling equals the one of :class:~`git.objects.blob.Blob` objects, but
+                the stage may be explicitly set. Please note that Index Entries require
+                binary sha's.
+
+        :param force:
+            **CURRENTLY INEFFECTIVE**
+            If ``True``, otherwise ignored or excluded files will be added anyway. As
+            opposed to the :manpage:`git-add(1)` command, we enable this flag by default
+            as the API user usually wants the item to be added even though they might be
+            excluded.
+
+        :param fprogress:
+            Function with signature ``f(path, done=False, item=item)`` called for each
+            path to be added, one time once it is about to be added where ``done=False``
+            and once after it was added where ``done=True``.
+
+            ``item`` is set to the actual item we handle, either a path or a
+            :class:`~git.index.typ.BaseIndexEntry`.
+
+            Please note that the processed path is not guaranteed to be present in the
+            index already as the index is currently being processed.
+
+        :param path_rewriter:
+            Function, with signature ``(string) func(BaseIndexEntry)``, returning a path
+            for each passed entry which is the path to be actually recorded for the
+            object created from :attr:`entry.path <git.index.typ.BaseIndexEntry.path>`.
+            This allows you to write an index which is not identical to the layout of
+            the actual files on your hard-disk. If not ``None`` and `items` contain
+            plain paths, these paths will be converted to Entries beforehand and passed
+            to the path_rewriter. Please note that ``entry.path`` is relative to the git
+            repository.
+
+        :param write:
+            If ``True``, the index will be written once it was altered. Otherwise the
+            changes only exist in memory and are not available to git commands.
+
+        :param write_extension_data:
+            If ``True``, extension data will be written back to the index. This can lead
+            to issues in case it is containing the 'TREE' extension, which will cause
+            the :manpage:`git-commit(1)` command to write an old tree, instead of a new
+            one representing the now changed index.
+
+            This doesn't matter if you use :meth:`IndexFile.commit`, which ignores the
+            'TREE' extension altogether. You should set it to ``True`` if you intend to
+            use :meth:`IndexFile.commit` exclusively while maintaining support for
+            third-party extensions. Besides that, you can usually safely ignore the
+            built-in extensions when using GitPython on repositories that are not
+            handled manually at all.
+
+            All current built-in extensions are listed here:
+            https://git-scm.com/docs/index-format
+
+        :return:
+            List of :class:`~git.index.typ.BaseIndexEntry`\s representing the entries
+            just actually added.
+
+        :raise OSError:
+            If a supplied path did not exist. Please note that
+            :class:`~git.index.typ.BaseIndexEntry` objects that do not have a null sha
+            will be added even if their paths do not exist.
+        """
+        # Sort the entries into strings and Entries.
+        # Blobs are converted to entries automatically.
+        # Paths can be git-added. For everything else we use git-update-index.
+        paths, entries = self._preprocess_add_items(items)
+        entries_added: List[BaseIndexEntry] = []
+        # This code needs a working tree, so we try not to run it unless required.
+        # That way, we are OK on a bare repository as well.
+        # If there are no paths, the rewriter has nothing to do either.
+        if paths:
+            entries_added.extend(self._entries_for_paths(paths, path_rewriter, fprogress, entries))
+
+        # HANDLE ENTRIES
+        if entries:
+            null_mode_entries = [e for e in entries if e.mode == 0]
+            if null_mode_entries:
+                raise ValueError(
+                    "At least one Entry has a null-mode - please use index.remove to remove files for clarity"
+                )
+            # END null mode should be remove
+
+            # HANDLE ENTRY OBJECT CREATION
+            # Create objects if required, otherwise go with the existing shas.
+            null_entries_indices = [i for i, e in enumerate(entries) if e.binsha == Object.NULL_BIN_SHA]
+            if null_entries_indices:
+
+                @git_working_dir
+                def handle_null_entries(self: "IndexFile") -> None:
+                    for ei in null_entries_indices:
+                        null_entry = entries[ei]
+                        new_entry = self._store_path(null_entry.path, fprogress)
+
+                        # Update null entry.
+                        entries[ei] = BaseIndexEntry(
+                            (
+                                null_entry.mode,
+                                new_entry.binsha,
+                                null_entry.stage,
+                                null_entry.path,
+                            )
+                        )
+                    # END for each entry index
+
+                # END closure
+
+                handle_null_entries(self)
+            # END null_entry handling
+
+            # REWRITE PATHS
+            # If we have to rewrite the entries, do so now, after we have generated all
+            # object sha's.
+            if path_rewriter:
+                for i, e in enumerate(entries):
+                    entries[i] = BaseIndexEntry((e.mode, e.binsha, e.stage, path_rewriter(e)))
+                # END for each entry
+            # END handle path rewriting
+
+            # Just go through the remaining entries and provide progress info.
+            for i, entry in enumerate(entries):
+                progress_sent = i in null_entries_indices
+                if not progress_sent:
+                    fprogress(entry.path, False, entry)
+                    fprogress(entry.path, True, entry)
+                # END handle progress
+            # END for each entry
+            entries_added.extend(entries)
+        # END if there are base entries
+
+        # FINALIZE
+        # Add the new entries to this instance.
+        for entry in entries_added:
+            self.entries[(entry.path, 0)] = IndexEntry.from_base(entry)
+
+        if write:
+            self.write(ignore_extension_data=not write_extension_data)
+        # END handle write
+
+        return entries_added
+
+    def _items_to_rela_paths(
+        self,
+        items: Union[PathLike, Sequence[Union[PathLike, BaseIndexEntry, Blob, Submodule]]],
+    ) -> List[PathLike]:
+        """Returns a list of repo-relative paths from the given items which
+        may be absolute or relative paths, entries or blobs."""
+        paths = []
+        # If string, put in list.
+        if isinstance(items, (str, os.PathLike)):
+            items = [items]
+
+        for item in items:
+            if isinstance(item, (BaseIndexEntry, (Blob, Submodule))):
+                paths.append(self._to_relative_path(item.path))
+            elif isinstance(item, (str, os.PathLike)):
+                paths.append(self._to_relative_path(item))
+            else:
+                raise TypeError("Invalid item type: %r" % item)
+        # END for each item
+        return paths
+
+    @post_clear_cache
+    @default_index
+    def remove(
+        self,
+        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
+        working_tree: bool = False,
+        **kwargs: Any,
+    ) -> List[str]:
+        R"""Remove the given items from the index and optionally from the working tree
+        as well.
+
+        :param items:
+            Multiple types of items are supported which may be be freely mixed.
+
+            - path string
+
+                Remove the given path at all stages. If it is a directory, you must
+                specify the ``r=True`` keyword argument to remove all file entries below
+                it. If absolute paths are given, they will be converted to a path
+                relative to the git repository directory containing the working tree
+
+                The path string may include globs, such as ``*.c``.
+
+            - :class:~`git.objects.blob.Blob` object
+
+                Only the path portion is used in this case.
+
+            - :class:`~git.index.typ.BaseIndexEntry` or compatible type
+
+                The only relevant information here is the path. The stage is ignored.
+
+        :param working_tree:
+            If ``True``, the entry will also be removed from the working tree,
+            physically removing the respective file. This may fail if there are
+            uncommitted changes in it.
+
+        :param kwargs:
+            Additional keyword arguments to be passed to :manpage:`git-rm(1)`, such as
+            ``r`` to allow recursive removal.
+
+        :return:
+            List(path_string, ...) list of repository relative paths that have been
+            removed effectively.
+
+            This is interesting to know in case you have provided a directory or globs.
+            Paths are relative to the repository.
+        """
+        args = []
+        if not working_tree:
+            args.append("--cached")
+        args.append("--")
+
+        # Preprocess paths.
+        paths = self._items_to_rela_paths(items)
+        removed_paths = self.repo.git.rm(args, paths, **kwargs).splitlines()
+
+        # Process output to gain proper paths.
+        # rm 'path'
+        return [p[4:-1] for p in removed_paths]
+
+    @post_clear_cache
+    @default_index
+    def move(
+        self,
+        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
+        skip_errors: bool = False,
+        **kwargs: Any,
+    ) -> List[Tuple[str, str]]:
+        """Rename/move the items, whereas the last item is considered the destination of
+        the move operation.
+
+        If the destination is a file, the first item (of two) must be a file as well.
+
+        If the destination is a directory, it may be preceded by one or more directories
+        or files.
+
+        The working tree will be affected in non-bare repositories.
+
+        :param items:
+            Multiple types of items are supported, please see the :meth:`remove` method
+            for reference.
+
+        :param skip_errors:
+            If ``True``, errors such as ones resulting from missing source files will be
+            skipped.
+
+        :param kwargs:
+            Additional arguments you would like to pass to :manpage:`git-mv(1)`, such as
+            ``dry_run`` or ``force``.
+
+        :return:
+            List(tuple(source_path_string, destination_path_string), ...)
+
+            A list of pairs, containing the source file moved as well as its actual
+            destination. Relative to the repository root.
+
+        :raise ValueError:
+            If only one item was given.
+
+        :raise git.exc.GitCommandError:
+            If git could not handle your request.
+        """
+        args = []
+        if skip_errors:
+            args.append("-k")
+
+        paths = self._items_to_rela_paths(items)
+        if len(paths) < 2:
+            raise ValueError("Please provide at least one source and one destination of the move operation")
+
+        was_dry_run = kwargs.pop("dry_run", kwargs.pop("n", None))
+        kwargs["dry_run"] = True
+
+        # First execute rename in dry run so the command tells us what it actually does
+        # (for later output).
+        out = []
+        mvlines = self.repo.git.mv(args, paths, **kwargs).splitlines()
+
+        # Parse result - first 0:n/2 lines are 'checking ', the remaining ones are the
+        # 'renaming' ones which we parse.
+        for ln in range(int(len(mvlines) / 2), len(mvlines)):
+            tokens = mvlines[ln].split(" to ")
+            assert len(tokens) == 2, "Too many tokens in %s" % mvlines[ln]
+
+            # [0] = Renaming x
+            # [1] = y
+            out.append((tokens[0][9:], tokens[1]))
+        # END for each line to parse
+
+        # Either prepare for the real run, or output the dry-run result.
+        if was_dry_run:
+            return out
+        # END handle dry run
+
+        # Now apply the actual operation.
+        kwargs.pop("dry_run")
+        self.repo.git.mv(args, paths, **kwargs)
+
+        return out
+
+    def commit(
+        self,
+        message: str,
+        parent_commits: Union[List[Commit], None] = None,
+        head: bool = True,
+        author: Union[None, "Actor"] = None,
+        committer: Union[None, "Actor"] = None,
+        author_date: Union[datetime.datetime, str, None] = None,
+        commit_date: Union[datetime.datetime, str, None] = None,
+        skip_hooks: bool = False,
+    ) -> Commit:
+        """Commit the current default index file, creating a
+        :class:`~git.objects.commit.Commit` object.
+
+        For more information on the arguments, see
+        :meth:`Commit.create_from_tree <git.objects.commit.Commit.create_from_tree>`.
+
+        :note:
+            If you have manually altered the :attr:`entries` member of this instance,
+            don't forget to :meth:`write` your changes to disk beforehand.
+
+        :note:
+            Passing ``skip_hooks=True`` is the equivalent of using ``-n`` or
+            ``--no-verify`` on the command line.
+
+        :return:
+            :class:`~git.objects.commit.Commit` object representing the new commit
+        """
+        if not skip_hooks:
+            run_commit_hook("pre-commit", self)
+
+            self._write_commit_editmsg(message)
+            run_commit_hook("commit-msg", self, self._commit_editmsg_filepath())
+            message = self._read_commit_editmsg()
+            self._remove_commit_editmsg()
+        tree = self.write_tree()
+        rval = Commit.create_from_tree(
+            self.repo,
+            tree,
+            message,
+            parent_commits,
+            head,
+            author=author,
+            committer=committer,
+            author_date=author_date,
+            commit_date=commit_date,
+        )
+        if not skip_hooks:
+            run_commit_hook("post-commit", self)
+        return rval
+
+    def _write_commit_editmsg(self, message: str) -> None:
+        with open(self._commit_editmsg_filepath(), "wb") as commit_editmsg_file:
+            commit_editmsg_file.write(message.encode(defenc))
+
+    def _remove_commit_editmsg(self) -> None:
+        os.remove(self._commit_editmsg_filepath())
+
+    def _read_commit_editmsg(self) -> str:
+        with open(self._commit_editmsg_filepath(), "rb") as commit_editmsg_file:
+            return commit_editmsg_file.read().decode(defenc)
+
+    def _commit_editmsg_filepath(self) -> str:
+        return osp.join(self.repo.common_dir, "COMMIT_EDITMSG")
+
+    def _flush_stdin_and_wait(cls, proc: "Popen[bytes]", ignore_stdout: bool = False) -> bytes:
+        stdin_IO = proc.stdin
+        if stdin_IO:
+            stdin_IO.flush()
+            stdin_IO.close()
+
+        stdout = b""
+        if not ignore_stdout and proc.stdout:
+            stdout = proc.stdout.read()
+
+        if proc.stdout:
+            proc.stdout.close()
+            proc.wait()
+        return stdout
+
+    @default_index
+    def checkout(
+        self,
+        paths: Union[None, Iterable[PathLike]] = None,
+        force: bool = False,
+        fprogress: Callable = lambda *args: None,
+        **kwargs: Any,
+    ) -> Union[None, Iterator[PathLike], Sequence[PathLike]]:
+        """Check out the given paths or all files from the version known to the index
+        into the working tree.
+
+        :note:
+            Be sure you have written pending changes using the :meth:`write` method in
+            case you have altered the entries dictionary directly.
+
+        :param paths:
+            If ``None``, all paths in the index will be checked out.
+            Otherwise an iterable of relative or absolute paths or a single path
+            pointing to files or directories in the index is expected.
+
+        :param force:
+            If ``True``, existing files will be overwritten even if they contain local
+            modifications.
+            If ``False``, these will trigger a :exc:`~git.exc.CheckoutError`.
+
+        :param fprogress:
+            See :meth:`IndexFile.add` for signature and explanation.
+
+            The provided progress information will contain ``None`` as path and item if
+            no explicit paths are given. Otherwise progress information will be send
+            prior and after a file has been checked out.
+
+        :param kwargs:
+            Additional arguments to be passed to :manpage:`git-checkout-index(1)`.
+
+        :return:
+            Iterable yielding paths to files which have been checked out and are
+            guaranteed to match the version stored in the index.
+
+        :raise git.exc.CheckoutError:
+            * If at least one file failed to be checked out. This is a summary, hence it
+              will checkout as many files as it can anyway.
+            * If one of files or directories do not exist in the index (as opposed to
+              the original git command, which ignores them).
+
+        :raise git.exc.GitCommandError:
+            If error lines could not be parsed - this truly is an exceptional state.
+
+        :note:
+            The checkout is limited to checking out the files in the index. Files which
+            are not in the index anymore and exist in the working tree will not be
+            deleted. This behaviour is fundamentally different to ``head.checkout``,
+            i.e. if you want :manpage:`git-checkout(1)`-like behaviour, use
+            ``head.checkout`` instead of ``index.checkout``.
+        """
+        args = ["--index"]
+        if force:
+            args.append("--force")
+
+        failed_files = []
+        failed_reasons = []
+        unknown_lines = []
+
+        def handle_stderr(proc: "Popen[bytes]", iter_checked_out_files: Iterable[PathLike]) -> None:
+            stderr_IO = proc.stderr
+            if not stderr_IO:
+                return  # Return early if stderr empty.
+
+            stderr_bytes = stderr_IO.read()
+            # line contents:
+            stderr = stderr_bytes.decode(defenc)
+            # git-checkout-index: this already exists
+            endings = (
+                " already exists",
+                " is not in the cache",
+                " does not exist at stage",
+                " is unmerged",
+            )
+            for line in stderr.splitlines():
+                if not line.startswith("git checkout-index: ") and not line.startswith("git-checkout-index: "):
+                    is_a_dir = " is a directory"
+                    unlink_issue = "unable to unlink old '"
+                    already_exists_issue = " already exists, no checkout"  # created by entry.c:checkout_entry(...)
+                    if line.endswith(is_a_dir):
+                        failed_files.append(line[: -len(is_a_dir)])
+                        failed_reasons.append(is_a_dir)
+                    elif line.startswith(unlink_issue):
+                        failed_files.append(line[len(unlink_issue) : line.rfind("'")])
+                        failed_reasons.append(unlink_issue)
+                    elif line.endswith(already_exists_issue):
+                        failed_files.append(line[: -len(already_exists_issue)])
+                        failed_reasons.append(already_exists_issue)
+                    else:
+                        unknown_lines.append(line)
+                    continue
+                # END special lines parsing
+
+                for e in endings:
+                    if line.endswith(e):
+                        failed_files.append(line[20 : -len(e)])
+                        failed_reasons.append(e)
+                        break
+                    # END if ending matches
+                # END for each possible ending
+            # END for each line
+            if unknown_lines:
+                raise GitCommandError(("git-checkout-index",), 128, stderr)
+            if failed_files:
+                valid_files = list(set(iter_checked_out_files) - set(failed_files))
+                raise CheckoutError(
+                    "Some files could not be checked out from the index due to local modifications",
+                    failed_files,
+                    valid_files,
+                    failed_reasons,
+                )
+
+        # END stderr handler
+
+        if paths is None:
+            args.append("--all")
+            kwargs["as_process"] = 1
+            fprogress(None, False, None)
+            proc = self.repo.git.checkout_index(*args, **kwargs)
+            proc.wait()
+            fprogress(None, True, None)
+            rval_iter = (e.path for e in self.entries.values())
+            handle_stderr(proc, rval_iter)
+            return rval_iter
+        else:
+            if isinstance(paths, str):
+                paths = [paths]
+
+            # Make sure we have our entries loaded before we start checkout_index, which
+            # will hold a lock on it. We try to get the lock as well during our entries
+            # initialization.
+            self.entries  # noqa: B018
+
+            args.append("--stdin")
+            kwargs["as_process"] = True
+            kwargs["istream"] = subprocess.PIPE
+            proc = self.repo.git.checkout_index(args, **kwargs)
+            # FIXME: Reading from GIL!
+            make_exc = lambda: GitCommandError(("git-checkout-index",) + tuple(args), 128, proc.stderr.read())
+            checked_out_files: List[PathLike] = []
+
+            for path in paths:
+                co_path = to_native_path_linux(self._to_relative_path(path))
+                # If the item is not in the index, it could be a directory.
+                path_is_directory = False
+
+                try:
+                    self.entries[(co_path, 0)]
+                except KeyError:
+                    folder = str(co_path)
+                    if not folder.endswith("/"):
+                        folder += "/"
+                    for entry in self.entries.values():
+                        if str(entry.path).startswith(folder):
+                            p = entry.path
+                            self._write_path_to_stdin(proc, p, p, make_exc, fprogress, read_from_stdout=False)
+                            checked_out_files.append(p)
+                            path_is_directory = True
+                        # END if entry is in directory
+                    # END for each entry
+                # END path exception handlnig
+
+                if not path_is_directory:
+                    self._write_path_to_stdin(proc, co_path, path, make_exc, fprogress, read_from_stdout=False)
+                    checked_out_files.append(co_path)
+                # END path is a file
+            # END for each path
+            try:
+                self._flush_stdin_and_wait(proc, ignore_stdout=True)
+            except GitCommandError:
+                # Without parsing stdout we don't know what failed.
+                raise CheckoutError(  # noqa: B904
+                    "Some files could not be checked out from the index, probably because they didn't exist.",
+                    failed_files,
+                    [],
+                    failed_reasons,
+                )
+
+            handle_stderr(proc, checked_out_files)
+            return checked_out_files
+        # END paths handling
+
+    @default_index
+    def reset(
+        self,
+        commit: Union[Commit, "Reference", str] = "HEAD",
+        working_tree: bool = False,
+        paths: Union[None, Iterable[PathLike]] = None,
+        head: bool = False,
+        **kwargs: Any,
+    ) -> "IndexFile":
+        """Reset the index to reflect the tree at the given commit. This will not adjust
+        our HEAD reference by default, as opposed to
+        :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
+
+        :param commit:
+            Revision, :class:`~git.refs.reference.Reference` or
+            :class:`~git.objects.commit.Commit` specifying the commit we should
+            represent.
+
+            If you want to specify a tree only, use :meth:`IndexFile.from_tree` and
+            overwrite the default index.
+
+        :param working_tree:
+            If ``True``, the files in the working tree will reflect the changed index.
+            If ``False``, the working tree will not be touched.
+            Please note that changes to the working copy will be discarded without
+            warning!
+
+        :param head:
+            If ``True``, the head will be set to the given commit. This is ``False`` by
+            default, but if ``True``, this method behaves like
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
+
+        :param paths:
+            If given as an iterable of absolute or repository-relative paths, only these
+            will be reset to their state at the given commit-ish.
+            The paths need to exist at the commit, otherwise an exception will be
+            raised.
+
+        :param kwargs:
+            Additional keyword arguments passed to :manpage:`git-reset(1)`.
+
+        :note:
+            :meth:`IndexFile.reset`, as opposed to
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`, will not delete any files in
+            order to maintain a consistent working tree. Instead, it will just check out
+            the files according to their state in the index.
+            If you want :manpage:`git-reset(1)`-like behaviour, use
+            :meth:`HEAD.reset <git.refs.head.HEAD.reset>` instead.
+
+        :return:
+            self
+        """
+        # What we actually want to do is to merge the tree into our existing index,
+        # which is what git-read-tree does.
+        new_inst = type(self).from_tree(self.repo, commit)
+        if not paths:
+            self.entries = new_inst.entries
+        else:
+            nie = new_inst.entries
+            for path in paths:
+                path = self._to_relative_path(path)
+                try:
+                    key = entry_key(path, 0)
+                    self.entries[key] = nie[key]
+                except KeyError:
+                    # If key is not in theirs, it musn't be in ours.
+                    try:
+                        del self.entries[key]
+                    except KeyError:
+                        pass
+                    # END handle deletion keyerror
+                # END handle keyerror
+            # END for each path
+        # END handle paths
+        self.write()
+
+        if working_tree:
+            self.checkout(paths=paths, force=True)
+        # END handle working tree
+
+        if head:
+            self.repo.head.set_commit(self.repo.commit(commit), logmsg="%s: Updating HEAD" % commit)
+        # END handle head change
+
+        return self
+
+    # FIXME: This is documented to accept the same parameters as Diffable.diff, but this
+    # does not handle NULL_TREE for `other`. (The suppressed mypy error is about this.)
+    def diff(
+        self,
+        other: Union[  # type: ignore[override]
+            Literal[git_diff.DiffConstants.INDEX],
+            "Tree",
+            "Commit",
+            str,
+            None,
+        ] = git_diff.INDEX,
+        paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
+        create_patch: bool = False,
+        **kwargs: Any,
+    ) -> git_diff.DiffIndex:
+        """Diff this index against the working copy or a :class:`~git.objects.tree.Tree`
+        or :class:`~git.objects.commit.Commit` object.
+
+        For documentation of the parameters and return values, see
+        :meth:`Diffable.diff <git.diff.Diffable.diff>`.
+
+        :note:
+            Will only work with indices that represent the default git index as they
+            have not been initialized with a stream.
+        """
+        # Only run if we are the default repository index.
+        if self._file_path != self._index_path():
+            raise AssertionError("Cannot call %r on indices that do not represent the default git index" % self.diff())
+        # Index against index is always empty.
+        if other is self.INDEX:
+            return git_diff.DiffIndex()
+
+        # Index against anything but None is a reverse diff with the respective item.
+        # Handle existing -R flags properly.
+        # Transform strings to the object so that we can call diff on it.
+        if isinstance(other, str):
+            other = self.repo.rev_parse(other)
+        # END object conversion
+
+        if isinstance(other, Object):  # For Tree or Commit.
+            # Invert the existing R flag.
+            cur_val = kwargs.get("R", False)
+            kwargs["R"] = not cur_val
+            return other.diff(self.INDEX, paths, create_patch, **kwargs)
+        # END diff against other item handling
+
+        # If other is not None here, something is wrong.
+        if other is not None:
+            raise ValueError("other must be None, Diffable.INDEX, a Tree or Commit, was %r" % other)
+
+        # Diff against working copy - can be handled by superclass natively.
+        return super().diff(other, paths, create_patch, **kwargs)

parrot/lib/python3.10/site-packages/git/index/util.py

@@ -0,0 +1,121 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Index utilities."""
+
+__all__ = ["TemporaryFileSwap", "post_clear_cache", "default_index", "git_working_dir"]
+
+import contextlib
+from functools import wraps
+import os
+import os.path as osp
+import struct
+import tempfile
+from types import TracebackType
+
+# typing ----------------------------------------------------------------------
+
+from typing import Any, Callable, TYPE_CHECKING, Optional, Type
+
+from git.types import Literal, PathLike, _T
+
+if TYPE_CHECKING:
+    from git.index import IndexFile
+
+# ---------------------------------------------------------------------------------
+
+# { Aliases
+pack = struct.pack
+unpack = struct.unpack
+# } END aliases
+
+
+class TemporaryFileSwap:
+    """Utility class moving a file to a temporary location within the same directory and
+    moving it back on to where on object deletion."""
+
+    __slots__ = ("file_path", "tmp_file_path")
+
+    def __init__(self, file_path: PathLike) -> None:
+        self.file_path = file_path
+        dirname, basename = osp.split(file_path)
+        fd, self.tmp_file_path = tempfile.mkstemp(prefix=basename, dir=dirname)
+        os.close(fd)
+        with contextlib.suppress(OSError):  # It may be that the source does not exist.
+            os.replace(self.file_path, self.tmp_file_path)
+
+    def __enter__(self) -> "TemporaryFileSwap":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Literal[False]:
+        if osp.isfile(self.tmp_file_path):
+            os.replace(self.tmp_file_path, self.file_path)
+        return False
+
+
+# { Decorators
+
+
+def post_clear_cache(func: Callable[..., _T]) -> Callable[..., _T]:
+    """Decorator for functions that alter the index using the git command.
+
+    When a git command alters the index, this invalidates our possibly existing entries
+    dictionary, which is why it must be deleted to allow it to be lazily reread later.
+    """
+
+    @wraps(func)
+    def post_clear_cache_if_not_raised(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
+        rval = func(self, *args, **kwargs)
+        self._delete_entries_cache()
+        return rval
+
+    # END wrapper method
+
+    return post_clear_cache_if_not_raised
+
+
+def default_index(func: Callable[..., _T]) -> Callable[..., _T]:
+    """Decorator ensuring the wrapped method may only run if we are the default
+    repository index.
+
+    This is as we rely on git commands that operate on that index only.
+    """
+
+    @wraps(func)
+    def check_default_index(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
+        if self._file_path != self._index_path():
+            raise AssertionError(
+                "Cannot call %r on indices that do not represent the default git index" % func.__name__
+            )
+        return func(self, *args, **kwargs)
+
+    # END wrapper method
+
+    return check_default_index
+
+
+def git_working_dir(func: Callable[..., _T]) -> Callable[..., _T]:
+    """Decorator which changes the current working dir to the one of the git
+    repository in order to ensure relative paths are handled correctly."""
+
+    @wraps(func)
+    def set_git_working_dir(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
+        cur_wd = os.getcwd()
+        os.chdir(str(self.repo.working_tree_dir))
+        try:
+            return func(self, *args, **kwargs)
+        finally:
+            os.chdir(cur_wd)
+        # END handle working dir
+
+    # END wrapper
+
+    return set_git_working_dir
+
+
+# } END decorators

parrot/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-310.pyc

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

parrot/lib/python3.10/site-packages/imageio/__init__.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-2020, imageio contributors
+# imageio is distributed under the terms of the (new) BSD License.
+
+# This docstring is used at the index of the documentation pages, and
+# gets inserted into a slightly larger description (in setup.py) for
+# the page on Pypi:
+"""
+Imageio is a Python library that provides an easy interface to read and
+write a wide range of image data, including animated images, volumetric
+data, and scientific formats. It is cross-platform, runs on Python 3.5+,
+and is easy to install.
+
+Main website: https://imageio.readthedocs.io/
+"""
+
+# flake8: noqa
+
+__version__ = "2.35.1"
+
+import warnings
+
+# Load some bits from core
+from .core import FormatManager, RETURN_BYTES
+
+# Instantiate the old format manager
+formats = FormatManager()
+show_formats = formats.show
+
+from . import v2
+from . import v3
+from . import plugins
+
+# import config after core to avoid circular import
+from . import config
+
+# import all APIs into the top level (meta API)
+from .v2 import (
+    imread as imread_v2,
+    mimread,
+    volread,
+    mvolread,
+    imwrite,
+    mimwrite,
+    volwrite,
+    mvolwrite,
+    # aliases
+    get_reader as read,
+    get_writer as save,
+    imwrite as imsave,
+    mimwrite as mimsave,
+    volwrite as volsave,
+    mvolwrite as mvolsave,
+    # misc
+    help,
+    get_reader,
+    get_writer,
+)
+from .v3 import (
+    imopen,
+    # imread,  # Will take over once v3 is released
+    # imwrite, # Will take over once v3 is released
+    imiter,
+)
+
+
+def imread(uri, format=None, **kwargs):
+    """imread(uri, format=None, **kwargs)
+
+    Reads an image from the specified file. Returns a numpy array, which
+    comes with a dict of meta data at its 'meta' attribute.
+
+    Note that the image data is returned as-is, and may not always have
+    a dtype of uint8 (and thus may differ from what e.g. PIL returns).
+
+    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.
+    format : str
+        The format to use to read the file. By default imageio selects
+        the appropriate for you based on the filename and its contents.
+    kwargs : ...
+        Further keyword arguments are passed to the reader. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    warnings.warn(
+        "Starting with ImageIO v3 the behavior of this function will switch to that of"
+        " iio.v3.imread. To keep the current behavior (and make this warning disappear)"
+        " use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    return imread_v2(uri, format=format, **kwargs)
+
+
+__all__ = [
+    "v2",
+    "v3",
+    "config",
+    "plugins",
+    # v3 API
+    "imopen",
+    "imread",
+    "imwrite",
+    "imiter",
+    # v2 API
+    "mimread",
+    "volread",
+    "mvolread",
+    "imwrite",
+    "mimwrite",
+    "volwrite",
+    "mvolwrite",
+    # v2 aliases
+    "read",
+    "save",
+    "imsave",
+    "mimsave",
+    "volsave",
+    "mvolsave",
+    # functions to deprecate
+    "help",
+    "get_reader",
+    "get_writer",
+    "formats",
+    "show_formats",
+]

parrot/lib/python3.10/site-packages/imageio/__main__.py

@@ -0,0 +1,169 @@
+"""
+Console scripts and associated helper methods for imageio.
+"""
+
+import argparse
+import os
+from os import path as op
+import shutil
+import sys
+
+
+from . import plugins
+from .core import util
+
+# A list of plugins that require binaries from the imageio-binaries
+# repository. These plugins must implement the `download` method.
+PLUGINS_WITH_BINARIES = ["freeimage"]
+
+
+def download_bin(plugin_names=["all"], package_dir=False):
+    """Download binary dependencies of plugins
+
+    This is a convenience method for downloading the binaries
+    (e.g. for freeimage) from the imageio-binaries
+    repository.
+
+    Parameters
+    ----------
+    plugin_names: list
+        A list of imageio plugin names. If it contains "all", all
+        binary dependencies are downloaded.
+    package_dir: bool
+        If set to `True`, the binaries will be downloaded to the
+        `resources` directory of the imageio package instead of
+        to the users application data directory. Note that this
+        might require administrative rights if imageio is installed
+        in a system directory.
+    """
+    if plugin_names.count("all"):
+        # Use all plugins
+        plugin_names = PLUGINS_WITH_BINARIES
+
+    plugin_names.sort()
+    print("Ascertaining binaries for: {}.".format(", ".join(plugin_names)))
+
+    if package_dir:
+        # Download the binaries to the `resources` directory
+        # of imageio. If imageio comes as an .egg, then a cache
+        # directory will be created by pkg_resources (requires setuptools).
+        # see `imageio.core.util.resource_dirs`
+        # and `imageio.core.utilresource_package_dir`
+        directory = util.resource_package_dir()
+    else:
+        directory = None
+
+    for plg in plugin_names:
+        if plg not in PLUGINS_WITH_BINARIES:
+            msg = "Plugin {} not registered for binary download!".format(plg)
+            raise Exception(msg)
+        mod = getattr(plugins, plg)
+        mod.download(directory=directory)
+
+
+def download_bin_main():
+    """Argument-parsing wrapper for `download_bin`"""
+    description = "Download plugin binary dependencies"
+    phelp = (
+        "Plugin name for which to download the binary. "
+        + "If no argument is given, all binaries are downloaded."
+    )
+    dhelp = (
+        "Download the binaries to the package directory "
+        + "(default is the users application data directory). "
+        + "This might require administrative rights."
+    )
+    example_text = (
+        "examples:\n"
+        + "  imageio_download_bin all\n"
+        + "  imageio_download_bin freeimage\n"
+    )
+    parser = argparse.ArgumentParser(
+        description=description,
+        epilog=example_text,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("plugin", type=str, nargs="*", default="all", help=phelp)
+    parser.add_argument(
+        "--package-dir",
+        dest="package_dir",
+        action="store_true",
+        default=False,
+        help=dhelp,
+    )
+    args = parser.parse_args()
+    download_bin(plugin_names=args.plugin, package_dir=args.package_dir)
+
+
+def remove_bin(plugin_names=["all"]):
+    """Remove binary dependencies of plugins
+
+    This is a convenience method that removes all binaries
+    dependencies for plugins downloaded by imageio.
+
+    Notes
+    -----
+    It only makes sense to use this method if the binaries
+    are corrupt.
+    """
+    if plugin_names.count("all"):
+        # Use all plugins
+        plugin_names = PLUGINS_WITH_BINARIES
+
+    print("Removing binaries for: {}.".format(", ".join(plugin_names)))
+
+    rdirs = util.resource_dirs()
+
+    for plg in plugin_names:
+        if plg not in PLUGINS_WITH_BINARIES:
+            msg = "Plugin {} not registered for binary download!".format(plg)
+            raise Exception(msg)
+
+    not_removed = []
+    for rd in rdirs:
+        # plugin name is in subdirectories
+        for rsub in os.listdir(rd):
+            if rsub in plugin_names:
+                plgdir = op.join(rd, rsub)
+                try:
+                    shutil.rmtree(plgdir)
+                except Exception:
+                    not_removed.append(plgdir)
+    if not_removed:
+        nrs = ",".join(not_removed)
+        msg2 = (
+            "These plugins files could not be removed: {}\n".format(nrs)
+            + "Make sure they are not used by any program and try again."
+        )
+        raise Exception(msg2)
+
+
+def remove_bin_main():
+    """Argument-parsing wrapper for `remove_bin`"""
+    description = "Remove plugin binary dependencies"
+    phelp = (
+        "Plugin name for which to remove the binary. "
+        + "If no argument is given, all binaries are removed."
+    )
+    example_text = (
+        "examples:\n"
+        + "  imageio_remove_bin all\n"
+        + "  imageio_remove_bin freeimage\n"
+    )
+    parser = argparse.ArgumentParser(
+        description=description,
+        epilog=example_text,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("plugin", type=str, nargs="*", default="all", help=phelp)
+    args = parser.parse_args()
+    remove_bin(plugin_names=args.plugin)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "download_bin":
+        download_bin_main()
+    elif len(sys.argv) > 1 and sys.argv[1] == "remove_bin":
+        remove_bin_main()
+    else:
+        raise RuntimeError("Invalid use of the imageio CLI")

parrot/lib/python3.10/site-packages/imageio/config/__init__.py

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

parrot/lib/python3.10/site-packages/imageio/config/extensions.py

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

parrot/lib/python3.10/site-packages/imageio/config/extensions.pyi

@@ -0,0 +1,24 @@
+from typing import List, Dict, Optional
+
+class FileExtension:
+    extension: str
+    priority: List[str]
+    name: Optional[str] = None
+    description: Optional[str] = None
+    external_link: Optional[str] = None
+    volume_support: bool
+
+    def __init__(
+        self,
+        *,
+        extension: str,
+        priority: List[str],
+        name: str = None,
+        description: str = None,
+        external_link: str = None
+    ) -> None: ...
+    def reset(self) -> None: ...
+
+extension_list: List[FileExtension]
+known_extensions: Dict[str, List[FileExtension]]
+video_extensions: List[FileExtension]

parrot/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]

parrot/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]

parrot/lib/python3.10/site-packages/imageio/freeze.py

@@ -0,0 +1,11 @@
+"""
+Helper functions for freezing imageio.
+"""
+
+
+def get_includes():
+    return ["email", "urllib.request", "numpy", "zipfile", "io"]
+
+
+def get_excludes():
+    return []

parrot/lib/python3.10/site-packages/imageio/plugins/__init__.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+# flake8: noqa
+
+"""
+Here you can find documentation on how to write your own plugin to allow
+ImageIO to access a new backend. Plugins are quite object oriented, and
+the relevant classes and their interaction are documented here:
+
+.. currentmodule:: imageio
+
+.. autosummary::
+    :toctree: ../_autosummary
+    :template: better_class.rst
+
+    imageio.core.Format
+    imageio.core.Request
+
+.. note::
+    You can always check existing plugins if you want to see examples.
+
+What methods to implement
+-------------------------
+
+To implement a new plugin, create a new class that inherits from
+:class:`imageio.core.Format`. and implement the following functions:
+
+.. autosummary::
+    :toctree: ../_autosummary
+
+    imageio.core.Format.__init__
+    imageio.core.Format._can_read
+    imageio.core.Format._can_write
+
+Further, each format contains up to two nested classes; one for reading and
+one for writing. To support reading and/or writing, the respective classes
+need to be defined.
+
+For reading, create a nested class that inherits from
+``imageio.core.Format.Reader`` and that implements the following functions:
+
+    * Implement ``_open(**kwargs)`` to initialize the reader. Deal with the
+        user-provided keyword arguments here.
+    * Implement ``_close()`` to clean up.
+    * Implement ``_get_length()`` to provide a suitable length based on what
+        the user expects. Can be ``inf`` for streaming data.
+    * Implement ``_get_data(index)`` to return an array and a meta-data dict.
+    * Implement ``_get_meta_data(index)`` to return a meta-data dict. If index
+        is None, it should return the 'global' meta-data.
+
+For writing, create a nested class that inherits from
+``imageio.core.Format.Writer`` and implement the following functions:
+
+    * Implement ``_open(**kwargs)`` to initialize the writer. Deal with the
+        user-provided keyword arguments here.
+    * Implement ``_close()`` to clean up.
+    * Implement ``_append_data(im, meta)`` to add data (and meta-data).
+    * Implement ``_set_meta_data(meta)`` to set the global meta-data.
+
+"""
+
+import importlib
+import os
+import warnings
+
+
+# v2 imports remove in v3
+from .. import formats
+
+# v2 allows formatting plugins by environment variable
+# this is done here.
+env_plugin_order = os.getenv("IMAGEIO_FORMAT_ORDER", None)
+if env_plugin_order is not None:  # pragma: no cover
+    warnings.warn(
+        "Setting plugin priority through an environment variable is"
+        " deprecated and will be removed in ImageIO v3. There is no"
+        " replacement planned for this feature. If you have an"
+        " active use-case for it, please reach out to us on GitHub.",
+        DeprecationWarning,
+    )
+
+    formats.sort(*os.getenv("IMAGEIO_FORMAT_ORDER", "").split(","))
+
+
+# this class replaces plugin module. For details
+# see https://stackoverflow.com/questions/2447353/getattr-on-a-module
+def __getattr__(name):
+    """Lazy-Import Plugins
+
+    This function dynamically loads plugins into the imageio.plugin
+    namespace upon first access. For example, the following snippet will
+    delay importing freeimage until the second line:
+
+    >>> import imageio
+    >>> imageio.plugins.freeimage.download()
+
+    """
+
+    try:
+        return importlib.import_module(f"imageio.plugins.{name}")
+    except ImportError:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'") from None

parrot/lib/python3.10/site-packages/imageio/plugins/_bsdf.py

@@ -0,0 +1,915 @@
+#!/usr/bin/env python
+# This file is distributed under the terms of the 2-clause BSD License.
+# Copyright (c) 2017-2018, Almar Klein
+
+"""
+Python implementation of the Binary Structured Data Format (BSDF).
+
+BSDF is a binary format for serializing structured (scientific) data.
+See http://bsdf.io for more information.
+
+This is the reference implementation, which is relatively relatively
+sophisticated, providing e.g. lazy loading of blobs and streamed
+reading/writing. A simpler Python implementation is available as
+``bsdf_lite.py``.
+
+This module has no dependencies and works on Python 2.7 and 3.4+.
+
+Note: on Legacy Python (Python 2.7), non-Unicode strings are encoded as bytes.
+"""
+
+# todo: in 2020, remove six stuff, __future__ and _isidentifier
+# todo: in 2020, remove 'utf-8' args to encode/decode; it's faster
+
+from __future__ import absolute_import, division, print_function
+
+import bz2
+import hashlib
+import logging
+import os
+import re
+import struct
+import sys
+import types
+import zlib
+from io import BytesIO
+
+logger = logging.getLogger(__name__)
+
+# Notes on versioning: the major and minor numbers correspond to the
+# BSDF format version. The major number if increased when backward
+# incompatible changes are introduced. An implementation must raise an
+# exception when the file being read has a higher major version. The
+# minor number is increased when new backward compatible features are
+# introduced. An implementation must display a warning when the file
+# being read has a higher minor version. The patch version is increased
+# for subsequent releases of the implementation.
+VERSION = 2, 1, 2
+__version__ = ".".join(str(i) for i in VERSION)
+
+
+# %% The encoder and decoder implementation
+
+# From six.py
+PY3 = sys.version_info[0] >= 3
+if PY3:
+    text_type = str
+    string_types = str
+    unicode_types = str
+    integer_types = int
+    classtypes = type
+else:  # pragma: no cover
+    logging.basicConfig()  # avoid "no handlers found" error
+    text_type = unicode  # noqa
+    string_types = basestring  # noqa
+    unicode_types = unicode  # noqa
+    integer_types = (int, long)  # noqa
+    classtypes = type, types.ClassType
+
+# Shorthands
+spack = struct.pack
+strunpack = struct.unpack
+
+
+def lencode(x):
+    """Encode an unsigned integer into a variable sized blob of bytes."""
+    # We could support 16 bit and 32 bit as well, but the gain is low, since
+    # 9 bytes for collections with over 250 elements is marginal anyway.
+    if x <= 250:
+        return spack("<B", x)
+    # elif x < 65536:
+    #     return spack('<BH', 251, x)
+    # elif x < 4294967296:
+    #     return spack('<BI', 252, x)
+    else:
+        return spack("<BQ", 253, x)
+
+
+# Include len decoder for completeness; we've inlined it for performance.
+def lendecode(f):
+    """Decode an unsigned integer from a file."""
+    n = strunpack("<B", f.read(1))[0]
+    if n == 253:
+        n = strunpack("<Q", f.read(8))[0]  # noqa
+    return n
+
+
+def encode_type_id(b, ext_id):
+    """Encode the type identifier, with or without extension id."""
+    if ext_id is not None:
+        bb = ext_id.encode("UTF-8")
+        return b.upper() + lencode(len(bb)) + bb  # noqa
+    else:
+        return b  # noqa
+
+
+def _isidentifier(s):  # pragma: no cover
+    """Use of str.isidentifier() for Legacy Python, but slower."""
+    # http://stackoverflow.com/questions/2544972/
+    return (
+        isinstance(s, string_types)
+        and re.match(r"^\w+$", s, re.UNICODE)
+        and re.match(r"^[0-9]", s) is None
+    )
+
+
+class BsdfSerializer(object):
+    """Instances of this class represent a BSDF encoder/decoder.
+
+    It acts as a placeholder for a set of extensions and encoding/decoding
+    options. Use this to predefine extensions and options for high
+    performance encoding/decoding. For general use, see the functions
+    `save()`, `encode()`, `load()`, and `decode()`.
+
+    This implementation of BSDF supports streaming lists (keep adding
+    to a list after writing the main file), lazy loading of blobs, and
+    in-place editing of blobs (for streams opened with a+).
+
+    Options for encoding:
+
+    * compression (int or str): ``0`` or "no" for no compression (default),
+      ``1`` or "zlib" for Zlib compression (same as zip files and PNG), and
+      ``2`` or "bz2" for Bz2 compression (more compact but slower writing).
+      Note that some BSDF implementations (e.g. JavaScript) may not support
+      compression.
+    * use_checksum (bool): whether to include a checksum with binary blobs.
+    * float64 (bool): Whether to write floats as 64 bit (default) or 32 bit.
+
+    Options for decoding:
+
+    * load_streaming (bool): if True, and the final object in the structure was
+      a stream, will make it available as a stream in the decoded object.
+    * lazy_blob (bool): if True, bytes are represented as Blob objects that can
+      be used to lazily access the data, and also overwrite the data if the
+      file is open in a+ mode.
+    """
+
+    def __init__(self, extensions=None, **options):
+        self._extensions = {}  # name -> extension
+        self._extensions_by_cls = {}  # cls -> (name, extension.encode)
+        if extensions is None:
+            extensions = standard_extensions
+        for extension in extensions:
+            self.add_extension(extension)
+        self._parse_options(**options)
+
+    def _parse_options(
+        self,
+        compression=0,
+        use_checksum=False,
+        float64=True,
+        load_streaming=False,
+        lazy_blob=False,
+    ):
+        # Validate compression
+        if isinstance(compression, string_types):
+            m = {"no": 0, "zlib": 1, "bz2": 2}
+            compression = m.get(compression.lower(), compression)
+        if compression not in (0, 1, 2):
+            raise TypeError("Compression must be 0, 1, 2, " '"no", "zlib", or "bz2"')
+        self._compression = compression
+
+        # Other encoding args
+        self._use_checksum = bool(use_checksum)
+        self._float64 = bool(float64)
+
+        # Decoding args
+        self._load_streaming = bool(load_streaming)
+        self._lazy_blob = bool(lazy_blob)
+
+    def add_extension(self, extension_class):
+        """Add an extension to this serializer instance, which must be
+        a subclass of Extension. Can be used as a decorator.
+        """
+        # Check class
+        if not (
+            isinstance(extension_class, type) and issubclass(extension_class, Extension)
+        ):
+            raise TypeError("add_extension() expects a Extension class.")
+        extension = extension_class()
+
+        # Get name
+        name = extension.name
+        if not isinstance(name, str):
+            raise TypeError("Extension name must be str.")
+        if len(name) == 0 or len(name) > 250:
+            raise NameError(
+                "Extension names must be nonempty and shorter " "than 251 chars."
+            )
+        if name in self._extensions:
+            logger.warning(
+                'BSDF warning: overwriting extension "%s", '
+                "consider removing first" % name
+            )
+
+        # Get classes
+        cls = extension.cls
+        if not cls:
+            clss = []
+        elif isinstance(cls, (tuple, list)):
+            clss = cls
+        else:
+            clss = [cls]
+        for cls in clss:
+            if not isinstance(cls, classtypes):
+                raise TypeError("Extension classes must be types.")
+
+        # Store
+        for cls in clss:
+            self._extensions_by_cls[cls] = name, extension.encode
+        self._extensions[name] = extension
+        return extension_class
+
+    def remove_extension(self, name):
+        """Remove a converted by its unique name."""
+        if not isinstance(name, str):
+            raise TypeError("Extension name must be str.")
+        if name in self._extensions:
+            self._extensions.pop(name)
+        for cls in list(self._extensions_by_cls.keys()):
+            if self._extensions_by_cls[cls][0] == name:
+                self._extensions_by_cls.pop(cls)
+
+    def _encode(self, f, value, streams, ext_id):
+        """Main encoder function."""
+        x = encode_type_id
+
+        if value is None:
+            f.write(x(b"v", ext_id))  # V for void
+        elif value is True:
+            f.write(x(b"y", ext_id))  # Y for yes
+        elif value is False:
+            f.write(x(b"n", ext_id))  # N for no
+        elif isinstance(value, integer_types):
+            if -32768 <= value <= 32767:
+                f.write(x(b"h", ext_id) + spack("h", value))  # H for ...
+            else:
+                f.write(x(b"i", ext_id) + spack("<q", value))  # I for int
+        elif isinstance(value, float):
+            if self._float64:
+                f.write(x(b"d", ext_id) + spack("<d", value))  # D for double
+            else:
+                f.write(x(b"f", ext_id) + spack("<f", value))  # f for float
+        elif isinstance(value, unicode_types):
+            bb = value.encode("UTF-8")
+            f.write(x(b"s", ext_id) + lencode(len(bb)))  # S for str
+            f.write(bb)
+        elif isinstance(value, (list, tuple)):
+            f.write(x(b"l", ext_id) + lencode(len(value)))  # L for list
+            for v in value:
+                self._encode(f, v, streams, None)
+        elif isinstance(value, dict):
+            f.write(x(b"m", ext_id) + lencode(len(value)))  # M for mapping
+            for key, v in value.items():
+                if PY3:
+                    assert key.isidentifier()  # faster
+                else:  # pragma: no cover
+                    assert _isidentifier(key)
+                # yield ' ' * indent + key
+                name_b = key.encode("UTF-8")
+                f.write(lencode(len(name_b)))
+                f.write(name_b)
+                self._encode(f, v, streams, None)
+        elif isinstance(value, bytes):
+            f.write(x(b"b", ext_id))  # B for blob
+            blob = Blob(
+                value, compression=self._compression, use_checksum=self._use_checksum
+            )
+            blob._to_file(f)  # noqa
+        elif isinstance(value, Blob):
+            f.write(x(b"b", ext_id))  # B for blob
+            value._to_file(f)  # noqa
+        elif isinstance(value, BaseStream):
+            # Initialize the stream
+            if value.mode != "w":
+                raise ValueError("Cannot serialize a read-mode stream.")
+            elif isinstance(value, ListStream):
+                f.write(x(b"l", ext_id) + spack("<BQ", 255, 0))  # L for list
+            else:
+                raise TypeError("Only ListStream is supported")
+            # Mark this as *the* stream, and activate the stream.
+            # The save() function verifies this is the last written object.
+            if len(streams) > 0:
+                raise ValueError("Can only have one stream per file.")
+            streams.append(value)
+            value._activate(f, self._encode, self._decode)  # noqa
+        else:
+            if ext_id is not None:
+                raise ValueError(
+                    "Extension %s wronfully encodes object to another "
+                    "extension object (though it may encode to a list/dict "
+                    "that contains other extension objects)." % ext_id
+                )
+            # Try if the value is of a type we know
+            ex = self._extensions_by_cls.get(value.__class__, None)
+            # Maybe its a subclass of a type we know
+            if ex is None:
+                for name, c in self._extensions.items():
+                    if c.match(self, value):
+                        ex = name, c.encode
+                        break
+                else:
+                    ex = None
+            # Success or fail
+            if ex is not None:
+                ext_id2, extension_encode = ex
+                self._encode(f, extension_encode(self, value), streams, ext_id2)
+            else:
+                t = (
+                    "Class %r is not a valid base BSDF type, nor is it "
+                    "handled by an extension."
+                )
+                raise TypeError(t % value.__class__.__name__)
+
+    def _decode(self, f):
+        """Main decoder function."""
+
+        # Get value
+        char = f.read(1)
+        c = char.lower()
+
+        # Conversion (uppercase value identifiers signify converted values)
+        if not char:
+            raise EOFError()
+        elif char != c:
+            n = strunpack("<B", f.read(1))[0]
+            # if n == 253: n = strunpack('<Q', f.read(8))[0]  # noqa - noneed
+            ext_id = f.read(n).decode("UTF-8")
+        else:
+            ext_id = None
+
+        if c == b"v":
+            value = None
+        elif c == b"y":
+            value = True
+        elif c == b"n":
+            value = False
+        elif c == b"h":
+            value = strunpack("<h", f.read(2))[0]
+        elif c == b"i":
+            value = strunpack("<q", f.read(8))[0]
+        elif c == b"f":
+            value = strunpack("<f", f.read(4))[0]
+        elif c == b"d":
+            value = strunpack("<d", f.read(8))[0]
+        elif c == b"s":
+            n_s = strunpack("<B", f.read(1))[0]
+            if n_s == 253:
+                n_s = strunpack("<Q", f.read(8))[0]  # noqa
+            value = f.read(n_s).decode("UTF-8")
+        elif c == b"l":
+            n = strunpack("<B", f.read(1))[0]
+            if n >= 254:
+                # Streaming
+                closed = n == 254
+                n = strunpack("<Q", f.read(8))[0]
+                if self._load_streaming:
+                    value = ListStream(n if closed else "r")
+                    value._activate(f, self._encode, self._decode)  # noqa
+                elif closed:
+                    value = [self._decode(f) for i in range(n)]
+                else:
+                    value = []
+                    try:
+                        while True:
+                            value.append(self._decode(f))
+                    except EOFError:
+                        pass
+            else:
+                # Normal
+                if n == 253:
+                    n = strunpack("<Q", f.read(8))[0]  # noqa
+                value = [self._decode(f) for i in range(n)]
+        elif c == b"m":
+            value = dict()
+            n = strunpack("<B", f.read(1))[0]
+            if n == 253:
+                n = strunpack("<Q", f.read(8))[0]  # noqa
+            for i in range(n):
+                n_name = strunpack("<B", f.read(1))[0]
+                if n_name == 253:
+                    n_name = strunpack("<Q", f.read(8))[0]  # noqa
+                assert n_name > 0
+                name = f.read(n_name).decode("UTF-8")
+                value[name] = self._decode(f)
+        elif c == b"b":
+            if self._lazy_blob:
+                value = Blob((f, True))
+            else:
+                blob = Blob((f, False))
+                value = blob.get_bytes()
+        else:
+            raise RuntimeError("Parse error %r" % char)
+
+        # Convert value if we have an extension for it
+        if ext_id is not None:
+            extension = self._extensions.get(ext_id, None)
+            if extension is not None:
+                value = extension.decode(self, value)
+            else:
+                logger.warning("BSDF warning: no extension found for %r" % ext_id)
+
+        return value
+
+    def encode(self, ob):
+        """Save the given object to bytes."""
+        f = BytesIO()
+        self.save(f, ob)
+        return f.getvalue()
+
+    def save(self, f, ob):
+        """Write the given object to the given file object."""
+        f.write(b"BSDF")
+        f.write(struct.pack("<B", VERSION[0]))
+        f.write(struct.pack("<B", VERSION[1]))
+
+        # Prepare streaming, this list will have 0 or 1 item at the end
+        streams = []
+
+        self._encode(f, ob, streams, None)
+
+        # Verify that stream object was at the end, and add initial elements
+        if len(streams) > 0:
+            stream = streams[0]
+            if stream._start_pos != f.tell():
+                raise ValueError(
+                    "The stream object must be " "the last object to be encoded."
+                )
+
+    def decode(self, bb):
+        """Load the data structure that is BSDF-encoded in the given bytes."""
+        f = BytesIO(bb)
+        return self.load(f)
+
+    def load(self, f):
+        """Load a BSDF-encoded object from the given file object."""
+        # Check magic string
+        f4 = f.read(4)
+        if f4 != b"BSDF":
+            raise RuntimeError("This does not look like a BSDF file: %r" % f4)
+        # Check version
+        major_version = strunpack("<B", f.read(1))[0]
+        minor_version = strunpack("<B", f.read(1))[0]
+        file_version = "%i.%i" % (major_version, minor_version)
+        if major_version != VERSION[0]:  # major version should be 2
+            t = (
+                "Reading file with different major version (%s) "
+                "from the implementation (%s)."
+            )
+            raise RuntimeError(t % (__version__, file_version))
+        if minor_version > VERSION[1]:  # minor should be < ours
+            t = (
+                "BSDF warning: reading file with higher minor version (%s) "
+                "than the implementation (%s)."
+            )
+            logger.warning(t % (__version__, file_version))
+
+        return self._decode(f)
+
+
+# %% Streaming and blob-files
+
+
+class BaseStream(object):
+    """Base class for streams."""
+
+    def __init__(self, mode="w"):
+        self._i = 0
+        self._count = -1
+        if isinstance(mode, int):
+            self._count = mode
+            mode = "r"
+        elif mode == "w":
+            self._count = 0
+        assert mode in ("r", "w")
+        self._mode = mode
+        self._f = None
+        self._start_pos = 0
+
+    def _activate(self, file, encode_func, decode_func):
+        if self._f is not None:  # Associated with another write
+            raise IOError("Stream object cannot be activated twice?")
+        self._f = file
+        self._start_pos = self._f.tell()
+        self._encode = encode_func
+        self._decode = decode_func
+
+    @property
+    def mode(self):
+        """The mode of this stream: 'r' or 'w'."""
+        return self._mode
+
+
+class ListStream(BaseStream):
+    """A streamable list object used for writing or reading.
+    In read mode, it can also be iterated over.
+    """
+
+    @property
+    def count(self):
+        """The number of elements in the stream (can be -1 for unclosed
+        streams in read-mode).
+        """
+        return self._count
+
+    @property
+    def index(self):
+        """The current index of the element to read/write."""
+        return self._i
+
+    def append(self, item):
+        """Append an item to the streaming list. The object is immediately
+        serialized and written to the underlying file.
+        """
+        # if self._mode != 'w':
+        #     raise IOError('This ListStream is not in write mode.')
+        if self._count != self._i:
+            raise IOError("Can only append items to the end of the stream.")
+        if self._f is None:
+            raise IOError("List stream is not associated with a file yet.")
+        if self._f.closed:
+            raise IOError("Cannot stream to a close file.")
+        self._encode(self._f, item, [self], None)
+        self._i += 1
+        self._count += 1
+
+    def close(self, unstream=False):
+        """Close the stream, marking the number of written elements. New
+        elements may still be appended, but they won't be read during decoding.
+        If ``unstream`` is False, the stream is turned into a regular list
+        (not streaming).
+        """
+        # if self._mode != 'w':
+        #     raise IOError('This ListStream is not in write mode.')
+        if self._count != self._i:
+            raise IOError("Can only close when at the end of the stream.")
+        if self._f is None:
+            raise IOError("ListStream is not associated with a file yet.")
+        if self._f.closed:
+            raise IOError("Cannot close a stream on a close file.")
+        i = self._f.tell()
+        self._f.seek(self._start_pos - 8 - 1)
+        self._f.write(spack("<B", 253 if unstream else 254))
+        self._f.write(spack("<Q", self._count))
+        self._f.seek(i)
+
+    def next(self):
+        """Read and return the next element in the streaming list.
+        Raises StopIteration if the stream is exhausted.
+        """
+        if self._mode != "r":
+            raise IOError("This ListStream in not in read mode.")
+        if self._f is None:
+            raise IOError("ListStream is not associated with a file yet.")
+        if getattr(self._f, "closed", None):  # not present on 2.7 http req :/
+            raise IOError("Cannot read a stream from a close file.")
+        if self._count >= 0:
+            if self._i >= self._count:
+                raise StopIteration()
+            self._i += 1
+            return self._decode(self._f)
+        else:
+            # This raises EOFError at some point.
+            try:
+                res = self._decode(self._f)
+                self._i += 1
+                return res
+            except EOFError:
+                self._count = self._i
+                raise StopIteration()
+
+    def __iter__(self):
+        if self._mode != "r":
+            raise IOError("Cannot iterate: ListStream in not in read mode.")
+        return self
+
+    def __next__(self):
+        return self.next()
+
+
+class Blob(object):
+    """Object to represent a blob of bytes. When used to write a BSDF file,
+    it's a wrapper for bytes plus properties such as what compression to apply.
+    When used to read a BSDF file, it can be used to read the data lazily, and
+    also modify the data if reading in 'r+' mode and the blob isn't compressed.
+    """
+
+    # For now, this does not allow re-sizing blobs (within the allocated size)
+    # but this can be added later.
+
+    def __init__(self, bb, compression=0, extra_size=0, use_checksum=False):
+        if isinstance(bb, bytes):
+            self._f = None
+            self.compressed = self._from_bytes(bb, compression)
+            self.compression = compression
+            self.allocated_size = self.used_size + extra_size
+            self.use_checksum = use_checksum
+        elif isinstance(bb, tuple) and len(bb) == 2 and hasattr(bb[0], "read"):
+            self._f, allow_seek = bb
+            self.compressed = None
+            self._from_file(self._f, allow_seek)
+            self._modified = False
+        else:
+            raise TypeError("Wrong argument to create Blob.")
+
+    def _from_bytes(self, value, compression):
+        """When used to wrap bytes in a blob."""
+        if compression == 0:
+            compressed = value
+        elif compression == 1:
+            compressed = zlib.compress(value, 9)
+        elif compression == 2:
+            compressed = bz2.compress(value, 9)
+        else:  # pragma: no cover
+            assert False, "Unknown compression identifier"
+
+        self.data_size = len(value)
+        self.used_size = len(compressed)
+        return compressed
+
+    def _to_file(self, f):
+        """Private friend method called by encoder to write a blob to a file."""
+        # Write sizes - write at least in a size that allows resizing
+        if self.allocated_size <= 250 and self.compression == 0:
+            f.write(spack("<B", self.allocated_size))
+            f.write(spack("<B", self.used_size))
+            f.write(lencode(self.data_size))
+        else:
+            f.write(spack("<BQ", 253, self.allocated_size))
+            f.write(spack("<BQ", 253, self.used_size))
+            f.write(spack("<BQ", 253, self.data_size))
+        # Compression and checksum
+        f.write(spack("B", self.compression))
+        if self.use_checksum:
+            f.write(b"\xff" + hashlib.md5(self.compressed).digest())
+        else:
+            f.write(b"\x00")
+        # Byte alignment (only necessary for uncompressed data)
+        if self.compression == 0:
+            alignment = 8 - (f.tell() + 1) % 8  # +1 for the byte to write
+            f.write(spack("<B", alignment))  # padding for byte alignment
+            f.write(b"\x00" * alignment)
+        else:
+            f.write(spack("<B", 0))
+        # The actual data and extra space
+        f.write(self.compressed)
+        f.write(b"\x00" * (self.allocated_size - self.used_size))
+
+    def _from_file(self, f, allow_seek):
+        """Used when a blob is read by the decoder."""
+        # Read blob header data (5 to 42 bytes)
+        # Size
+        allocated_size = strunpack("<B", f.read(1))[0]
+        if allocated_size == 253:
+            allocated_size = strunpack("<Q", f.read(8))[0]  # noqa
+        used_size = strunpack("<B", f.read(1))[0]
+        if used_size == 253:
+            used_size = strunpack("<Q", f.read(8))[0]  # noqa
+        data_size = strunpack("<B", f.read(1))[0]
+        if data_size == 253:
+            data_size = strunpack("<Q", f.read(8))[0]  # noqa
+        # Compression and checksum
+        compression = strunpack("<B", f.read(1))[0]
+        has_checksum = strunpack("<B", f.read(1))[0]
+        if has_checksum:
+            checksum = f.read(16)
+        # Skip alignment
+        alignment = strunpack("<B", f.read(1))[0]
+        f.read(alignment)
+        # Get or skip data + extra space
+        if allow_seek:
+            self.start_pos = f.tell()
+            self.end_pos = self.start_pos + used_size
+            f.seek(self.start_pos + allocated_size)
+        else:
+            self.start_pos = None
+            self.end_pos = None
+            self.compressed = f.read(used_size)
+            f.read(allocated_size - used_size)
+        # Store info
+        self.alignment = alignment
+        self.compression = compression
+        self.use_checksum = checksum if has_checksum else None
+        self.used_size = used_size
+        self.allocated_size = allocated_size
+        self.data_size = data_size
+
+    def seek(self, p):
+        """Seek to the given position (relative to the blob start)."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot seek in a blob " "that is not created by the BSDF decoder."
+            )
+        if p < 0:
+            p = self.allocated_size + p
+        if p < 0 or p > self.allocated_size:
+            raise IOError("Seek beyond blob boundaries.")
+        self._f.seek(self.start_pos + p)
+
+    def tell(self):
+        """Get the current file pointer position (relative to the blob start)."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot tell in a blob " "that is not created by the BSDF decoder."
+            )
+        return self._f.tell() - self.start_pos
+
+    def write(self, bb):
+        """Write bytes to the blob."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot write in a blob " "that is not created by the BSDF decoder."
+            )
+        if self.compression:
+            raise IOError("Cannot arbitrarily write in compressed blob.")
+        if self._f.tell() + len(bb) > self.end_pos:
+            raise IOError("Write beyond blob boundaries.")
+        self._modified = True
+        return self._f.write(bb)
+
+    def read(self, n):
+        """Read n bytes from the blob."""
+        if self._f is None:
+            raise RuntimeError(
+                "Cannot read in a blob " "that is not created by the BSDF decoder."
+            )
+        if self.compression:
+            raise IOError("Cannot arbitrarily read in compressed blob.")
+        if self._f.tell() + n > self.end_pos:
+            raise IOError("Read beyond blob boundaries.")
+        return self._f.read(n)
+
+    def get_bytes(self):
+        """Get the contents of the blob as bytes."""
+        if self.compressed is not None:
+            compressed = self.compressed
+        else:
+            i = self._f.tell()
+            self.seek(0)
+            compressed = self._f.read(self.used_size)
+            self._f.seek(i)
+        if self.compression == 0:
+            value = compressed
+        elif self.compression == 1:
+            value = zlib.decompress(compressed)
+        elif self.compression == 2:
+            value = bz2.decompress(compressed)
+        else:  # pragma: no cover
+            raise RuntimeError("Invalid compression %i" % self.compression)
+        return value
+
+    def update_checksum(self):
+        """Reset the blob's checksum if present. Call this after modifying
+        the data.
+        """
+        # or ... should the presence of a checksum mean that data is proteced?
+        if self.use_checksum and self._modified:
+            self.seek(0)
+            compressed = self._f.read(self.used_size)
+            self._f.seek(self.start_pos - self.alignment - 1 - 16)
+            self._f.write(hashlib.md5(compressed).digest())
+
+
+# %% High-level functions
+
+
+def encode(ob, extensions=None, **options):
+    """Save (BSDF-encode) the given object to bytes.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    return s.encode(ob)
+
+
+def save(f, ob, extensions=None, **options):
+    """Save (BSDF-encode) the given object to the given filename or
+    file object. See` BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    if isinstance(f, string_types):
+        with open(f, "wb") as fp:
+            return s.save(fp, ob)
+    else:
+        return s.save(f, ob)
+
+
+def decode(bb, extensions=None, **options):
+    """Load a (BSDF-encoded) structure from bytes.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    return s.decode(bb)
+
+
+def load(f, extensions=None, **options):
+    """Load a (BSDF-encoded) structure from the given filename or file object.
+    See `BSDFSerializer` for details on extensions and options.
+    """
+    s = BsdfSerializer(extensions, **options)
+    if isinstance(f, string_types):
+        if f.startswith(("~/", "~\\")):  # pragma: no cover
+            f = os.path.expanduser(f)
+        with open(f, "rb") as fp:
+            return s.load(fp)
+    else:
+        return s.load(f)
+
+
+# Aliases for json compat
+loads = decode
+dumps = encode
+
+
+# %% Standard extensions
+
+# Defining extensions as a dict would be more compact and feel lighter, but
+# that would only allow lambdas, which is too limiting, e.g. for ndarray
+# extension.
+
+
+class Extension(object):
+    """Base class to implement BSDF extensions for special data types.
+
+    Extension classes are provided to the BSDF serializer, which
+    instantiates the class. That way, the extension can be somewhat dynamic:
+    e.g. the NDArrayExtension exposes the ndarray class only when numpy
+    is imported.
+
+    A extension instance must have two attributes. These can be attributes of
+    the class, or of the instance set in ``__init__()``:
+
+    * name (str): the name by which encoded values will be identified.
+    * cls (type): the type (or list of types) to match values with.
+      This is optional, but it makes the encoder select extensions faster.
+
+    Further, it needs 3 methods:
+
+    * `match(serializer, value) -> bool`: return whether the extension can
+      convert the given value. The default is ``isinstance(value, self.cls)``.
+    * `encode(serializer, value) -> encoded_value`: the function to encode a
+      value to more basic data types.
+    * `decode(serializer, encoded_value) -> value`: the function to decode an
+      encoded value back to its intended representation.
+
+    """
+
+    name = ""
+    cls = ()
+
+    def __repr__(self):
+        return "<BSDF extension %r at 0x%s>" % (self.name, hex(id(self)))
+
+    def match(self, s, v):
+        return isinstance(v, self.cls)
+
+    def encode(self, s, v):
+        raise NotImplementedError()
+
+    def decode(self, s, v):
+        raise NotImplementedError()
+
+
+class ComplexExtension(Extension):
+    name = "c"
+    cls = complex
+
+    def encode(self, s, v):
+        return (v.real, v.imag)
+
+    def decode(self, s, v):
+        return complex(v[0], v[1])
+
+
+class NDArrayExtension(Extension):
+    name = "ndarray"
+
+    def __init__(self):
+        if "numpy" in sys.modules:
+            import numpy as np
+
+            self.cls = np.ndarray
+
+    def match(self, s, v):  # pragma: no cover - e.g. work for nd arrays in JS
+        return hasattr(v, "shape") and hasattr(v, "dtype") and hasattr(v, "tobytes")
+
+    def encode(self, s, v):
+        return dict(shape=v.shape, dtype=text_type(v.dtype), data=v.tobytes())
+
+    def decode(self, s, v):
+        try:
+            import numpy as np
+        except ImportError:  # pragma: no cover
+            return v
+        a = np.frombuffer(v["data"], dtype=v["dtype"])
+        a.shape = v["shape"]
+        return a
+
+
+standard_extensions = [ComplexExtension, NDArrayExtension]
+
+
+if __name__ == "__main__":
+    # Invoke CLI
+    import bsdf_cli
+
+    bsdf_cli.main()

parrot/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)

parrot/lib/python3.10/site-packages/imageio/plugins/_freeimage.py

@@ -0,0 +1,1312 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+# styletest: ignore E261
+
+""" Module imageio/freeimage.py
+
+This module contains the wrapper code for the freeimage library.
+The functions defined in this module are relatively thin; just thin
+enough so that arguments and results are native Python/numpy data
+types.
+
+"""
+
+import os
+import sys
+import ctypes
+import threading
+import logging
+import numpy
+
+from ..core import (
+    get_remote_file,
+    load_lib,
+    Dict,
+    resource_dirs,
+    IS_PYPY,
+    get_platform,
+    InternetNotAllowedError,
+    NeedDownloadError,
+)
+
+logger = logging.getLogger(__name__)
+
+TEST_NUMPY_NO_STRIDES = False  # To test pypy fallback
+
+FNAME_PER_PLATFORM = {
+    "osx32": "libfreeimage-3.16.0-osx10.6.dylib",  # universal library
+    "osx64": "libfreeimage-3.16.0-osx10.6.dylib",
+    "win32": "FreeImage-3.18.0-win32.dll",
+    "win64": "FreeImage-3.18.0-win64.dll",
+    "linux32": "libfreeimage-3.16.0-linux32.so",
+    "linux64": "libfreeimage-3.16.0-linux64.so",
+}
+
+
+def download(directory=None, force_download=False):
+    """Download the FreeImage library to your computer.
+
+    Parameters
+    ----------
+    directory : str | None
+        The directory where the file will be cached if a download was
+        required to obtain the file. By default, the appdata directory
+        is used. This is also the first directory that is checked for
+        a local version of the file.
+    force_download : bool | str
+        If True, the file will be downloaded even if a local copy exists
+        (and this copy will be overwritten). Can also be a YYYY-MM-DD date
+        to ensure a file is up-to-date (modified date of a file on disk,
+        if present, is checked).
+    """
+    plat = get_platform()
+    if plat and plat in FNAME_PER_PLATFORM:
+        fname = "freeimage/" + FNAME_PER_PLATFORM[plat]
+        get_remote_file(fname=fname, directory=directory, force_download=force_download)
+        fi._lib = None  # allow trying again (needed to make tests work)
+
+
+def get_freeimage_lib():
+    """Ensure we have our version of the binary freeimage lib."""
+
+    lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
+    if lib:  # pragma: no cover
+        return lib
+
+    # Get filename to load
+    # If we do not provide a binary, the system may still do ...
+    plat = get_platform()
+    if plat and plat in FNAME_PER_PLATFORM:
+        try:
+            return get_remote_file("freeimage/" + FNAME_PER_PLATFORM[plat], auto=False)
+        except InternetNotAllowedError:
+            pass
+        except NeedDownloadError:
+            raise NeedDownloadError(
+                "Need FreeImage library. "
+                "You can obtain it with either:\n"
+                "  - download using the command: "
+                "imageio_download_bin freeimage\n"
+                "  - download by calling (in Python): "
+                "imageio.plugins.freeimage.download()\n"
+            )
+        except RuntimeError as e:  # pragma: no cover
+            logger.warning(str(e))
+
+
+# Define function to encode a filename to bytes (for the current system)
+def efn(x):
+    return x.encode(sys.getfilesystemencoding())
+
+
+# 4-byte quads of 0,v,v,v from 0,0,0,0 to 0,255,255,255
+GREY_PALETTE = numpy.arange(0, 0x01000000, 0x00010101, dtype=numpy.uint32)
+
+
+class FI_TYPES(object):
+    FIT_UNKNOWN = 0
+    FIT_BITMAP = 1
+    FIT_UINT16 = 2
+    FIT_INT16 = 3
+    FIT_UINT32 = 4
+    FIT_INT32 = 5
+    FIT_FLOAT = 6
+    FIT_DOUBLE = 7
+    FIT_COMPLEX = 8
+    FIT_RGB16 = 9
+    FIT_RGBA16 = 10
+    FIT_RGBF = 11
+    FIT_RGBAF = 12
+
+    dtypes = {
+        FIT_BITMAP: numpy.uint8,
+        FIT_UINT16: numpy.uint16,
+        FIT_INT16: numpy.int16,
+        FIT_UINT32: numpy.uint32,
+        FIT_INT32: numpy.int32,
+        FIT_FLOAT: numpy.float32,
+        FIT_DOUBLE: numpy.float64,
+        FIT_COMPLEX: numpy.complex128,
+        FIT_RGB16: numpy.uint16,
+        FIT_RGBA16: numpy.uint16,
+        FIT_RGBF: numpy.float32,
+        FIT_RGBAF: numpy.float32,
+    }
+
+    fi_types = {
+        (numpy.uint8, 1): FIT_BITMAP,
+        (numpy.uint8, 3): FIT_BITMAP,
+        (numpy.uint8, 4): FIT_BITMAP,
+        (numpy.uint16, 1): FIT_UINT16,
+        (numpy.int16, 1): FIT_INT16,
+        (numpy.uint32, 1): FIT_UINT32,
+        (numpy.int32, 1): FIT_INT32,
+        (numpy.float32, 1): FIT_FLOAT,
+        (numpy.float64, 1): FIT_DOUBLE,
+        (numpy.complex128, 1): FIT_COMPLEX,
+        (numpy.uint16, 3): FIT_RGB16,
+        (numpy.uint16, 4): FIT_RGBA16,
+        (numpy.float32, 3): FIT_RGBF,
+        (numpy.float32, 4): FIT_RGBAF,
+    }
+
+    extra_dims = {
+        FIT_UINT16: [],
+        FIT_INT16: [],
+        FIT_UINT32: [],
+        FIT_INT32: [],
+        FIT_FLOAT: [],
+        FIT_DOUBLE: [],
+        FIT_COMPLEX: [],
+        FIT_RGB16: [3],
+        FIT_RGBA16: [4],
+        FIT_RGBF: [3],
+        FIT_RGBAF: [4],
+    }
+
+
+class IO_FLAGS(object):
+    FIF_LOAD_NOPIXELS = 0x8000  # loading: load the image header only
+    #                          # (not supported by all plugins)
+    BMP_DEFAULT = 0
+    BMP_SAVE_RLE = 1
+    CUT_DEFAULT = 0
+    DDS_DEFAULT = 0
+    EXR_DEFAULT = 0  # save data as half with piz-based wavelet compression
+    EXR_FLOAT = 0x0001  # save data as float instead of half (not recommended)
+    EXR_NONE = 0x0002  # save with no compression
+    EXR_ZIP = 0x0004  # save with zlib compression, in blocks of 16 scan lines
+    EXR_PIZ = 0x0008  # save with piz-based wavelet compression
+    EXR_PXR24 = 0x0010  # save with lossy 24-bit float compression
+    EXR_B44 = 0x0020  # save with lossy 44% float compression
+    #                # - goes to 22% when combined with EXR_LC
+    EXR_LC = 0x0040  # save images with one luminance and two chroma channels,
+    #               # rather than as RGB (lossy compression)
+    FAXG3_DEFAULT = 0
+    GIF_DEFAULT = 0
+    GIF_LOAD256 = 1  # Load the image as a 256 color image with ununsed
+    #               # palette entries, if it's 16 or 2 color
+    GIF_PLAYBACK = 2  # 'Play' the GIF to generate each frame (as 32bpp)
+    #                # instead of returning raw frame data when loading
+    HDR_DEFAULT = 0
+    ICO_DEFAULT = 0
+    ICO_MAKEALPHA = 1  # convert to 32bpp and create an alpha channel from the
+    #                 # AND-mask when loading
+    IFF_DEFAULT = 0
+    J2K_DEFAULT = 0  # save with a 16:1 rate
+    JP2_DEFAULT = 0  # save with a 16:1 rate
+    JPEG_DEFAULT = 0  # loading (see JPEG_FAST);
+    #                # saving (see JPEG_QUALITYGOOD|JPEG_SUBSAMPLING_420)
+    JPEG_FAST = 0x0001  # load the file as fast as possible,
+    #                  # sacrificing some quality
+    JPEG_ACCURATE = 0x0002  # load the file with the best quality,
+    #                      # sacrificing some speed
+    JPEG_CMYK = 0x0004  # load separated CMYK "as is"
+    #                  # (use | to combine with other load flags)
+    JPEG_EXIFROTATE = 0x0008  # load and rotate according to
+    #                        # Exif 'Orientation' tag if available
+    JPEG_QUALITYSUPERB = 0x80  # save with superb quality (100:1)
+    JPEG_QUALITYGOOD = 0x0100  # save with good quality (75:1)
+    JPEG_QUALITYNORMAL = 0x0200  # save with normal quality (50:1)
+    JPEG_QUALITYAVERAGE = 0x0400  # save with average quality (25:1)
+    JPEG_QUALITYBAD = 0x0800  # save with bad quality (10:1)
+    JPEG_PROGRESSIVE = 0x2000  # save as a progressive-JPEG
+    #                         # (use | to combine with other save flags)
+    JPEG_SUBSAMPLING_411 = 0x1000  # save with high 4x1 chroma
+    #                             # subsampling (4:1:1)
+    JPEG_SUBSAMPLING_420 = 0x4000  # save with medium 2x2 medium chroma
+    #                             # subsampling (4:2:0) - default value
+    JPEG_SUBSAMPLING_422 = 0x8000  # save /w low 2x1 chroma subsampling (4:2:2)
+    JPEG_SUBSAMPLING_444 = 0x10000  # save with no chroma subsampling (4:4:4)
+    JPEG_OPTIMIZE = 0x20000  # on saving, compute optimal Huffman coding tables
+    #                       # (can reduce a few percent of file size)
+    JPEG_BASELINE = 0x40000  # save basic JPEG, without metadata or any markers
+    KOALA_DEFAULT = 0
+    LBM_DEFAULT = 0
+    MNG_DEFAULT = 0
+    PCD_DEFAULT = 0
+    PCD_BASE = 1  # load the bitmap sized 768 x 512
+    PCD_BASEDIV4 = 2  # load the bitmap sized 384 x 256
+    PCD_BASEDIV16 = 3  # load the bitmap sized 192 x 128
+    PCX_DEFAULT = 0
+    PFM_DEFAULT = 0
+    PICT_DEFAULT = 0
+    PNG_DEFAULT = 0
+    PNG_IGNOREGAMMA = 1  # loading: avoid gamma correction
+    PNG_Z_BEST_SPEED = 0x0001  # save using ZLib level 1 compression flag
+    #                         # (default value is 6)
+    PNG_Z_DEFAULT_COMPRESSION = 0x0006  # save using ZLib level 6 compression
+    #                                  # flag (default recommended value)
+    PNG_Z_BEST_COMPRESSION = 0x0009  # save using ZLib level 9 compression flag
+    #                               # (default value is 6)
+    PNG_Z_NO_COMPRESSION = 0x0100  # save without ZLib compression
+    PNG_INTERLACED = 0x0200  # save using Adam7 interlacing (use | to combine
+    #                       # with other save flags)
+    PNM_DEFAULT = 0
+    PNM_SAVE_RAW = 0  # Writer saves in RAW format (i.e. P4, P5 or P6)
+    PNM_SAVE_ASCII = 1  # Writer saves in ASCII format (i.e. P1, P2 or P3)
+    PSD_DEFAULT = 0
+    PSD_CMYK = 1  # reads tags for separated CMYK (default is conversion to RGB)
+    PSD_LAB = 2  # reads tags for CIELab (default is conversion to RGB)
+    RAS_DEFAULT = 0
+    RAW_DEFAULT = 0  # load the file as linear RGB 48-bit
+    RAW_PREVIEW = 1  # try to load the embedded JPEG preview with included
+    #               # Exif Data or default to RGB 24-bit
+    RAW_DISPLAY = 2  # load the file as RGB 24-bit
+    SGI_DEFAULT = 0
+    TARGA_DEFAULT = 0
+    TARGA_LOAD_RGB888 = 1  # Convert RGB555 and ARGB8888 -> RGB888.
+    TARGA_SAVE_RLE = 2  # Save with RLE compression
+    TIFF_DEFAULT = 0
+    TIFF_CMYK = 0x0001  # reads/stores tags for separated CMYK
+    #                  # (use | to combine with compression flags)
+    TIFF_PACKBITS = 0x0100  # save using PACKBITS compression
+    TIFF_DEFLATE = 0x0200  # save using DEFLATE (a.k.a. ZLIB) compression
+    TIFF_ADOBE_DEFLATE = 0x0400  # save using ADOBE DEFLATE compression
+    TIFF_NONE = 0x0800  # save without any compression
+    TIFF_CCITTFAX3 = 0x1000  # save using CCITT Group 3 fax encoding
+    TIFF_CCITTFAX4 = 0x2000  # save using CCITT Group 4 fax encoding
+    TIFF_LZW = 0x4000  # save using LZW compression
+    TIFF_JPEG = 0x8000  # save using JPEG compression
+    TIFF_LOGLUV = 0x10000  # save using LogLuv compression
+    WBMP_DEFAULT = 0
+    XBM_DEFAULT = 0
+    XPM_DEFAULT = 0
+
+
+class METADATA_MODELS(object):
+    FIMD_COMMENTS = 0
+    FIMD_EXIF_MAIN = 1
+    FIMD_EXIF_EXIF = 2
+    FIMD_EXIF_GPS = 3
+    FIMD_EXIF_MAKERNOTE = 4
+    FIMD_EXIF_INTEROP = 5
+    FIMD_IPTC = 6
+    FIMD_XMP = 7
+    FIMD_GEOTIFF = 8
+    FIMD_ANIMATION = 9
+
+
+class METADATA_DATATYPE(object):
+    FIDT_BYTE = 1  # 8-bit unsigned integer
+    FIDT_ASCII = 2  # 8-bit bytes w/ last byte null
+    FIDT_SHORT = 3  # 16-bit unsigned integer
+    FIDT_LONG = 4  # 32-bit unsigned integer
+    FIDT_RATIONAL = 5  # 64-bit unsigned fraction
+    FIDT_SBYTE = 6  # 8-bit signed integer
+    FIDT_UNDEFINED = 7  # 8-bit untyped data
+    FIDT_SSHORT = 8  # 16-bit signed integer
+    FIDT_SLONG = 9  # 32-bit signed integer
+    FIDT_SRATIONAL = 10  # 64-bit signed fraction
+    FIDT_FLOAT = 11  # 32-bit IEEE floating point
+    FIDT_DOUBLE = 12  # 64-bit IEEE floating point
+    FIDT_IFD = 13  # 32-bit unsigned integer (offset)
+    FIDT_PALETTE = 14  # 32-bit RGBQUAD
+    FIDT_LONG8 = 16  # 64-bit unsigned integer
+    FIDT_SLONG8 = 17  # 64-bit signed integer
+    FIDT_IFD8 = 18  # 64-bit unsigned integer (offset)
+
+    dtypes = {
+        FIDT_BYTE: numpy.uint8,
+        FIDT_SHORT: numpy.uint16,
+        FIDT_LONG: numpy.uint32,
+        FIDT_RATIONAL: [("numerator", numpy.uint32), ("denominator", numpy.uint32)],
+        FIDT_LONG8: numpy.uint64,
+        FIDT_SLONG8: numpy.int64,
+        FIDT_IFD8: numpy.uint64,
+        FIDT_SBYTE: numpy.int8,
+        FIDT_UNDEFINED: numpy.uint8,
+        FIDT_SSHORT: numpy.int16,
+        FIDT_SLONG: numpy.int32,
+        FIDT_SRATIONAL: [("numerator", numpy.int32), ("denominator", numpy.int32)],
+        FIDT_FLOAT: numpy.float32,
+        FIDT_DOUBLE: numpy.float64,
+        FIDT_IFD: numpy.uint32,
+        FIDT_PALETTE: [
+            ("R", numpy.uint8),
+            ("G", numpy.uint8),
+            ("B", numpy.uint8),
+            ("A", numpy.uint8),
+        ],
+    }
+
+
+class Freeimage(object):
+    """Class to represent an interface to the FreeImage library.
+    This class is relatively thin. It provides a Pythonic API that converts
+    Freeimage objects to Python objects, but that's about it.
+    The actual implementation should be provided by the plugins.
+
+    The recommended way to call into the Freeimage library (so that
+    errors and warnings show up in the right moment) is to use this
+    object as a context manager:
+    with imageio.fi as lib:
+        lib.FreeImage_GetPalette()
+
+    """
+
+    _API = {
+        # All we're doing here is telling ctypes that some of the
+        # FreeImage functions return pointers instead of integers. (On
+        # 64-bit systems, without this information the pointers get
+        # truncated and crashes result). There's no need to list
+        # functions that return ints, or the types of the parameters
+        # to these or other functions -- that's fine to do implicitly.
+        # Note that the ctypes immediately converts the returned void_p
+        # back to a python int again! This is really not helpful,
+        # because then passing it back to another library call will
+        # cause truncation-to-32-bits on 64-bit systems. Thanks, ctypes!
+        # So after these calls one must immediately re-wrap the int as
+        # a c_void_p if it is to be passed back into FreeImage.
+        "FreeImage_AllocateT": (ctypes.c_void_p, None),
+        "FreeImage_FindFirstMetadata": (ctypes.c_void_p, None),
+        "FreeImage_GetBits": (ctypes.c_void_p, None),
+        "FreeImage_GetPalette": (ctypes.c_void_p, None),
+        "FreeImage_GetTagKey": (ctypes.c_char_p, None),
+        "FreeImage_GetTagValue": (ctypes.c_void_p, None),
+        "FreeImage_CreateTag": (ctypes.c_void_p, None),
+        "FreeImage_Save": (ctypes.c_void_p, None),
+        "FreeImage_Load": (ctypes.c_void_p, None),
+        "FreeImage_LoadFromMemory": (ctypes.c_void_p, None),
+        "FreeImage_OpenMultiBitmap": (ctypes.c_void_p, None),
+        "FreeImage_LoadMultiBitmapFromMemory": (ctypes.c_void_p, None),
+        "FreeImage_LockPage": (ctypes.c_void_p, None),
+        "FreeImage_OpenMemory": (ctypes.c_void_p, None),
+        # 'FreeImage_ReadMemory': (ctypes.c_void_p, None),
+        # 'FreeImage_CloseMemory': (ctypes.c_void_p, None),
+        "FreeImage_GetVersion": (ctypes.c_char_p, None),
+        "FreeImage_GetFIFExtensionList": (ctypes.c_char_p, None),
+        "FreeImage_GetFormatFromFIF": (ctypes.c_char_p, None),
+        "FreeImage_GetFIFDescription": (ctypes.c_char_p, None),
+        "FreeImage_ColorQuantizeEx": (ctypes.c_void_p, None),
+        # Pypy wants some extra definitions, so here we go ...
+        "FreeImage_IsLittleEndian": (ctypes.c_int, None),
+        "FreeImage_SetOutputMessage": (ctypes.c_void_p, None),
+        "FreeImage_GetFIFCount": (ctypes.c_int, None),
+        "FreeImage_IsPluginEnabled": (ctypes.c_int, None),
+        "FreeImage_GetFileType": (ctypes.c_int, None),
+        #
+        "FreeImage_GetTagType": (ctypes.c_int, None),
+        "FreeImage_GetTagLength": (ctypes.c_int, None),
+        "FreeImage_FindNextMetadata": (ctypes.c_int, None),
+        "FreeImage_FindCloseMetadata": (ctypes.c_void_p, None),
+        #
+        "FreeImage_GetFIFFromFilename": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsReading": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsWriting": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsExportType": (ctypes.c_int, None),
+        "FreeImage_FIFSupportsExportBPP": (ctypes.c_int, None),
+        "FreeImage_GetHeight": (ctypes.c_int, None),
+        "FreeImage_GetWidth": (ctypes.c_int, None),
+        "FreeImage_GetImageType": (ctypes.c_int, None),
+        "FreeImage_GetBPP": (ctypes.c_int, None),
+        "FreeImage_GetColorsUsed": (ctypes.c_int, None),
+        "FreeImage_ConvertTo32Bits": (ctypes.c_void_p, None),
+        "FreeImage_GetPitch": (ctypes.c_int, None),
+        "FreeImage_Unload": (ctypes.c_void_p, None),
+    }
+
+    def __init__(self):
+        # Initialize freeimage lib as None
+        self._lib = None
+
+        # A lock to create thread-safety
+        self._lock = threading.RLock()
+
+        # Init log messages lists
+        self._messages = []
+
+        # Select functype for error handler
+        if sys.platform.startswith("win"):
+            functype = ctypes.WINFUNCTYPE
+        else:
+            functype = ctypes.CFUNCTYPE
+
+        # Create output message handler
+        @functype(None, ctypes.c_int, ctypes.c_char_p)
+        def error_handler(fif, message):
+            message = message.decode("utf-8")
+            self._messages.append(message)
+            while (len(self._messages)) > 256:
+                self._messages.pop(0)
+
+        # Make sure to keep a ref to function
+        self._error_handler = error_handler
+
+    @property
+    def lib(self):
+        if self._lib is None:
+            try:
+                self.load_freeimage()
+            except OSError as err:
+                self._lib = "The freeimage library could not be loaded: "
+                self._lib += str(err)
+        if isinstance(self._lib, str):
+            raise RuntimeError(self._lib)
+        return self._lib
+
+    def has_lib(self):
+        try:
+            self.lib
+        except Exception:
+            return False
+        return True
+
+    def load_freeimage(self):
+        """Try to load the freeimage lib from the system. If not successful,
+        try to download the imageio version and try again.
+        """
+        # Load library and register API
+        success = False
+        try:
+            # Try without forcing a download, but giving preference
+            # to the imageio-provided lib (if previously downloaded)
+            self._load_freeimage()
+            self._register_api()
+            if self.lib.FreeImage_GetVersion().decode("utf-8") >= "3.15":
+                success = True
+        except OSError:
+            pass
+
+        if not success:
+            # Ensure we have our own lib, try again
+            get_freeimage_lib()
+            self._load_freeimage()
+            self._register_api()
+
+        # Wrap up
+        self.lib.FreeImage_SetOutputMessage(self._error_handler)
+        self.lib_version = self.lib.FreeImage_GetVersion().decode("utf-8")
+
+    def _load_freeimage(self):
+        # Define names
+        lib_names = ["freeimage", "libfreeimage"]
+        exact_lib_names = [
+            "FreeImage",
+            "libfreeimage.dylib",
+            "libfreeimage.so",
+            "libfreeimage.so.3",
+        ]
+        # Add names of libraries that we provide (that file may not exist)
+        res_dirs = resource_dirs()
+        plat = get_platform()
+        if plat:  # Can be None on e.g. FreeBSD
+            fname = FNAME_PER_PLATFORM[plat]
+            for dir in res_dirs:
+                exact_lib_names.insert(0, os.path.join(dir, "freeimage", fname))
+
+        # Add the path specified with IMAGEIO_FREEIMAGE_LIB:
+        lib = os.getenv("IMAGEIO_FREEIMAGE_LIB", None)
+        if lib is not None:
+            exact_lib_names.insert(0, lib)
+
+        # Load
+        try:
+            lib, fname = load_lib(exact_lib_names, lib_names, res_dirs)
+        except OSError as err:  # pragma: no cover
+            err_msg = str(err) + "\nPlease install the FreeImage library."
+            raise OSError(err_msg)
+
+        # Store
+        self._lib = lib
+        self.lib_fname = fname
+
+    def _register_api(self):
+        # Albert's ctypes pattern
+        for f, (restype, argtypes) in self._API.items():
+            func = getattr(self.lib, f)
+            func.restype = restype
+            func.argtypes = argtypes
+
+    # Handling of output messages
+
+    def __enter__(self):
+        self._lock.acquire()
+        return self.lib
+
+    def __exit__(self, *args):
+        self._show_any_warnings()
+        self._lock.release()
+
+    def _reset_log(self):
+        """Reset the list of output messages. Call this before
+        loading or saving an image with the FreeImage API.
+        """
+        self._messages = []
+
+    def _get_error_message(self):
+        """Get the output messages produced since the last reset as
+        one string. Returns 'No known reason.' if there are no messages.
+        Also resets the log.
+        """
+        if self._messages:
+            res = " ".join(self._messages)
+            self._reset_log()
+            return res
+        else:
+            return "No known reason."
+
+    def _show_any_warnings(self):
+        """If there were any messages since the last reset, show them
+        as a warning. Otherwise do nothing. Also resets the messages.
+        """
+        if self._messages:
+            logger.warning("imageio.freeimage warning: " + self._get_error_message())
+            self._reset_log()
+
+    def get_output_log(self):
+        """Return a list of the last 256 output messages
+        (warnings and errors) produced by the FreeImage library.
+        """
+        # This message log is not cleared/reset, but kept to 256 elements.
+        return [m for m in self._messages]
+
+    def getFIF(self, filename, mode, bb=None):
+        """Get the freeimage Format (FIF) from a given filename.
+        If mode is 'r', will try to determine the format by reading
+        the file, otherwise only the filename is used.
+
+        This function also tests whether the format supports reading/writing.
+        """
+        with self as lib:
+            # Init
+            ftype = -1
+            if mode not in "rw":
+                raise ValueError('Invalid mode (must be "r" or "w").')
+
+            # Try getting format from the content. Note that some files
+            # do not have a header that allows reading the format from
+            # the file.
+            if mode == "r":
+                if bb is not None:
+                    fimemory = lib.FreeImage_OpenMemory(ctypes.c_char_p(bb), len(bb))
+                    ftype = lib.FreeImage_GetFileTypeFromMemory(
+                        ctypes.c_void_p(fimemory), len(bb)
+                    )
+                    lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+                if (ftype == -1) and os.path.isfile(filename):
+                    ftype = lib.FreeImage_GetFileType(efn(filename), 0)
+            # Try getting the format from the extension
+            if ftype == -1:
+                ftype = lib.FreeImage_GetFIFFromFilename(efn(filename))
+
+            # Test if ok
+            if ftype == -1:
+                raise ValueError('Cannot determine format of file "%s"' % filename)
+            elif mode == "w" and not lib.FreeImage_FIFSupportsWriting(ftype):
+                raise ValueError('Cannot write the format of file "%s"' % filename)
+            elif mode == "r" and not lib.FreeImage_FIFSupportsReading(ftype):
+                raise ValueError('Cannot read the format of file "%s"' % filename)
+            return ftype
+
+    def create_bitmap(self, filename, ftype, flags=0):
+        """create_bitmap(filename, ftype, flags=0)
+        Create a wrapped bitmap object.
+        """
+        return FIBitmap(self, filename, ftype, flags)
+
+    def create_multipage_bitmap(self, filename, ftype, flags=0):
+        """create_multipage_bitmap(filename, ftype, flags=0)
+        Create a wrapped multipage bitmap object.
+        """
+        return FIMultipageBitmap(self, filename, ftype, flags)
+
+
+class FIBaseBitmap(object):
+    def __init__(self, fi, filename, ftype, flags):
+        self._fi = fi
+        self._filename = filename
+        self._ftype = ftype
+        self._flags = flags
+        self._bitmap = None
+        self._close_funcs = []
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if (self._bitmap is not None) and self._close_funcs:
+            for close_func in self._close_funcs:
+                try:
+                    with self._fi:
+                        fun = close_func[0]
+                        fun(*close_func[1:])
+                except Exception:  # pragma: no cover
+                    pass
+            self._close_funcs = []
+            self._bitmap = None
+
+    def _set_bitmap(self, bitmap, close_func=None):
+        """Function to set the bitmap and specify the function to unload it."""
+        if self._bitmap is not None:
+            pass  # bitmap is converted
+        if close_func is None:
+            close_func = self._fi.lib.FreeImage_Unload, bitmap
+
+        self._bitmap = bitmap
+        if close_func:
+            self._close_funcs.append(close_func)
+
+    def get_meta_data(self):
+        # todo: there is also FreeImage_TagToString, is that useful?
+        # and would that work well when reading and then saving?
+
+        # Create a list of (model_name, number) tuples
+        models = [
+            (name[5:], number)
+            for name, number in METADATA_MODELS.__dict__.items()
+            if name.startswith("FIMD_")
+        ]
+
+        # Prepare
+        metadata = Dict()
+        tag = ctypes.c_void_p()
+
+        with self._fi as lib:
+            # Iterate over all FreeImage meta models
+            for model_name, number in models:
+                # Find beginning, get search handle
+                mdhandle = lib.FreeImage_FindFirstMetadata(
+                    number, self._bitmap, ctypes.byref(tag)
+                )
+                mdhandle = ctypes.c_void_p(mdhandle)
+                if mdhandle:
+                    # Iterate over all tags in this model
+                    more = True
+                    while more:
+                        # Get info about tag
+                        tag_name = lib.FreeImage_GetTagKey(tag).decode("utf-8")
+                        tag_type = lib.FreeImage_GetTagType(tag)
+                        byte_size = lib.FreeImage_GetTagLength(tag)
+                        char_ptr = ctypes.c_char * byte_size
+                        data = char_ptr.from_address(lib.FreeImage_GetTagValue(tag))
+                        # Convert in a way compatible with Pypy
+                        tag_bytes = bytes(bytearray(data))
+                        # The default value is the raw bytes
+                        tag_val = tag_bytes
+                        # Convert to a Python value in the metadata dict
+                        if tag_type == METADATA_DATATYPE.FIDT_ASCII:
+                            tag_val = tag_bytes.decode("utf-8", "replace")
+                        elif tag_type in METADATA_DATATYPE.dtypes:
+                            dtype = METADATA_DATATYPE.dtypes[tag_type]
+                            if IS_PYPY and isinstance(dtype, (list, tuple)):
+                                pass  # pragma: no cover - or we get a segfault
+                            else:
+                                try:
+                                    tag_val = numpy.frombuffer(
+                                        tag_bytes, dtype=dtype
+                                    ).copy()
+                                    if len(tag_val) == 1:
+                                        tag_val = tag_val[0]
+                                except Exception:  # pragma: no cover
+                                    pass
+                        # Store data in dict
+                        subdict = metadata.setdefault(model_name, Dict())
+                        subdict[tag_name] = tag_val
+                        # Next
+                        more = lib.FreeImage_FindNextMetadata(
+                            mdhandle, ctypes.byref(tag)
+                        )
+
+                    # Close search handle for current meta model
+                    lib.FreeImage_FindCloseMetadata(mdhandle)
+
+            # Done
+            return metadata
+
+    def set_meta_data(self, metadata):
+        # Create a dict mapping model_name to number
+        models = {}
+        for name, number in METADATA_MODELS.__dict__.items():
+            if name.startswith("FIMD_"):
+                models[name[5:]] = number
+
+        # Create a mapping from numpy.dtype to METADATA_DATATYPE
+        def get_tag_type_number(dtype):
+            for number, numpy_dtype in METADATA_DATATYPE.dtypes.items():
+                if dtype == numpy_dtype:
+                    return number
+            else:
+                return None
+
+        with self._fi as lib:
+            for model_name, subdict in metadata.items():
+                # Get model number
+                number = models.get(model_name, None)
+                if number is None:
+                    continue  # Unknown model, silent ignore
+
+                for tag_name, tag_val in subdict.items():
+                    # Create new tag
+                    tag = lib.FreeImage_CreateTag()
+                    tag = ctypes.c_void_p(tag)
+
+                    try:
+                        # Convert Python value to FI type, val
+                        is_ascii = False
+                        if isinstance(tag_val, str):
+                            try:
+                                tag_bytes = tag_val.encode("ascii")
+                                is_ascii = True
+                            except UnicodeError:
+                                pass
+                        if is_ascii:
+                            tag_type = METADATA_DATATYPE.FIDT_ASCII
+                            tag_count = len(tag_bytes)
+                        else:
+                            if not hasattr(tag_val, "dtype"):
+                                tag_val = numpy.array([tag_val])
+                            tag_type = get_tag_type_number(tag_val.dtype)
+                            if tag_type is None:
+                                logger.warning(
+                                    "imageio.freeimage warning: Could not "
+                                    "determine tag type of %r." % tag_name
+                                )
+                                continue
+                            tag_bytes = tag_val.tobytes()
+                            tag_count = tag_val.size
+                        # Set properties
+                        lib.FreeImage_SetTagKey(tag, tag_name.encode("utf-8"))
+                        lib.FreeImage_SetTagType(tag, tag_type)
+                        lib.FreeImage_SetTagCount(tag, tag_count)
+                        lib.FreeImage_SetTagLength(tag, len(tag_bytes))
+                        lib.FreeImage_SetTagValue(tag, tag_bytes)
+                        # Store tag
+                        tag_key = lib.FreeImage_GetTagKey(tag)
+                        lib.FreeImage_SetMetadata(number, self._bitmap, tag_key, tag)
+
+                    except Exception as err:  # pragma: no cover
+                        logger.warning(
+                            "imagio.freeimage warning: Could not set tag "
+                            "%r: %s, %s"
+                            % (tag_name, self._fi._get_error_message(), str(err))
+                        )
+                    finally:
+                        lib.FreeImage_DeleteTag(tag)
+
+
+class FIBitmap(FIBaseBitmap):
+    """Wrapper for the FI bitmap object."""
+
+    def allocate(self, array):
+        # Prepare array
+        assert isinstance(array, numpy.ndarray)
+        shape = array.shape
+        dtype = array.dtype
+
+        # Get shape and channel info
+        r, c = shape[:2]
+        if len(shape) == 2:
+            n_channels = 1
+        elif len(shape) == 3:
+            n_channels = shape[2]
+        else:
+            n_channels = shape[0]
+
+        # Get fi_type
+        try:
+            fi_type = FI_TYPES.fi_types[(dtype.type, n_channels)]
+            self._fi_type = fi_type
+        except KeyError:
+            raise ValueError("Cannot write arrays of given type and shape.")
+
+        # Allocate bitmap
+        with self._fi as lib:
+            bpp = 8 * dtype.itemsize * n_channels
+            bitmap = lib.FreeImage_AllocateT(fi_type, c, r, bpp, 0, 0, 0)
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and store
+            if not bitmap:  # pragma: no cover
+                raise RuntimeError(
+                    "Could not allocate bitmap for storage: %s"
+                    % self._fi._get_error_message()
+                )
+            self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    def load_from_filename(self, filename=None):
+        if filename is None:
+            filename = self._filename
+
+        with self._fi as lib:
+            # Create bitmap
+            bitmap = lib.FreeImage_Load(self._ftype, efn(filename), self._flags)
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and store
+            if not bitmap:  # pragma: no cover
+                raise ValueError(
+                    'Could not load bitmap "%s": %s'
+                    % (self._filename, self._fi._get_error_message())
+                )
+            self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    # def load_from_bytes(self, bb):
+    #     with self._fi as lib:
+    #         # Create bitmap
+    #         fimemory = lib.FreeImage_OpenMemory(
+    #                                         ctypes.c_char_p(bb), len(bb))
+    #         bitmap = lib.FreeImage_LoadFromMemory(
+    #                         self._ftype, ctypes.c_void_p(fimemory), self._flags)
+    #         bitmap = ctypes.c_void_p(bitmap)
+    #         lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #
+    #         # Check
+    #         if not bitmap:
+    #             raise ValueError('Could not load bitmap "%s": %s'
+    #                         % (self._filename, self._fi._get_error_message()))
+    #         else:
+    #             self._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+
+    def save_to_filename(self, filename=None):
+        if filename is None:
+            filename = self._filename
+
+        ftype = self._ftype
+        bitmap = self._bitmap
+        fi_type = self._fi_type  # element type
+
+        with self._fi as lib:
+            # Check if can write
+            if fi_type == FI_TYPES.FIT_BITMAP:
+                can_write = lib.FreeImage_FIFSupportsExportBPP(
+                    ftype, lib.FreeImage_GetBPP(bitmap)
+                )
+            else:
+                can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
+            if not can_write:
+                raise TypeError("Cannot save image of this format to this file type")
+
+            # Save to file
+            res = lib.FreeImage_Save(ftype, bitmap, efn(filename), self._flags)
+            # Check
+            if res is None:  # pragma: no cover, we do so many checks, this is rare
+                raise RuntimeError(
+                    f"Could not save file `{self._filename}`: {self._fi._get_error_message()}"
+                )
+
+    # def save_to_bytes(self):
+    #     ftype = self._ftype
+    #     bitmap = self._bitmap
+    #     fi_type = self._fi_type # element type
+    #
+    #     with self._fi as lib:
+    #         # Check if can write
+    #         if fi_type == FI_TYPES.FIT_BITMAP:
+    #             can_write = lib.FreeImage_FIFSupportsExportBPP(ftype,
+    #                                     lib.FreeImage_GetBPP(bitmap))
+    #         else:
+    #             can_write = lib.FreeImage_FIFSupportsExportType(ftype, fi_type)
+    #         if not can_write:
+    #             raise TypeError('Cannot save image of this format '
+    #                             'to this file type')
+    #
+    #         # Extract the bytes
+    #         fimemory = lib.FreeImage_OpenMemory(0, 0)
+    #         res = lib.FreeImage_SaveToMemory(ftype, bitmap,
+    #                                          ctypes.c_void_p(fimemory),
+    #                                          self._flags)
+    #         if res:
+    #             N = lib.FreeImage_TellMemory(ctypes.c_void_p(fimemory))
+    #             result = ctypes.create_string_buffer(N)
+    #             lib.FreeImage_SeekMemory(ctypes.c_void_p(fimemory), 0)
+    #             lib.FreeImage_ReadMemory(result, 1, N, ctypes.c_void_p(fimemory))
+    #             result = result.raw
+    #         lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #
+    #         # Check
+    #         if not res:
+    #             raise RuntimeError('Could not save file "%s": %s'
+    #                     % (self._filename, self._fi._get_error_message()))
+    #
+    #     # Done
+    #     return result
+
+    def get_image_data(self):
+        dtype, shape, bpp = self._get_type_and_shape()
+        array = self._wrap_bitmap_bits_in_array(shape, dtype, False)
+        with self._fi as lib:
+            isle = lib.FreeImage_IsLittleEndian()
+
+        # swizzle the color components and flip the scanlines to go from
+        # FreeImage's BGR[A] and upside-down internal memory format to
+        # something more normal
+        def n(arr):
+            # return arr[..., ::-1].T  # Does not work on numpypy yet
+            if arr.ndim == 1:  # pragma: no cover
+                return arr[::-1].T
+            elif arr.ndim == 2:  # Always the case here ...
+                return arr[:, ::-1].T
+            elif arr.ndim == 3:  # pragma: no cover
+                return arr[:, :, ::-1].T
+            elif arr.ndim == 4:  # pragma: no cover
+                return arr[:, :, :, ::-1].T
+
+        if len(shape) == 3 and isle and dtype.type == numpy.uint8:
+            b = n(array[0])
+            g = n(array[1])
+            r = n(array[2])
+            if shape[0] == 3:
+                return numpy.dstack((r, g, b))
+            elif shape[0] == 4:
+                a = n(array[3])
+                return numpy.dstack((r, g, b, a))
+            else:  # pragma: no cover - we check this earlier
+                raise ValueError("Cannot handle images of shape %s" % shape)
+
+        # We need to copy because array does *not* own its memory
+        # after bitmap is freed.
+        a = n(array).copy()
+        return a
+
+    def set_image_data(self, array):
+        # Prepare array
+        assert isinstance(array, numpy.ndarray)
+        shape = array.shape
+        dtype = array.dtype
+        with self._fi as lib:
+            isle = lib.FreeImage_IsLittleEndian()
+
+        # Calculate shape and channels
+        r, c = shape[:2]
+        if len(shape) == 2:
+            n_channels = 1
+            w_shape = (c, r)
+        elif len(shape) == 3:
+            n_channels = shape[2]
+            w_shape = (n_channels, c, r)
+        else:
+            n_channels = shape[0]
+
+        def n(arr):  # normalise to freeimage's in-memory format
+            return arr[::-1].T
+
+        wrapped_array = self._wrap_bitmap_bits_in_array(w_shape, dtype, True)
+        # swizzle the color components and flip the scanlines to go to
+        # FreeImage's BGR[A] and upside-down internal memory format
+        # The BGR[A] order is only used for 8bits per channel images
+        # on little endian machines. For everything else RGB[A] is
+        # used.
+        if len(shape) == 3 and isle and dtype.type == numpy.uint8:
+            R = array[:, :, 0]
+            G = array[:, :, 1]
+            B = array[:, :, 2]
+            wrapped_array[0] = n(B)
+            wrapped_array[1] = n(G)
+            wrapped_array[2] = n(R)
+            if shape[2] == 4:
+                A = array[:, :, 3]
+                wrapped_array[3] = n(A)
+        else:
+            wrapped_array[:] = n(array)
+        if self._need_finish:
+            self._finish_wrapped_array(wrapped_array)
+
+        if len(shape) == 2 and dtype.type == numpy.uint8:
+            with self._fi as lib:
+                palette = lib.FreeImage_GetPalette(self._bitmap)
+            palette = ctypes.c_void_p(palette)
+            if not palette:
+                raise RuntimeError("Could not get image palette")
+            try:
+                palette_data = GREY_PALETTE.ctypes.data
+            except Exception:  # pragma: no cover - IS_PYPY
+                palette_data = GREY_PALETTE.__array_interface__["data"][0]
+            ctypes.memmove(palette, palette_data, 1024)
+
+    def _wrap_bitmap_bits_in_array(self, shape, dtype, save):
+        """Return an ndarray view on the data in a FreeImage bitmap. Only
+        valid for as long as the bitmap is loaded (if single page) / locked
+        in memory (if multipage). This is used in loading data, but
+        also during saving, to prepare a strided numpy array buffer.
+
+        """
+        # Get bitmap info
+        with self._fi as lib:
+            pitch = lib.FreeImage_GetPitch(self._bitmap)
+            bits = lib.FreeImage_GetBits(self._bitmap)
+
+        # Get more info
+        height = shape[-1]
+        byte_size = height * pitch
+        itemsize = dtype.itemsize
+
+        # Get strides
+        if len(shape) == 3:
+            strides = (itemsize, shape[0] * itemsize, pitch)
+        else:
+            strides = (itemsize, pitch)
+
+        # Create numpy array and return
+        data = (ctypes.c_char * byte_size).from_address(bits)
+        try:
+            self._need_finish = False
+            if TEST_NUMPY_NO_STRIDES:
+                raise NotImplementedError()
+            return numpy.ndarray(shape, dtype=dtype, buffer=data, strides=strides)
+        except NotImplementedError:
+            # IS_PYPY - not very efficient. We create a C-contiguous
+            # numpy array (because pypy does not support Fortran-order)
+            # and shape it such that the rest of the code can remain.
+            if save:
+                self._need_finish = True  # Flag to use _finish_wrapped_array
+                return numpy.zeros(shape, dtype=dtype)
+            else:
+                bb = bytes(bytearray(data))
+                array = numpy.frombuffer(bb, dtype=dtype).copy()
+                # Deal with strides
+                if len(shape) == 3:
+                    array.shape = shape[2], strides[-1] // shape[0], shape[0]
+                    array2 = array[: shape[2], : shape[1], : shape[0]]
+                    array = numpy.zeros(shape, dtype=array.dtype)
+                    for i in range(shape[0]):
+                        array[i] = array2[:, :, i].T
+                else:
+                    array.shape = shape[1], strides[-1]
+                    array = array[: shape[1], : shape[0]].T
+                return array
+
+    def _finish_wrapped_array(self, array):  # IS_PYPY
+        """Hardcore way to inject numpy array in bitmap."""
+        # Get bitmap info
+        with self._fi as lib:
+            pitch = lib.FreeImage_GetPitch(self._bitmap)
+            bits = lib.FreeImage_GetBits(self._bitmap)
+            bpp = lib.FreeImage_GetBPP(self._bitmap)
+        # Get channels and realwidth
+        nchannels = bpp // 8 // array.itemsize
+        realwidth = pitch // nchannels
+        # Apply padding for pitch if necessary
+        extra = realwidth - array.shape[-2]
+        assert 0 <= extra < 10
+        # Make sort of Fortran, also take padding (i.e. pitch) into account
+        newshape = array.shape[-1], realwidth, nchannels
+        array2 = numpy.zeros(newshape, array.dtype)
+        if nchannels == 1:
+            array2[:, : array.shape[-2], 0] = array.T
+        else:
+            for i in range(nchannels):
+                array2[:, : array.shape[-2], i] = array[i, :, :].T
+        # copy data
+        data_ptr = array2.__array_interface__["data"][0]
+        ctypes.memmove(bits, data_ptr, array2.nbytes)
+        del array2
+
+    def _get_type_and_shape(self):
+        bitmap = self._bitmap
+
+        # Get info on bitmap
+        with self._fi as lib:
+            w = lib.FreeImage_GetWidth(bitmap)
+            h = lib.FreeImage_GetHeight(bitmap)
+            self._fi_type = fi_type = lib.FreeImage_GetImageType(bitmap)
+            if not fi_type:
+                raise ValueError("Unknown image pixel type")
+
+        # Determine required props for numpy array
+        bpp = None
+        dtype = FI_TYPES.dtypes[fi_type]
+
+        if fi_type == FI_TYPES.FIT_BITMAP:
+            with self._fi as lib:
+                bpp = lib.FreeImage_GetBPP(bitmap)
+                has_pallette = lib.FreeImage_GetColorsUsed(bitmap)
+            if has_pallette:
+                # Examine the palette. If it is grayscale, we return as such
+                if has_pallette == 256:
+                    palette = lib.FreeImage_GetPalette(bitmap)
+                    palette = ctypes.c_void_p(palette)
+                    p = (ctypes.c_uint8 * (256 * 4)).from_address(palette.value)
+                    p = numpy.frombuffer(p, numpy.uint32).copy()
+                    if (GREY_PALETTE == p).all():
+                        extra_dims = []
+                        return numpy.dtype(dtype), extra_dims + [w, h], bpp
+                # Convert bitmap and call this method again
+                newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
+                newbitmap = ctypes.c_void_p(newbitmap)
+                self._set_bitmap(newbitmap)
+                return self._get_type_and_shape()
+            elif bpp == 8:
+                extra_dims = []
+            elif bpp == 24:
+                extra_dims = [3]
+            elif bpp == 32:
+                extra_dims = [4]
+            else:  # pragma: no cover
+                # raise ValueError('Cannot convert %d BPP bitmap' % bpp)
+                # Convert bitmap and call this method again
+                newbitmap = lib.FreeImage_ConvertTo32Bits(bitmap)
+                newbitmap = ctypes.c_void_p(newbitmap)
+                self._set_bitmap(newbitmap)
+                return self._get_type_and_shape()
+        else:
+            extra_dims = FI_TYPES.extra_dims[fi_type]
+
+        # Return dtype and shape
+        return numpy.dtype(dtype), extra_dims + [w, h], bpp
+
+    def quantize(self, quantizer=0, palettesize=256):
+        """Quantize the bitmap to make it 8-bit (paletted). Returns a new
+        FIBitmap object.
+        Only for 24 bit images.
+        """
+        with self._fi as lib:
+            # New bitmap
+            bitmap = lib.FreeImage_ColorQuantizeEx(
+                self._bitmap, quantizer, palettesize, 0, None
+            )
+            bitmap = ctypes.c_void_p(bitmap)
+
+            # Check and return
+            if not bitmap:
+                raise ValueError(
+                    'Could not quantize bitmap "%s": %s'
+                    % (self._filename, self._fi._get_error_message())
+                )
+
+            new = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
+            new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+            new._fi_type = self._fi_type
+            return new
+
+
+# def convert_to_32bit(self):
+#     """ Convert to 32bit image.
+#     """
+#     with self._fi as lib:
+#         # New bitmap
+#         bitmap = lib.FreeImage_ConvertTo32Bits(self._bitmap)
+#         bitmap = ctypes.c_void_p(bitmap)
+#
+#         # Check and return
+#         if not bitmap:
+#             raise ValueError('Could not convert bitmap to 32bit "%s": %s' %
+#                                 (self._filename,
+#                                 self._fi._get_error_message()))
+#         else:
+#             new = FIBitmap(self._fi, self._filename, self._ftype,
+#                             self._flags)
+#             new._set_bitmap(bitmap, (lib.FreeImage_Unload, bitmap))
+#             new._fi_type = self._fi_type
+#             return new
+
+
+class FIMultipageBitmap(FIBaseBitmap):
+    """Wrapper for the multipage FI bitmap object."""
+
+    def load_from_filename(self, filename=None):
+        if filename is None:  # pragma: no cover
+            filename = self._filename
+
+        # Prepare
+        create_new = False
+        read_only = True
+        keep_cache_in_memory = False
+
+        # Try opening
+        with self._fi as lib:
+            # Create bitmap
+            multibitmap = lib.FreeImage_OpenMultiBitmap(
+                self._ftype,
+                efn(filename),
+                create_new,
+                read_only,
+                keep_cache_in_memory,
+                self._flags,
+            )
+            multibitmap = ctypes.c_void_p(multibitmap)
+
+            # Check
+            if not multibitmap:  # pragma: no cover
+                err = self._fi._get_error_message()
+                raise ValueError(
+                    'Could not open file "%s" as multi-image: %s'
+                    % (self._filename, err)
+                )
+            self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    # def load_from_bytes(self, bb):
+    #     with self._fi as lib:
+    #         # Create bitmap
+    #         fimemory = lib.FreeImage_OpenMemory(
+    #                                         ctypes.c_char_p(bb), len(bb))
+    #         multibitmap = lib.FreeImage_LoadMultiBitmapFromMemory(
+    #             self._ftype, ctypes.c_void_p(fimemory), self._flags)
+    #         multibitmap = ctypes.c_void_p(multibitmap)
+    #         #lib.FreeImage_CloseMemory(ctypes.c_void_p(fimemory))
+    #         self._mem = fimemory
+    #         self._bytes = bb
+    #         # Check
+    #         if not multibitmap:
+    #             raise ValueError('Could not load multibitmap "%s": %s'
+    #                         % (self._filename, self._fi._get_error_message()))
+    #         else:
+    #             self._set_bitmap(multibitmap,
+    #                              (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    def save_to_filename(self, filename=None):
+        if filename is None:  # pragma: no cover
+            filename = self._filename
+
+        # Prepare
+        create_new = True
+        read_only = False
+        keep_cache_in_memory = False
+
+        # Open the file
+        # todo: Set flags at close func
+        with self._fi as lib:
+            multibitmap = lib.FreeImage_OpenMultiBitmap(
+                self._ftype,
+                efn(filename),
+                create_new,
+                read_only,
+                keep_cache_in_memory,
+                0,
+            )
+            multibitmap = ctypes.c_void_p(multibitmap)
+
+            # Check
+            if not multibitmap:  # pragma: no cover
+                msg = 'Could not open file "%s" for writing multi-image: %s' % (
+                    self._filename,
+                    self._fi._get_error_message(),
+                )
+                raise ValueError(msg)
+            self._set_bitmap(multibitmap, (lib.FreeImage_CloseMultiBitmap, multibitmap))
+
+    def __len__(self):
+        with self._fi as lib:
+            return lib.FreeImage_GetPageCount(self._bitmap)
+
+    def get_page(self, index):
+        """Return the sub-bitmap for the given page index.
+        Please close the returned bitmap when done.
+        """
+        with self._fi as lib:
+            # Create low-level bitmap in freeimage
+            bitmap = lib.FreeImage_LockPage(self._bitmap, index)
+            bitmap = ctypes.c_void_p(bitmap)
+            if not bitmap:  # pragma: no cover
+                raise ValueError(
+                    "Could not open sub-image %i in %r: %s"
+                    % (index, self._filename, self._fi._get_error_message())
+                )
+
+            # Get bitmap object to wrap this bitmap
+            bm = FIBitmap(self._fi, self._filename, self._ftype, self._flags)
+            bm._set_bitmap(
+                bitmap, (lib.FreeImage_UnlockPage, self._bitmap, bitmap, False)
+            )
+            return bm
+
+    def append_bitmap(self, bitmap):
+        """Add a sub-bitmap to the multi-page bitmap."""
+        with self._fi as lib:
+            # no return value
+            lib.FreeImage_AppendPage(self._bitmap, bitmap._bitmap)
+
+
+# Create instance
+fi = Freeimage()

parrot/lib/python3.10/site-packages/imageio/plugins/_swf.py

@@ -0,0 +1,897 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+# This code was taken from https://github.com/almarklein/visvis/blob/master/vvmovie/images2swf.py
+
+# styletest: ignore E261
+
+"""
+Provides a function (write_swf) to store a series of numpy arrays in an
+SWF movie, that can be played on a wide range of OS's.
+
+In desperation of wanting to share animated images, and then lacking a good
+writer for animated gif or .avi, I decided to look into SWF. This format
+is very well documented.
+
+This is a pure python module to create an SWF file that shows a series
+of images. The images are stored using the DEFLATE algorithm (same as
+PNG and ZIP and which is included in the standard Python distribution).
+As this compression algorithm is much more effective than that used in
+GIF images, we obtain better quality (24 bit colors + alpha channel)
+while still producesing smaller files (a test showed ~75%). Although
+SWF also allows for JPEG compression, doing so would probably require
+a third party library for the JPEG encoding/decoding, we could
+perhaps do this via Pillow or freeimage.
+
+sources and tools:
+
+- SWF on wikipedia
+- Adobes "SWF File Format Specification" version 10
+  (http://www.adobe.com/devnet/swf/pdf/swf_file_format_spec_v10.pdf)
+- swftools (swfdump in specific) for debugging
+- iwisoft swf2avi can be used to convert swf to avi/mpg/flv with really
+  good quality, while file size is reduced with factors 20-100.
+  A good program in my opinion. The free version has the limitation
+  of a watermark in the upper left corner.
+
+"""
+
+import os
+import zlib
+import time  # noqa
+import logging
+
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+# todo: use Pillow to support reading JPEG images from SWF?
+
+
+# Base functions and classes
+
+
+class BitArray:
+    """Dynamic array of bits that automatically resizes
+    with factors of two.
+    Append bits using .append() or +=
+    You can reverse bits using .reverse()
+    """
+
+    def __init__(self, initvalue=None):
+        self.data = np.zeros((16,), dtype=np.uint8)
+        self._len = 0
+        if initvalue is not None:
+            self.append(initvalue)
+
+    def __len__(self):
+        return self._len  # self.data.shape[0]
+
+    def __repr__(self):
+        return self.data[: self._len].tobytes().decode("ascii")
+
+    def _checkSize(self):
+        # check length... grow if necessary
+        arraylen = self.data.shape[0]
+        if self._len >= arraylen:
+            tmp = np.zeros((arraylen * 2,), dtype=np.uint8)
+            tmp[: self._len] = self.data[: self._len]
+            self.data = tmp
+
+    def __add__(self, value):
+        self.append(value)
+        return self
+
+    def append(self, bits):
+        # check input
+        if isinstance(bits, BitArray):
+            bits = str(bits)
+        if isinstance(bits, int):  # pragma: no cover - we dont use it
+            bits = str(bits)
+        if not isinstance(bits, str):  # pragma: no cover
+            raise ValueError("Append bits as strings or integers!")
+
+        # add bits
+        for bit in bits:
+            self.data[self._len] = ord(bit)
+            self._len += 1
+            self._checkSize()
+
+    def reverse(self):
+        """In-place reverse."""
+        tmp = self.data[: self._len].copy()
+        self.data[: self._len] = tmp[::-1]
+
+    def tobytes(self):
+        """Convert to bytes. If necessary,
+        zeros are padded to the end (right side).
+        """
+        bits = str(self)
+
+        # determine number of bytes
+        nbytes = 0
+        while nbytes * 8 < len(bits):
+            nbytes += 1
+        # pad
+        bits = bits.ljust(nbytes * 8, "0")
+
+        # go from bits to bytes
+        bb = bytes()
+        for i in range(nbytes):
+            tmp = int(bits[i * 8 : (i + 1) * 8], 2)
+            bb += int2uint8(tmp)
+
+        # done
+        return bb
+
+
+def int2uint32(i):
+    return int(i).to_bytes(4, "little")
+
+
+def int2uint16(i):
+    return int(i).to_bytes(2, "little")
+
+
+def int2uint8(i):
+    return int(i).to_bytes(1, "little")
+
+
+def int2bits(i, n=None):
+    """convert int to a string of bits (0's and 1's in a string),
+    pad to n elements. Convert back using int(ss,2)."""
+    ii = i
+
+    # make bits
+    bb = BitArray()
+    while ii > 0:
+        bb += str(ii % 2)
+        ii = ii >> 1
+    bb.reverse()
+
+    # justify
+    if n is not None:
+        if len(bb) > n:  # pragma: no cover
+            raise ValueError("int2bits fail: len larger than padlength.")
+        bb = str(bb).rjust(n, "0")
+
+    # done
+    return BitArray(bb)
+
+
+def bits2int(bb, n=8):
+    # Init
+    value = ""
+
+    # Get value in bits
+    for i in range(len(bb)):
+        b = bb[i : i + 1]
+        tmp = bin(ord(b))[2:]
+        # value += tmp.rjust(8,'0')
+        value = tmp.rjust(8, "0") + value
+
+    # Make decimal
+    return int(value[:n], 2)
+
+
+def get_type_and_len(bb):
+    """bb should be 6 bytes at least
+    Return (type, length, length_of_full_tag)
+    """
+    # Init
+    value = ""
+
+    # Get first 16 bits
+    for i in range(2):
+        b = bb[i : i + 1]
+        tmp = bin(ord(b))[2:]
+        # value += tmp.rjust(8,'0')
+        value = tmp.rjust(8, "0") + value
+
+    # Get type and length
+    type = int(value[:10], 2)
+    L = int(value[10:], 2)
+    L2 = L + 2
+
+    # Long tag header?
+    if L == 63:  # '111111'
+        value = ""
+        for i in range(2, 6):
+            b = bb[i : i + 1]  # becomes a single-byte bytes()
+            tmp = bin(ord(b))[2:]
+            # value += tmp.rjust(8,'0')
+            value = tmp.rjust(8, "0") + value
+        L = int(value, 2)
+        L2 = L + 6
+
+    # Done
+    return type, L, L2
+
+
+def signedint2bits(i, n=None):
+    """convert signed int to a string of bits (0's and 1's in a string),
+    pad to n elements. Negative numbers are stored in 2's complement bit
+    patterns, thus positive numbers always start with a 0.
+    """
+
+    # negative number?
+    ii = i
+    if i < 0:
+        # A negative number, -n, is represented as the bitwise opposite of
+        ii = abs(ii) - 1  # the positive-zero number n-1.
+
+    # make bits
+    bb = BitArray()
+    while ii > 0:
+        bb += str(ii % 2)
+        ii = ii >> 1
+    bb.reverse()
+
+    # justify
+    bb = "0" + str(bb)  # always need the sign bit in front
+    if n is not None:
+        if len(bb) > n:  # pragma: no cover
+            raise ValueError("signedint2bits fail: len larger than padlength.")
+        bb = bb.rjust(n, "0")
+
+    # was it negative? (then opposite bits)
+    if i < 0:
+        bb = bb.replace("0", "x").replace("1", "0").replace("x", "1")
+
+    # done
+    return BitArray(bb)
+
+
+def twits2bits(arr):
+    """Given a few (signed) numbers, store them
+    as compactly as possible in the wat specifief by the swf format.
+    The numbers are multiplied by 20, assuming they
+    are twits.
+    Can be used to make the RECT record.
+    """
+
+    # first determine length using non justified bit strings
+    maxlen = 1
+    for i in arr:
+        tmp = len(signedint2bits(i * 20))
+        if tmp > maxlen:
+            maxlen = tmp
+
+    # build array
+    bits = int2bits(maxlen, 5)
+    for i in arr:
+        bits += signedint2bits(i * 20, maxlen)
+
+    return bits
+
+
+def floats2bits(arr):
+    """Given a few (signed) numbers, convert them to bits,
+    stored as FB (float bit values). We always use 16.16.
+    Negative numbers are not (yet) possible, because I don't
+    know how the're implemented (ambiguity).
+    """
+    bits = int2bits(31, 5)  # 32 does not fit in 5 bits!
+    for i in arr:
+        if i < 0:  # pragma: no cover
+            raise ValueError("Dit not implement negative floats!")
+        i1 = int(i)
+        i2 = i - i1
+        bits += int2bits(i1, 15)
+        bits += int2bits(i2 * 2**16, 16)
+    return bits
+
+
+# Base Tag
+
+
+class Tag:
+    def __init__(self):
+        self.bytes = bytes()
+        self.tagtype = -1
+
+    def process_tag(self):
+        """Implement this to create the tag."""
+        raise NotImplementedError()
+
+    def get_tag(self):
+        """Calls processTag and attaches the header."""
+        self.process_tag()
+
+        # tag to binary
+        bits = int2bits(self.tagtype, 10)
+
+        # complete header uint16 thing
+        bits += "1" * 6  # = 63 = 0x3f
+        # make uint16
+        bb = int2uint16(int(str(bits), 2))
+
+        # now add 32bit length descriptor
+        bb += int2uint32(len(self.bytes))
+
+        # done, attach and return
+        bb += self.bytes
+        return bb
+
+    def make_rect_record(self, xmin, xmax, ymin, ymax):
+        """Simply uses makeCompactArray to produce
+        a RECT Record."""
+        return twits2bits([xmin, xmax, ymin, ymax])
+
+    def make_matrix_record(self, scale_xy=None, rot_xy=None, trans_xy=None):
+        # empty matrix?
+        if scale_xy is None and rot_xy is None and trans_xy is None:
+            return "0" * 8
+
+        # init
+        bits = BitArray()
+
+        # scale
+        if scale_xy:
+            bits += "1"
+            bits += floats2bits([scale_xy[0], scale_xy[1]])
+        else:
+            bits += "0"
+
+        # rotation
+        if rot_xy:
+            bits += "1"
+            bits += floats2bits([rot_xy[0], rot_xy[1]])
+        else:
+            bits += "0"
+
+        # translation (no flag here)
+        if trans_xy:
+            bits += twits2bits([trans_xy[0], trans_xy[1]])
+        else:
+            bits += twits2bits([0, 0])
+
+        # done
+        return bits
+
+
+# Control tags
+
+
+class ControlTag(Tag):
+    def __init__(self):
+        Tag.__init__(self)
+
+
+class FileAttributesTag(ControlTag):
+    def __init__(self):
+        ControlTag.__init__(self)
+        self.tagtype = 69
+
+    def process_tag(self):
+        self.bytes = "\x00".encode("ascii") * (1 + 3)
+
+
+class ShowFrameTag(ControlTag):
+    def __init__(self):
+        ControlTag.__init__(self)
+        self.tagtype = 1
+
+    def process_tag(self):
+        self.bytes = bytes()
+
+
+class SetBackgroundTag(ControlTag):
+    """Set the color in 0-255, or 0-1 (if floats given)."""
+
+    def __init__(self, *rgb):
+        self.tagtype = 9
+        if len(rgb) == 1:
+            rgb = rgb[0]
+        self.rgb = rgb
+
+    def process_tag(self):
+        bb = bytes()
+        for i in range(3):
+            clr = self.rgb[i]
+            if isinstance(clr, float):  # pragma: no cover - not used
+                clr = clr * 255
+            bb += int2uint8(clr)
+        self.bytes = bb
+
+
+class DoActionTag(Tag):
+    def __init__(self, action="stop"):
+        Tag.__init__(self)
+        self.tagtype = 12
+        self.actions = [action]
+
+    def append(self, action):  # pragma: no cover - not used
+        self.actions.append(action)
+
+    def process_tag(self):
+        bb = bytes()
+
+        for action in self.actions:
+            action = action.lower()
+            if action == "stop":
+                bb += "\x07".encode("ascii")
+            elif action == "play":  # pragma: no cover - not used
+                bb += "\x06".encode("ascii")
+            else:  # pragma: no cover
+                logger.warning("unknown action: %s" % action)
+
+        bb += int2uint8(0)
+        self.bytes = bb
+
+
+# Definition tags
+class DefinitionTag(Tag):
+    counter = 0  # to give automatically id's
+
+    def __init__(self):
+        Tag.__init__(self)
+        DefinitionTag.counter += 1
+        self.id = DefinitionTag.counter  # id in dictionary
+
+
+class BitmapTag(DefinitionTag):
+    def __init__(self, im):
+        DefinitionTag.__init__(self)
+        self.tagtype = 36  # DefineBitsLossless2
+
+        # convert image (note that format is ARGB)
+        # even a grayscale image is stored in ARGB, nevertheless,
+        # the fabilous deflate compression will make it that not much
+        # more data is required for storing (25% or so, and less than 10%
+        # when storing RGB as ARGB).
+
+        if len(im.shape) == 3:
+            if im.shape[2] in [3, 4]:
+                tmp = np.ones((im.shape[0], im.shape[1], 4), dtype=np.uint8) * 255
+                for i in range(3):
+                    tmp[:, :, i + 1] = im[:, :, i]
+                if im.shape[2] == 4:
+                    tmp[:, :, 0] = im[:, :, 3]  # swap channel where alpha is
+            else:  # pragma: no cover
+                raise ValueError("Invalid shape to be an image.")
+
+        elif len(im.shape) == 2:
+            tmp = np.ones((im.shape[0], im.shape[1], 4), dtype=np.uint8) * 255
+            for i in range(3):
+                tmp[:, :, i + 1] = im[:, :]
+        else:  # pragma: no cover
+            raise ValueError("Invalid shape to be an image.")
+
+        # we changed the image to uint8 4 channels.
+        # now compress!
+        self._data = zlib.compress(tmp.tobytes(), zlib.DEFLATED)
+        self.imshape = im.shape
+
+    def process_tag(self):
+        # build tag
+        bb = bytes()
+        bb += int2uint16(self.id)  # CharacterID
+        bb += int2uint8(5)  # BitmapFormat
+        bb += int2uint16(self.imshape[1])  # BitmapWidth
+        bb += int2uint16(self.imshape[0])  # BitmapHeight
+        bb += self._data  # ZlibBitmapData
+
+        self.bytes = bb
+
+
+class PlaceObjectTag(ControlTag):
+    def __init__(self, depth, idToPlace=None, xy=(0, 0), move=False):
+        ControlTag.__init__(self)
+        self.tagtype = 26
+        self.depth = depth
+        self.idToPlace = idToPlace
+        self.xy = xy
+        self.move = move
+
+    def process_tag(self):
+        # retrieve stuff
+        depth = self.depth
+        xy = self.xy
+        id = self.idToPlace
+
+        # build PlaceObject2
+        bb = bytes()
+        if self.move:
+            bb += "\x07".encode("ascii")
+        else:
+            # (8 bit flags): 4:matrix, 2:character, 1:move
+            bb += "\x06".encode("ascii")
+        bb += int2uint16(depth)  # Depth
+        bb += int2uint16(id)  # character id
+        bb += self.make_matrix_record(trans_xy=xy).tobytes()  # MATRIX record
+        self.bytes = bb
+
+
+class ShapeTag(DefinitionTag):
+    def __init__(self, bitmapId, xy, wh):
+        DefinitionTag.__init__(self)
+        self.tagtype = 2
+        self.bitmapId = bitmapId
+        self.xy = xy
+        self.wh = wh
+
+    def process_tag(self):
+        """Returns a defineshape tag. with a bitmap fill"""
+
+        bb = bytes()
+        bb += int2uint16(self.id)
+        xy, wh = self.xy, self.wh
+        tmp = self.make_rect_record(xy[0], wh[0], xy[1], wh[1])  # ShapeBounds
+        bb += tmp.tobytes()
+
+        # make SHAPEWITHSTYLE structure
+
+        # first entry: FILLSTYLEARRAY with in it a single fill style
+        bb += int2uint8(1)  # FillStyleCount
+        bb += "\x41".encode("ascii")  # FillStyleType (0x41 or 0x43 unsmoothed)
+        bb += int2uint16(self.bitmapId)  # BitmapId
+        # bb += '\x00' # BitmapMatrix (empty matrix with leftover bits filled)
+        bb += self.make_matrix_record(scale_xy=(20, 20)).tobytes()
+
+        #         # first entry: FILLSTYLEARRAY with in it a single fill style
+        #         bb += int2uint8(1)  # FillStyleCount
+        #         bb += '\x00' # solid fill
+        #         bb += '\x00\x00\xff' # color
+
+        # second entry: LINESTYLEARRAY with a single line style
+        bb += int2uint8(0)  # LineStyleCount
+        # bb += int2uint16(0*20) # Width
+        # bb += '\x00\xff\x00'  # Color
+
+        # third and fourth entry: NumFillBits and NumLineBits (4 bits each)
+        # I each give them four bits, so 16 styles possible.
+        bb += "\x44".encode("ascii")
+
+        self.bytes = bb
+
+        # last entries: SHAPERECORDs ... (individual shape records not aligned)
+        # STYLECHANGERECORD
+        bits = BitArray()
+        bits += self.make_style_change_record(0, 1, moveTo=(self.wh[0], self.wh[1]))
+        # STRAIGHTEDGERECORD 4x
+        bits += self.make_straight_edge_record(-self.wh[0], 0)
+        bits += self.make_straight_edge_record(0, -self.wh[1])
+        bits += self.make_straight_edge_record(self.wh[0], 0)
+        bits += self.make_straight_edge_record(0, self.wh[1])
+
+        # ENDSHAPRECORD
+        bits += self.make_end_shape_record()
+
+        self.bytes += bits.tobytes()
+
+        # done
+        # self.bytes = bb
+
+    def make_style_change_record(self, lineStyle=None, fillStyle=None, moveTo=None):
+        # first 6 flags
+        # Note that we use FillStyle1. If we don't flash (at least 8) does not
+        # recognize the frames properly when importing to library.
+
+        bits = BitArray()
+        bits += "0"  # TypeFlag (not an edge record)
+        bits += "0"  # StateNewStyles (only for DefineShape2 and Defineshape3)
+        if lineStyle:
+            bits += "1"  # StateLineStyle
+        else:
+            bits += "0"
+        if fillStyle:
+            bits += "1"  # StateFillStyle1
+        else:
+            bits += "0"
+        bits += "0"  # StateFillStyle0
+        if moveTo:
+            bits += "1"  # StateMoveTo
+        else:
+            bits += "0"
+
+        # give information
+        # todo: nbits for fillStyle and lineStyle is hard coded.
+
+        if moveTo:
+            bits += twits2bits([moveTo[0], moveTo[1]])
+        if fillStyle:
+            bits += int2bits(fillStyle, 4)
+        if lineStyle:
+            bits += int2bits(lineStyle, 4)
+
+        return bits
+
+    def make_straight_edge_record(self, *dxdy):
+        if len(dxdy) == 1:
+            dxdy = dxdy[0]
+
+        # determine required number of bits
+        xbits = signedint2bits(dxdy[0] * 20)
+        ybits = signedint2bits(dxdy[1] * 20)
+        nbits = max([len(xbits), len(ybits)])
+
+        bits = BitArray()
+        bits += "11"  # TypeFlag and StraightFlag
+        bits += int2bits(nbits - 2, 4)
+        bits += "1"  # GeneralLineFlag
+        bits += signedint2bits(dxdy[0] * 20, nbits)
+        bits += signedint2bits(dxdy[1] * 20, nbits)
+
+        # note: I do not make use of vertical/horizontal only lines...
+
+        return bits
+
+    def make_end_shape_record(self):
+        bits = BitArray()
+        bits += "0"  # TypeFlag: no edge
+        bits += "0" * 5  # EndOfShape
+        return bits
+
+
+def read_pixels(bb, i, tagType, L1):
+    """With pf's seed after the recordheader, reads the pixeldata."""
+
+    # Get info
+    charId = bb[i : i + 2]  # noqa
+    i += 2
+    format = ord(bb[i : i + 1])
+    i += 1
+    width = bits2int(bb[i : i + 2], 16)
+    i += 2
+    height = bits2int(bb[i : i + 2], 16)
+    i += 2
+
+    # If we can, get pixeldata and make numpy array
+    if format != 5:
+        logger.warning("Can only read 24bit or 32bit RGB(A) lossless images.")
+    else:
+        # Read byte data
+        offset = 2 + 1 + 2 + 2  # all the info bits
+        bb2 = bb[i : i + (L1 - offset)]
+
+        # Decompress and make numpy array
+        data = zlib.decompress(bb2)
+        a = np.frombuffer(data, dtype=np.uint8)
+
+        # Set shape
+        if tagType == 20:
+            # DefineBitsLossless - RGB data
+            try:
+                a.shape = height, width, 3
+            except Exception:
+                # Byte align stuff might cause troubles
+                logger.warning("Cannot read image due to byte alignment")
+        if tagType == 36:
+            # DefineBitsLossless2 - ARGB data
+            a.shape = height, width, 4
+            # Swap alpha channel to make RGBA
+            b = a
+            a = np.zeros_like(a)
+            a[:, :, 0] = b[:, :, 1]
+            a[:, :, 1] = b[:, :, 2]
+            a[:, :, 2] = b[:, :, 3]
+            a[:, :, 3] = b[:, :, 0]
+
+        return a
+
+
+# Last few functions
+
+
+# These are the original public functions, we don't use them, but we
+# keep it so that in principle this module can be used stand-alone.
+
+
+def checkImages(images):  # pragma: no cover
+    """checkImages(images)
+    Check numpy images and correct intensity range etc.
+    The same for all movie formats.
+    """
+    # Init results
+    images2 = []
+
+    for im in images:
+        if isinstance(im, np.ndarray):
+            # Check and convert dtype
+            if im.dtype == np.uint8:
+                images2.append(im)  # Ok
+            elif im.dtype in [np.float32, np.float64]:
+                theMax = im.max()
+                if 128 < theMax < 300:
+                    pass  # assume 0:255
+                else:
+                    im = im.copy()
+                    im[im < 0] = 0
+                    im[im > 1] = 1
+                    im *= 255
+                images2.append(im.astype(np.uint8))
+            else:
+                im = im.astype(np.uint8)
+                images2.append(im)
+            # Check size
+            if im.ndim == 2:
+                pass  # ok
+            elif im.ndim == 3:
+                if im.shape[2] not in [3, 4]:
+                    raise ValueError("This array can not represent an image.")
+            else:
+                raise ValueError("This array can not represent an image.")
+        else:
+            raise ValueError("Invalid image type: " + str(type(im)))
+
+    # Done
+    return images2
+
+
+def build_file(
+    fp, taglist, nframes=1, framesize=(500, 500), fps=10, version=8
+):  # pragma: no cover
+    """Give the given file (as bytes) a header."""
+
+    # compose header
+    bb = bytes()
+    bb += "F".encode("ascii")  # uncompressed
+    bb += "WS".encode("ascii")  # signature bytes
+    bb += int2uint8(version)  # version
+    bb += "0000".encode("ascii")  # FileLength (leave open for now)
+    bb += Tag().make_rect_record(0, framesize[0], 0, framesize[1]).tobytes()
+    bb += int2uint8(0) + int2uint8(fps)  # FrameRate
+    bb += int2uint16(nframes)
+    fp.write(bb)
+
+    # produce all tags
+    for tag in taglist:
+        fp.write(tag.get_tag())
+
+    # finish with end tag
+    fp.write("\x00\x00".encode("ascii"))
+
+    # set size
+    sze = fp.tell()
+    fp.seek(4)
+    fp.write(int2uint32(sze))
+
+
+def write_swf(filename, images, duration=0.1, repeat=True):  # pragma: no cover
+    """Write an swf-file from the specified images. If repeat is False,
+    the movie is finished with a stop action. Duration may also
+    be a list with durations for each frame (note that the duration
+    for each frame is always an integer amount of the minimum duration.)
+
+    Images should be a list consisting numpy arrays with values between
+    0 and 255 for integer types, and between 0 and 1 for float types.
+
+    """
+
+    # Check images
+    images2 = checkImages(images)
+
+    # Init
+    taglist = [FileAttributesTag(), SetBackgroundTag(0, 0, 0)]
+
+    # Check duration
+    if hasattr(duration, "__len__"):
+        if len(duration) == len(images2):
+            duration = [d for d in duration]
+        else:
+            raise ValueError("len(duration) doesn't match amount of images.")
+    else:
+        duration = [duration for im in images2]
+
+    # Build delays list
+    minDuration = float(min(duration))
+    delays = [round(d / minDuration) for d in duration]
+    delays = [max(1, int(d)) for d in delays]
+
+    # Get FPS
+    fps = 1.0 / minDuration
+
+    # Produce series of tags for each image
+    # t0 = time.time()
+    nframes = 0
+    for im in images2:
+        bm = BitmapTag(im)
+        wh = (im.shape[1], im.shape[0])
+        sh = ShapeTag(bm.id, (0, 0), wh)
+        po = PlaceObjectTag(1, sh.id, move=nframes > 0)
+        taglist.extend([bm, sh, po])
+        for i in range(delays[nframes]):
+            taglist.append(ShowFrameTag())
+        nframes += 1
+
+    if not repeat:
+        taglist.append(DoActionTag("stop"))
+
+    # Build file
+    # t1 = time.time()
+    fp = open(filename, "wb")
+    try:
+        build_file(fp, taglist, nframes=nframes, framesize=wh, fps=fps)
+    except Exception:
+        raise
+    finally:
+        fp.close()
+    # t2 = time.time()
+
+    # logger.warning("Writing SWF took %1.2f and %1.2f seconds" % (t1-t0, t2-t1) )
+
+
+def read_swf(filename):  # pragma: no cover
+    """Read all images from an SWF (shockwave flash) file. Returns a list
+    of numpy arrays.
+
+    Limitation: only read the PNG encoded images (not the JPG encoded ones).
+    """
+
+    # Check whether it exists
+    if not os.path.isfile(filename):
+        raise IOError("File not found: " + str(filename))
+
+    # Init images
+    images = []
+
+    # Open file and read all
+    fp = open(filename, "rb")
+    bb = fp.read()
+
+    try:
+        # Check opening tag
+        tmp = bb[0:3].decode("ascii", "ignore")
+        if tmp.upper() == "FWS":
+            pass  # ok
+        elif tmp.upper() == "CWS":
+            # Decompress movie
+            bb = bb[:8] + zlib.decompress(bb[8:])
+        else:
+            raise IOError("Not a valid SWF file: " + str(filename))
+
+        # Set filepointer at first tag (skipping framesize RECT and two uin16's
+        i = 8
+        nbits = bits2int(bb[i : i + 1], 5)  # skip FrameSize
+        nbits = 5 + nbits * 4
+        Lrect = nbits / 8.0
+        if Lrect % 1:
+            Lrect += 1
+        Lrect = int(Lrect)
+        i += Lrect + 4
+
+        # Iterate over the tags
+        counter = 0
+        while True:
+            counter += 1
+
+            # Get tag header
+            head = bb[i : i + 6]
+            if not head:
+                break  # Done (we missed end tag)
+
+            # Determine type and length
+            T, L1, L2 = get_type_and_len(head)
+            if not L2:
+                logger.warning("Invalid tag length, could not proceed")
+                break
+            # logger.warning(T, L2)
+
+            # Read image if we can
+            if T in [20, 36]:
+                im = read_pixels(bb, i + 6, T, L1)
+                if im is not None:
+                    images.append(im)
+            elif T in [6, 21, 35, 90]:
+                logger.warning("Ignoring JPEG image: cannot read JPEG.")
+            else:
+                pass  # Not an image tag
+
+            # Detect end tag
+            if T == 0:
+                break
+
+            # Next tag!
+            i += L2
+
+    finally:
+        fp.close()
+
+    # Done
+    return images
+
+
+# Backward compatibility; same public names as when this was images2swf.
+writeSwf = write_swf
+readSwf = read_swf

parrot/lib/python3.10/site-packages/imageio/plugins/bsdf.py

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+""" Read/Write BSDF files.
+
+Backend Library: internal
+
+The BSDF format enables reading and writing of image data in the
+BSDF serialization format. This format allows storage of images, volumes,
+and series thereof. Data can be of any numeric data type, and can
+optionally be compressed. Each image/volume can have associated
+meta data, which can consist of any data type supported by BSDF.
+
+By default, image data is lazily loaded; the actual image data is
+not read until it is requested. This allows storing multiple images
+in a single file and still have fast access to individual images.
+Alternatively, a series of images can be read in streaming mode, reading
+images as they are read (e.g. from http).
+
+BSDF is a simple generic binary format. It is easy to extend and there
+are standard extension definitions for 2D and 3D image data.
+Read more at http://bsdf.io.
+
+
+Parameters
+----------
+random_access : bool
+    Whether individual images in the file can be read in random order.
+    Defaults to True for normal files, and to False when reading from HTTP.
+    If False, the file is read in "streaming mode", allowing reading
+    files as they are read, but without support for "rewinding".
+    Note that setting this to True when reading from HTTP, the whole file
+    is read upon opening it (since lazy loading is not possible over HTTP).
+
+compression : int
+    Use ``0`` or "no" for no compression, ``1`` or "zlib" for Zlib
+    compression (same as zip files and PNG), and ``2`` or "bz2" for Bz2
+    compression (more compact but slower). Default 1 (zlib).
+    Note that some BSDF implementations may not support compression
+    (e.g. JavaScript).
+
+"""
+
+import numpy as np
+
+from ..core import Format
+
+
+def get_bsdf_serializer(options):
+    from . import _bsdf as bsdf
+
+    class NDArrayExtension(bsdf.Extension):
+        """Copy of BSDF's NDArrayExtension but deal with lazy blobs."""
+
+        name = "ndarray"
+        cls = np.ndarray
+
+        def encode(self, s, v):
+            return dict(shape=v.shape, dtype=str(v.dtype), data=v.tobytes())
+
+        def decode(self, s, v):
+            return v  # return as dict, because of lazy blobs, decode in Image
+
+    class ImageExtension(bsdf.Extension):
+        """We implement two extensions that trigger on the Image classes."""
+
+        def encode(self, s, v):
+            return dict(array=v.array, meta=v.meta)
+
+        def decode(self, s, v):
+            return Image(v["array"], v["meta"])
+
+    class Image2DExtension(ImageExtension):
+        name = "image2d"
+        cls = Image2D
+
+    class Image3DExtension(ImageExtension):
+        name = "image3d"
+        cls = Image3D
+
+    exts = [NDArrayExtension, Image2DExtension, Image3DExtension]
+    serializer = bsdf.BsdfSerializer(exts, **options)
+
+    return bsdf, serializer
+
+
+class Image:
+    """Class in which we wrap the array and meta data. By using an extension
+    we can make BSDF trigger on these classes and thus encode the images.
+    as actual images.
+    """
+
+    def __init__(self, array, meta):
+        self.array = array
+        self.meta = meta
+
+    def get_array(self):
+        if not isinstance(self.array, np.ndarray):
+            v = self.array
+            blob = v["data"]
+            if not isinstance(blob, bytes):  # then it's a lazy bsdf.Blob
+                blob = blob.get_bytes()
+            self.array = np.frombuffer(blob, dtype=v["dtype"])
+            self.array.shape = v["shape"]
+        return self.array
+
+    def get_meta(self):
+        return self.meta
+
+
+class Image2D(Image):
+    pass
+
+
+class Image3D(Image):
+    pass
+
+
+class BsdfFormat(Format):
+    """The BSDF format enables reading and writing of image data in the
+    BSDF serialization format. This format allows storage of images, volumes,
+    and series thereof. Data can be of any numeric data type, and can
+    optionally be compressed. Each image/volume can have associated
+    meta data, which can consist of any data type supported by BSDF.
+
+    By default, image data is lazily loaded; the actual image data is
+    not read until it is requested. This allows storing multiple images
+    in a single file and still have fast access to individual images.
+    Alternatively, a series of images can be read in streaming mode, reading
+    images as they are read (e.g. from http).
+
+    BSDF is a simple generic binary format. It is easy to extend and there
+    are standard extension definitions for 2D and 3D image data.
+    Read more at http://bsdf.io.
+
+    Parameters for reading
+    ----------------------
+    random_access : bool
+        Whether individual images in the file can be read in random order.
+        Defaults to True for normal files, and to False when reading from HTTP.
+        If False, the file is read in "streaming mode", allowing reading
+        files as they are read, but without support for "rewinding".
+        Note that setting this to True when reading from HTTP, the whole file
+        is read upon opening it (since lazy loading is not possible over HTTP).
+
+    Parameters for saving
+    ---------------------
+    compression : {0, 1, 2}
+        Use ``0`` or "no" for no compression, ``1`` or "zlib" for Zlib
+        compression (same as zip files and PNG), and ``2`` or "bz2" for Bz2
+        compression (more compact but slower). Default 1 (zlib).
+        Note that some BSDF implementations may not support compression
+        (e.g. JavaScript).
+
+    """
+
+    def _can_read(self, request):
+        if request.mode[1] in (self.modes + "?"):
+            # if request.extension in self.extensions:
+            #     return True
+            if request.firstbytes.startswith(b"BSDF"):
+                return True
+
+    def _can_write(self, request):
+        if request.mode[1] in (self.modes + "?"):
+            if request.extension in self.extensions:
+                return True
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, random_access=None):
+            # Validate - we need a BSDF file consisting of a list of images
+            # The list is typically a stream, but does not have to be.
+            assert self.request.firstbytes[:4] == b"BSDF", "Not a BSDF file"
+            # self.request.firstbytes[5:6] == major and minor version
+            if not (
+                self.request.firstbytes[6:15] == b"M\x07image2D"
+                or self.request.firstbytes[6:15] == b"M\x07image3D"
+                or self.request.firstbytes[6:7] == b"l"
+            ):
+                pass  # Actually, follow a more duck-type approach ...
+                # raise RuntimeError('BSDF file does not look like an '
+                #                   'image container.')
+            # Set options. If we think that seeking is allowed, we lazily load
+            # blobs, and set streaming to False (i.e. the whole file is read,
+            # but we skip over binary blobs), so that we subsequently allow
+            # random access to the images.
+            # If seeking is not allowed (e.g. with a http request), we cannot
+            # lazily load blobs, but we can still load streaming from the web.
+            options = {}
+            if self.request.filename.startswith(("http://", "https://")):
+                ra = False if random_access is None else bool(random_access)
+                options["lazy_blob"] = False  # Because we cannot seek now
+                options["load_streaming"] = not ra  # Load as a stream?
+            else:
+                ra = True if random_access is None else bool(random_access)
+                options["lazy_blob"] = ra  # Don't read data until needed
+                options["load_streaming"] = not ra
+
+            file = self.request.get_file()
+            bsdf, self._serializer = get_bsdf_serializer(options)
+            self._stream = self._serializer.load(file)
+            # Another validation
+            if (
+                isinstance(self._stream, dict)
+                and "meta" in self._stream
+                and "array" in self._stream
+            ):
+                self._stream = Image(self._stream["array"], self._stream["meta"])
+            if not isinstance(self._stream, (Image, list, bsdf.ListStream)):
+                raise RuntimeError(
+                    "BSDF file does not look seem to have an " "image container."
+                )
+
+        def _close(self):
+            pass
+
+        def _get_length(self):
+            if isinstance(self._stream, Image):
+                return 1
+            elif isinstance(self._stream, list):
+                return len(self._stream)
+            elif self._stream.count < 0:
+                return np.inf
+            return self._stream.count
+
+        def _get_data(self, index):
+            # Validate
+            if index < 0 or index >= self.get_length():
+                raise IndexError(
+                    "Image index %i not in [0 %i]." % (index, self.get_length())
+                )
+            # Get Image object
+            if isinstance(self._stream, Image):
+                image_ob = self._stream  # singleton
+            elif isinstance(self._stream, list):
+                # Easy when we have random access
+                image_ob = self._stream[index]
+            else:
+                # For streaming, we need to skip over frames
+                if index < self._stream.index:
+                    raise IndexError(
+                        "BSDF file is being read in streaming "
+                        "mode, thus does not allow rewinding."
+                    )
+                while index > self._stream.index:
+                    self._stream.next()
+                image_ob = self._stream.next()  # Can raise StopIteration
+            # Is this an image?
+            if (
+                isinstance(image_ob, dict)
+                and "meta" in image_ob
+                and "array" in image_ob
+            ):
+                image_ob = Image(image_ob["array"], image_ob["meta"])
+            if isinstance(image_ob, Image):
+                # Return as array (if we have lazy blobs, they are read now)
+                return image_ob.get_array(), image_ob.get_meta()
+            else:
+                r = repr(image_ob)
+                r = r if len(r) < 200 else r[:197] + "..."
+                raise RuntimeError("BSDF file contains non-image " + r)
+
+        def _get_meta_data(self, index):  # pragma: no cover
+            return {}  # This format does not support global meta data
+
+    # -- writer
+
+    class Writer(Format.Writer):
+        def _open(self, compression=1):
+            options = {"compression": compression}
+            bsdf, self._serializer = get_bsdf_serializer(options)
+            if self.request.mode[1] in "iv":
+                self._stream = None  # Singleton image
+                self._written = False
+            else:
+                # Series (stream) of images
+                file = self.request.get_file()
+                self._stream = bsdf.ListStream()
+                self._serializer.save(file, self._stream)
+
+        def _close(self):
+            # We close the stream here, which will mark the number of written
+            # elements. If we would not close it, the file would be fine, it's
+            # just that upon reading it would not be known how many items are
+            # in there.
+            if self._stream is not None:
+                self._stream.close(False)  # False says "keep this a stream"
+
+        def _append_data(self, im, meta):
+            # Determine dimension
+            ndim = None
+            if self.request.mode[1] in "iI":
+                ndim = 2
+            elif self.request.mode[1] in "vV":
+                ndim = 3
+            else:
+                ndim = 3  # Make an educated guess
+                if im.ndim == 2 or (im.ndim == 3 and im.shape[-1] <= 4):
+                    ndim = 2
+            # Validate shape
+            assert ndim in (2, 3)
+            if ndim == 2:
+                assert im.ndim == 2 or (im.ndim == 3 and im.shape[-1] <= 4)
+            else:
+                assert im.ndim == 3 or (im.ndim == 4 and im.shape[-1] <= 4)
+            # Wrap data and meta data in our special class that will trigger
+            # the BSDF image2D or image3D extension.
+            if ndim == 2:
+                ob = Image2D(im, meta)
+            else:
+                ob = Image3D(im, meta)
+            # Write directly or to stream
+            if self._stream is None:
+                assert not self._written, "Cannot write singleton image twice"
+                self._written = True
+                file = self.request.get_file()
+                self._serializer.save(file, ob)
+            else:
+                self._stream.append(ob)
+
+        def set_meta_data(self, meta):  # pragma: no cover
+            raise RuntimeError("The BSDF format only supports " "per-image meta data.")

parrot/lib/python3.10/site-packages/imageio/plugins/dicom.py

@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read DICOM files.
+
+Backend Library: internal
+
+A format for reading DICOM images: a common format used to store
+medical image data, such as X-ray, CT and MRI.
+
+This format borrows some code (and ideas) from the pydicom project. However,
+only a predefined subset of tags are extracted from the file. This allows
+for great simplifications allowing us to make a stand-alone reader, and
+also results in a much faster read time.
+
+By default, only uncompressed and deflated transfer syntaxes are supported.
+If gdcm or dcmtk is installed, these will be used to automatically convert
+the data. See https://github.com/malaterre/GDCM/releases for installing GDCM.
+
+This format provides functionality to group images of the same
+series together, thus extracting volumes (and multiple volumes).
+Using volread will attempt to yield a volume. If multiple volumes
+are present, the first one is given. Using mimread will simply yield
+all images in the given directory (not taking series into account).
+
+Parameters
+----------
+progress : {True, False, BaseProgressIndicator}
+    Whether to show progress when reading from multiple files.
+    Default True. By passing an object that inherits from
+    BaseProgressIndicator, the way in which progress is reported
+    can be costumized.
+
+"""
+
+# 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 os
+import sys
+import logging
+import subprocess
+
+from ..core import Format, BaseProgressIndicator, StdoutProgressIndicator
+from ..core import read_n_bytes
+
+_dicom = None  # lazily loaded in load_lib()
+
+logger = logging.getLogger(__name__)
+
+
+def load_lib():
+    global _dicom
+    from . import _dicom
+
+    return _dicom
+
+
+# Determine endianity of system
+sys_is_little_endian = sys.byteorder == "little"
+
+
+def get_dcmdjpeg_exe():
+    fname = "dcmdjpeg" + ".exe" * sys.platform.startswith("win")
+    for dir in (
+        "c:\\dcmtk",
+        "c:\\Program Files",
+        "c:\\Program Files\\dcmtk",
+        "c:\\Program Files (x86)\\dcmtk",
+    ):
+        filename = os.path.join(dir, fname)
+        if os.path.isfile(filename):
+            return [filename]
+
+    try:
+        subprocess.check_call([fname, "--version"])
+        return [fname]
+    except Exception:
+        return None
+
+
+def get_gdcmconv_exe():
+    fname = "gdcmconv" + ".exe" * sys.platform.startswith("win")
+    # Maybe it's on the path
+    try:
+        subprocess.check_call([fname, "--version"])
+        return [fname, "--raw"]
+    except Exception:
+        pass
+    # Select directories where it could be
+    candidates = []
+    base_dirs = [r"c:\Program Files"]
+    for base_dir in base_dirs:
+        if os.path.isdir(base_dir):
+            for dname in os.listdir(base_dir):
+                if dname.lower().startswith("gdcm"):
+                    suffix = dname[4:].strip()
+                    candidates.append((suffix, os.path.join(base_dir, dname)))
+    # Sort, so higher versions are tried earlier
+    candidates.sort(reverse=True)
+    # Select executable
+    filename = None
+    for _, dirname in candidates:
+        exe1 = os.path.join(dirname, "gdcmconv.exe")
+        exe2 = os.path.join(dirname, "bin", "gdcmconv.exe")
+        if os.path.isfile(exe1):
+            filename = exe1
+            break
+        if os.path.isfile(exe2):
+            filename = exe2
+            break
+    else:
+        return None
+    return [filename, "--raw"]
+
+
+class DicomFormat(Format):
+    """See :mod:`imageio.plugins.dicom`"""
+
+    def _can_read(self, request):
+        # If user URI was a directory, we check whether it has a DICOM file
+        if os.path.isdir(request.filename):
+            files = os.listdir(request.filename)
+            for fname in sorted(files):  # Sorting make it consistent
+                filename = os.path.join(request.filename, fname)
+                if os.path.isfile(filename) and "DICOMDIR" not in fname:
+                    with open(filename, "rb") as f:
+                        first_bytes = read_n_bytes(f, 140)
+                    return first_bytes[128:132] == b"DICM"
+            else:
+                return False
+        # Check
+        return request.firstbytes[128:132] == b"DICM"
+
+    def _can_write(self, request):
+        # We cannot save yet. May be possible if we will used pydicom as
+        # a backend.
+        return False
+
+    # --
+
+    class Reader(Format.Reader):
+        _compressed_warning_dirs = set()
+
+        def _open(self, progress=True):
+            if not _dicom:
+                load_lib()
+            if os.path.isdir(self.request.filename):
+                # A dir can be given if the user used the format explicitly
+                self._info = {}
+                self._data = None
+            else:
+                # Read the given dataset now ...
+                try:
+                    dcm = _dicom.SimpleDicomReader(self.request.get_file())
+                except _dicom.CompressedDicom as err:
+                    # We cannot do this on our own. Perhaps with some help ...
+                    cmd = get_gdcmconv_exe()
+                    if not cmd and "JPEG" in str(err):
+                        cmd = get_dcmdjpeg_exe()
+                    if not cmd:
+                        msg = err.args[0].replace("using", "installing")
+                        msg = msg.replace("convert", "auto-convert")
+                        err.args = (msg,)
+                        raise
+                    else:
+                        fname1 = self.request.get_local_filename()
+                        fname2 = fname1 + ".raw"
+                        try:
+                            subprocess.check_call(cmd + [fname1, fname2])
+                        except Exception:
+                            raise err
+                        d = os.path.dirname(fname1)
+                        if d not in self._compressed_warning_dirs:
+                            self._compressed_warning_dirs.add(d)
+                            logger.warning(
+                                "DICOM file contained compressed data. "
+                                + "Autoconverting with "
+                                + cmd[0]
+                                + " (this warning is shown once for each directory)"
+                            )
+                        dcm = _dicom.SimpleDicomReader(fname2)
+
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            # Initialize series, list of DicomSeries objects
+            self._series = None  # only created if needed
+
+            # Set progress indicator
+            if isinstance(progress, BaseProgressIndicator):
+                self._progressIndicator = progress
+            elif progress is True:
+                p = StdoutProgressIndicator("Reading DICOM")
+                self._progressIndicator = p
+            elif progress in (None, False):
+                self._progressIndicator = BaseProgressIndicator("Dummy")
+            else:
+                raise ValueError("Invalid value for progress.")
+
+        def _close(self):
+            # Clean up
+            self._info = None
+            self._data = None
+            self._series = None
+
+        @property
+        def series(self):
+            if self._series is None:
+                pi = self._progressIndicator
+                self._series = _dicom.process_directory(self.request, pi)
+            return self._series
+
+        def _get_length(self):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            if self.request.mode[1] == "i":
+                # User expects one, but lets be honest about this file
+                return nslices
+            elif self.request.mode[1] == "I":
+                # User expects multiple, if this file has multiple slices, ok.
+                # Otherwise we have to check the series.
+                if nslices > 1:
+                    return nslices
+                else:
+                    return sum([len(serie) for serie in self.series])
+            elif self.request.mode[1] == "v":
+                # User expects a volume, if this file has one, ok.
+                # Otherwise we have to check the series
+                if nslices > 1:
+                    return 1
+                else:
+                    return len(self.series)  # We assume one volume per series
+            elif self.request.mode[1] == "V":
+                # User expects multiple volumes. We have to check the series
+                return len(self.series)  # We assume one volume per series
+            else:
+                raise RuntimeError("DICOM plugin should know what to expect.")
+
+        def _get_slice_data(self, index):
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            # Allow index >1 only if this file contains >1
+            if nslices > 1:
+                return self._data[index], self._info
+            elif index == 0:
+                return self._data, self._info
+            else:
+                raise IndexError("Dicom file contains only one slice.")
+
+        def _get_data(self, index):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            if self.request.mode[1] == "i":
+                return self._get_slice_data(index)
+            elif self.request.mode[1] == "I":
+                # Return slice from volume, or return item from series
+                if index == 0 and nslices > 1:
+                    return self._data[index], self._info
+                else:
+                    L = []
+                    for serie in self.series:
+                        L.extend([dcm_ for dcm_ in serie])
+                    return L[index].get_numpy_array(), L[index].info
+            elif self.request.mode[1] in "vV":
+                # Return volume or series
+                if index == 0 and nslices > 1:
+                    return self._data, self._info
+                else:
+                    return (
+                        self.series[index].get_numpy_array(),
+                        self.series[index].info,
+                    )
+            # mode is `?` (typically because we are using V3). If there is a
+            # series (multiple files), index referrs to the element of the
+            # series and we read volumes. If there is no series, index
+            # referrs to the slice in the volume we read "flat" images.
+            elif len(self.series) > 1:
+                # mode is `?` and there are multiple series. Each series is a ndimage.
+                return (
+                    self.series[index].get_numpy_array(),
+                    self.series[index].info,
+                )
+            else:
+                # mode is `?` and there is only one series. Each slice is an ndimage.
+                return self._get_slice_data(index)
+
+        def _get_meta_data(self, index):
+            if self._data is None:
+                dcm = self.series[0][0]
+                self._info = dcm._info
+                self._data = dcm.get_numpy_array()
+
+            nslices = self._data.shape[0] if (self._data.ndim == 3) else 1
+
+            # Default is the meta data of the given file, or the "first" file.
+            if index is None:
+                return self._info
+
+            if self.request.mode[1] == "i":
+                return self._info
+            elif self.request.mode[1] == "I":
+                # Return slice from volume, or return item from series
+                if index == 0 and nslices > 1:
+                    return self._info
+                else:
+                    L = []
+                    for serie in self.series:
+                        L.extend([dcm_ for dcm_ in serie])
+                    return L[index].info
+            elif self.request.mode[1] in "vV":
+                # Return volume or series
+                if index == 0 and nslices > 1:
+                    return self._info
+                else:
+                    return self.series[index].info
+            else:  # pragma: no cover
+                raise ValueError("DICOM plugin should know what to expect.")

parrot/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)

parrot/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

parrot/lib/python3.10/site-packages/imageio/plugins/ffmpeg.py

@@ -0,0 +1,729 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read/Write video using FFMPEG
+
+.. note::
+    We are in the process of (slowly) replacing this plugin with a new one that
+    is based on `pyav <https://pyav.org/docs/stable/>`_. It is faster and more
+    flexible than the plugin documented here. Check the :mod:`pyav
+    plugin's documentation <imageio.plugins.pyav>` for more information about
+    this plugin.
+
+Backend Library: https://github.com/imageio/imageio-ffmpeg
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[ffmpeg]
+
+
+The ffmpeg format provides reading and writing for a wide range of movie formats
+such as .avi, .mpeg, .mp4, etc. as well as the ability to read streams from
+webcams and USB cameras. It is based on ffmpeg and is inspired by/based `moviepy
+<https://github.com/Zulko/moviepy/>`_ by Zulko.
+
+Parameters for reading
+----------------------
+fps : scalar
+    The number of frames per second of the input stream. Default None (i.e.
+    read at the file's native fps). One can use this for files with a
+    variable fps, or in cases where imageio is unable to correctly detect
+    the fps. In case of trouble opening camera streams, it may help to set an
+    explicit fps value matching a framerate supported by the camera.
+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.
+    Setting this to True will internally call ``count_frames()``,
+    and set the reader's length to that value instead of inf.
+size : str | tuple
+    The frame size (i.e. resolution) to read the images, e.g.
+    (100, 100) or "640x480". For camera streams, this allows setting
+    the capture resolution. For normal video data, ffmpeg will
+    rescale the data.
+dtype : str | type
+    The dtype for the output arrays. Determines the bit-depth that
+    is requested from ffmpeg. Supported dtypes: uint8, uint16.
+    Default: uint8.
+pixelformat : str
+    The pixel format for the camera to use (e.g. "yuyv422" or
+    "gray"). The camera needs to support the format in order for
+    this to take effect. Note that the images produced by this
+    reader are always RGB.
+input_params : list
+    List additional arguments to ffmpeg for input file options.
+    (Can also be provided as ``ffmpeg_params`` for backwards compatibility)
+    Example ffmpeg arguments to use aggressive error handling:
+    ['-err_detect', 'aggressive']
+output_params : list
+    List additional arguments to ffmpeg for output file options (i.e. the
+    stream being read by imageio).
+print_info : bool
+    Print information about the video file as reported by ffmpeg.
+
+Parameters for writing
+----------------------
+fps : scalar
+    The number of frames per second. Default 10.
+codec : str
+    the video codec to use. Default 'libx264', which represents the
+    widely available mpeg4. Except when saving .wmv files, then the
+    defaults is 'msmpeg4' which is more commonly supported for windows
+quality : float | None
+    Video output quality. Default is 5. Uses variable bit rate. Highest
+    quality is 10, lowest is 0. Set to None to prevent variable bitrate
+    flags to FFMPEG so you can manually specify them using output_params
+    instead. Specifying a fixed bitrate using 'bitrate' disables this
+    parameter.
+bitrate : int | None
+    Set a constant bitrate for the video encoding. Default is None causing
+    'quality' parameter to be used instead.  Better quality videos with
+    smaller file sizes will result from using the 'quality'  variable
+    bitrate parameter rather than specifying a fixed bitrate with this
+    parameter.
+pixelformat: str
+    The output video pixel format. Default is 'yuv420p' which most widely
+    supported by video players.
+input_params : list
+    List additional arguments to ffmpeg for input file options (i.e. the
+    stream that imageio provides).
+output_params : list
+    List additional arguments to ffmpeg for output file options.
+    (Can also be provided as ``ffmpeg_params`` for backwards compatibility)
+    Example ffmpeg arguments to use only intra frames and set aspect ratio:
+    ['-intra', '-aspect', '16:9']
+ffmpeg_log_level: str
+    Sets ffmpeg output log level.  Default is "warning".
+    Values can be "quiet", "panic", "fatal", "error", "warning", "info"
+    "verbose", or "debug". Also prints the FFMPEG command being used by
+    imageio if "info", "verbose", or "debug".
+macro_block_size: int
+    Size constraint for video. Width and height, must be divisible by this
+    number. If not divisible by this number imageio will tell ffmpeg to
+    scale the image up to the next closest size
+    divisible by this number. Most codecs are compatible with a macroblock
+    size of 16 (default), some can go smaller (4, 8). To disable this
+    automatic feature set it to None or 1, however be warned many players
+    can't decode videos that are odd in size and some codecs will produce
+    poor results or fail. See https://en.wikipedia.org/wiki/Macroblock.
+audio_path : str | None
+    Audio path of any audio that needs to be written. Defaults to nothing,
+    so no audio will be written. Please note, when writing shorter video
+    than the original, ffmpeg will not truncate the audio track; it
+    will maintain its original length and be longer than the video.
+audio_codec : str | None
+    The audio codec to use. Defaults to nothing, but if an audio_path has
+    been provided ffmpeg will attempt to set a default codec.
+
+Notes
+-----
+If you are using anaconda and ``anaconda/ffmpeg`` you will not be able to
+encode/decode H.264 (likely due to licensing concerns). If you need this
+format on anaconda install ``conda-forge/ffmpeg`` instead.
+
+You can use the ``IMAGEIO_FFMPEG_EXE`` environment variable to force using a
+specific ffmpeg executable.
+
+To get the number of frames before having read them all, you can use the
+``reader.count_frames()`` method (the reader will then use
+``imageio_ffmpeg.count_frames_and_secs()`` to get the exact number of frames,
+note that this operation can take a few seconds on large files). Alternatively,
+the number of frames can be estimated from the fps and duration in the meta data
+(though these values themselves are not always present/reliable).
+
+"""
+
+import re
+import sys
+import time
+import logging
+import platform
+import threading
+import subprocess as sp
+import imageio_ffmpeg
+
+import numpy as np
+
+from ..core import Format, image_as_uint
+
+logger = logging.getLogger(__name__)
+
+# Get camera format
+if sys.platform.startswith("win"):
+    CAM_FORMAT = "dshow"  # dshow or vfwcap
+elif sys.platform.startswith("linux"):
+    CAM_FORMAT = "video4linux2"
+elif sys.platform.startswith("darwin"):
+    CAM_FORMAT = "avfoundation"
+else:  # pragma: no cover
+    CAM_FORMAT = "unknown-cam-format"
+
+
+def download(directory=None, force_download=False):  # pragma: no cover
+    raise RuntimeError(
+        "imageio.ffmpeg.download() has been deprecated. "
+        "Use 'pip install imageio-ffmpeg' instead.'"
+    )
+
+
+# For backwards compatibility - we dont use this ourselves
+def get_exe():  # pragma: no cover
+    """Wrapper for imageio_ffmpeg.get_ffmpeg_exe()"""
+
+    return imageio_ffmpeg.get_ffmpeg_exe()
+
+
+class FfmpegFormat(Format):
+    """Read/Write ImageResources using FFMPEG.
+
+    See :mod:`imageio.plugins.ffmpeg`
+    """
+
+    def _can_read(self, request):
+        # Read from video stream?
+        # Note that we could write the _video flag here, but a user might
+        # select this format explicitly (and this code is not run)
+        if re.match(r"<video(\d+)>", request.filename):
+            return True
+
+        # Read from file that we know?
+        if request.extension in self.extensions:
+            return True
+
+    def _can_write(self, request):
+        if request.extension in self.extensions:
+            return True
+
+    # --
+
+    class Reader(Format.Reader):
+        _frame_catcher = None
+        _read_gen = None
+
+        def _get_cam_inputname(self, index):
+            if sys.platform.startswith("linux"):
+                return "/dev/" + self.request._video[1:-1]
+
+            elif sys.platform.startswith("win"):
+                # Ask ffmpeg for list of dshow device names
+                ffmpeg_api = imageio_ffmpeg
+                cmd = [
+                    ffmpeg_api.get_ffmpeg_exe(),
+                    "-list_devices",
+                    "true",
+                    "-f",
+                    CAM_FORMAT,
+                    "-i",
+                    "dummy",
+                ]
+                # Set `shell=True` in sp.run to prevent popup of a command
+                # line window in frozen applications. Note: this would be a
+                # security vulnerability if user-input goes into the cmd.
+                # Note that the ffmpeg process returns with exit code 1 when
+                # using `-list_devices` (or `-list_options`), even if the
+                # command is successful, so we set `check=False` explicitly.
+                completed_process = sp.run(
+                    cmd,
+                    stdout=sp.PIPE,
+                    stderr=sp.PIPE,
+                    encoding="utf-8",
+                    shell=True,
+                    check=False,
+                )
+
+                # Return device name at index
+                try:
+                    name = parse_device_names(completed_process.stderr)[index]
+                except IndexError:
+                    raise IndexError("No ffdshow camera at index %i." % index)
+                return "video=%s" % name
+
+            elif sys.platform.startswith("darwin"):
+                # Appears that newer ffmpeg builds don't support -list-devices
+                # on OS X. But you can directly open the camera by index.
+                name = str(index)
+                return name
+
+            else:  # pragma: no cover
+                return "??"
+
+        def _open(
+            self,
+            loop=False,
+            size=None,
+            dtype=None,
+            pixelformat=None,
+            print_info=False,
+            ffmpeg_params=None,
+            input_params=None,
+            output_params=None,
+            fps=None,
+        ):
+            # Get generator functions
+            self._ffmpeg_api = imageio_ffmpeg
+            # Process input args
+            self._arg_loop = bool(loop)
+            if size is None:
+                self._arg_size = None
+            elif isinstance(size, tuple):
+                self._arg_size = "%ix%i" % size
+            elif isinstance(size, str) and "x" in size:
+                self._arg_size = size
+            else:
+                raise ValueError('FFMPEG size must be tuple of "NxM"')
+            if pixelformat is None:
+                pass
+            elif not isinstance(pixelformat, str):
+                raise ValueError("FFMPEG pixelformat must be str")
+            if dtype is None:
+                self._dtype = np.dtype("uint8")
+            else:
+                self._dtype = np.dtype(dtype)
+                allowed_dtypes = ["uint8", "uint16"]
+                if self._dtype.name not in allowed_dtypes:
+                    raise ValueError(
+                        "dtype must be one of: {}".format(", ".join(allowed_dtypes))
+                    )
+            self._arg_pixelformat = pixelformat
+            self._arg_input_params = input_params or []
+            self._arg_output_params = output_params or []
+            self._arg_input_params += ffmpeg_params or []  # backward compat
+            # Write "_video"_arg - indicating webcam support
+            self.request._video = None
+            regex_match = re.match(r"<video(\d+)>", self.request.filename)
+            if regex_match:
+                self.request._video = self.request.filename
+            # Get local filename
+            if self.request._video:
+                index = int(regex_match.group(1))
+                self._filename = self._get_cam_inputname(index)
+            else:
+                self._filename = self.request.get_local_filename()
+                # When passed to ffmpeg on command line, carets need to be escaped.
+                self._filename = self._filename.replace("^", "^^")
+            # Determine pixel format and depth
+            self._depth = 3
+            if self._dtype.name == "uint8":
+                self._pix_fmt = "rgb24"
+                self._bytes_per_channel = 1
+            else:
+                self._pix_fmt = "rgb48le"
+                self._bytes_per_channel = 2
+            # Initialize parameters
+            self._pos = -1
+            self._meta = {"plugin": "ffmpeg"}
+            self._lastread = None
+
+            # Calculating this from fps and duration is not accurate,
+            # and calculating it exactly with ffmpeg_api.count_frames_and_secs
+            # takes too long to do for each video. But we need it for looping.
+            self._nframes = float("inf")
+            if self._arg_loop and not self.request._video:
+                self._nframes = self.count_frames()
+            self._meta["nframes"] = self._nframes
+
+            # Specify input framerate? (only on macOS)
+            # Ideally we'd get the supported framerate from the metadata, but we get the
+            # metadata when we boot ffmpeg ... maybe we could refactor this so we can
+            # get the metadata beforehand, but for now we'll just give it 2 tries on MacOS,
+            # one with fps 30 and one with fps 15.
+            need_input_fps = need_output_fps = False
+            if self.request._video and platform.system().lower() == "darwin":
+                if "-framerate" not in str(self._arg_input_params):
+                    need_input_fps = True
+                if not self.request.kwargs.get("fps", None):
+                    need_output_fps = True
+            if need_input_fps:
+                self._arg_input_params.extend(["-framerate", str(float(30))])
+            if need_output_fps:
+                self._arg_output_params.extend(["-r", str(float(30))])
+
+            # Start ffmpeg subprocess and get meta information
+            try:
+                self._initialize()
+            except IndexError:
+                # Specify input framerate again, this time different.
+                if need_input_fps:
+                    self._arg_input_params[-1] = str(float(15))
+                    self._initialize()
+                else:
+                    raise
+
+            # For cameras, create thread that keeps reading the images
+            if self.request._video:
+                self._frame_catcher = FrameCatcher(self._read_gen)
+
+            # For reference - but disabled, because it is inaccurate
+            # if self._meta["nframes"] == float("inf"):
+            #     if self._meta.get("fps", 0) > 0:
+            #         if self._meta.get("duration", 0) > 0:
+            #             n = round(self._meta["duration"] * self._meta["fps"])
+            #             self._meta["nframes"] = int(n)
+
+        def _close(self):
+            # First close the frame catcher, because we cannot close the gen
+            # if the frame catcher thread is using it
+            if self._frame_catcher is not None:
+                self._frame_catcher.stop_me()
+                self._frame_catcher = None
+            if self._read_gen is not None:
+                self._read_gen.close()
+                self._read_gen = None
+
+        def count_frames(self):
+            """Count the number of frames. Note that this can take a few
+            seconds for large files. Also note that it counts the number
+            of frames in the original video and does not take a given fps
+            into account.
+            """
+            # This would have been nice, but this does not work :(
+            # oargs = []
+            # if self.request.kwargs.get("fps", None):
+            #     fps = float(self.request.kwargs["fps"])
+            #     oargs += ["-r", "%.02f" % fps]
+            cf = self._ffmpeg_api.count_frames_and_secs
+            return cf(self._filename)[0]
+
+        def _get_length(self):
+            return self._nframes  # only not inf if loop is True
+
+        def _get_data(self, index):
+            """Reads a frame at index. Note for coders: getting an
+            arbitrary frame in the video with ffmpeg can be painfully
+            slow if some decoding has to be done. This function tries
+            to avoid fectching arbitrary frames whenever possible, by
+            moving between adjacent frames."""
+            # Modulo index (for looping)
+            if self._arg_loop and self._nframes < float("inf"):
+                index %= self._nframes
+
+            if index == self._pos:
+                return self._lastread, dict(new=False)
+            elif index < 0:
+                raise IndexError("Frame index must be >= 0")
+            elif index >= self._nframes:
+                raise IndexError("Reached end of video")
+            else:
+                if (index < self._pos) or (index > self._pos + 100):
+                    self._initialize(index)
+                else:
+                    self._skip_frames(index - self._pos - 1)
+                result, is_new = self._read_frame()
+                self._pos = index
+                return result, dict(new=is_new)
+
+        def _get_meta_data(self, index):
+            return self._meta
+
+        def _initialize(self, index=0):
+            # Close the current generator, and thereby terminate its subprocess
+            if self._read_gen is not None:
+                self._read_gen.close()
+
+            iargs = []
+            oargs = []
+
+            # Create input args
+            iargs += self._arg_input_params
+            if self.request._video:
+                iargs += ["-f", CAM_FORMAT]
+                if self._arg_pixelformat:
+                    iargs += ["-pix_fmt", self._arg_pixelformat]
+                if self._arg_size:
+                    iargs += ["-s", self._arg_size]
+            elif index > 0:  # re-initialize  / seek
+                # Note: only works if we initialized earlier, and now have meta
+                # Some info here: https://trac.ffmpeg.org/wiki/Seeking
+                # There are two ways to seek, one before -i (input_params) and
+                # after (output_params). The former is fast, because it uses
+                # keyframes, the latter is slow but accurate. According to
+                # the article above, the fast method should also be accurate
+                # from ffmpeg version 2.1, however in version 4.1 our tests
+                # start failing again. Not sure why, but we can solve this
+                # by combining slow and fast. Seek the long stretch using
+                # the fast method, and seek the last 10s the slow way.
+                starttime = index / self._meta["fps"]
+                seek_slow = min(10, starttime)
+                seek_fast = starttime - seek_slow
+                # We used to have this epsilon earlier, when we did not use
+                # the slow seek. I don't think we need it anymore.
+                # epsilon = -1 / self._meta["fps"] * 0.1
+                iargs += ["-ss", "%.06f" % (seek_fast)]
+                oargs += ["-ss", "%.06f" % (seek_slow)]
+
+            # Output args, for writing to pipe
+            if self._arg_size:
+                oargs += ["-s", self._arg_size]
+            if self.request.kwargs.get("fps", None):
+                fps = float(self.request.kwargs["fps"])
+                oargs += ["-r", "%.02f" % fps]
+            oargs += self._arg_output_params
+
+            # Get pixelformat and bytes per pixel
+            pix_fmt = self._pix_fmt
+            bpp = self._depth * self._bytes_per_channel
+
+            # Create generator
+            rf = self._ffmpeg_api.read_frames
+            self._read_gen = rf(
+                self._filename, pix_fmt, bpp, input_params=iargs, output_params=oargs
+            )
+
+            # Read meta data. This start the generator (and ffmpeg subprocess)
+            if self.request._video:
+                # With cameras, catch error and turn into IndexError
+                try:
+                    meta = self._read_gen.__next__()
+                except IOError as err:
+                    err_text = str(err)
+                    if "darwin" in sys.platform:
+                        if "Unknown input format: 'avfoundation'" in err_text:
+                            err_text += (
+                                "Try installing FFMPEG using "
+                                "home brew to get a version with "
+                                "support for cameras."
+                            )
+                    raise IndexError(
+                        "No (working) camera at {}.\n\n{}".format(
+                            self.request._video, err_text
+                        )
+                    )
+                else:
+                    self._meta.update(meta)
+            elif index == 0:
+                self._meta.update(self._read_gen.__next__())
+            else:
+                self._read_gen.__next__()  # we already have meta data
+
+        def _skip_frames(self, n=1):
+            """Reads and throws away n frames"""
+            for i in range(n):
+                self._read_gen.__next__()
+            self._pos += n
+
+        def _read_frame(self):
+            # Read and convert to numpy array
+            w, h = self._meta["size"]
+            framesize = w * h * self._depth * self._bytes_per_channel
+            # t0 = time.time()
+
+            # Read frame
+            if self._frame_catcher:  # pragma: no cover - camera thing
+                s, is_new = self._frame_catcher.get_frame()
+            else:
+                s = self._read_gen.__next__()
+                is_new = True
+
+            # Check
+            if len(s) != framesize:
+                raise RuntimeError(
+                    "Frame is %i bytes, but expected %i." % (len(s), framesize)
+                )
+
+            result = np.frombuffer(s, dtype=self._dtype).copy()
+            result = result.reshape((h, w, self._depth))
+            # t1 = time.time()
+            # print('etime', t1-t0)
+
+            # Store and return
+            self._lastread = result
+            return result, is_new
+
+    # --
+
+    class Writer(Format.Writer):
+        _write_gen = None
+
+        def _open(
+            self,
+            fps=10,
+            codec="libx264",
+            bitrate=None,
+            pixelformat="yuv420p",
+            ffmpeg_params=None,
+            input_params=None,
+            output_params=None,
+            ffmpeg_log_level="quiet",
+            quality=5,
+            macro_block_size=16,
+            audio_path=None,
+            audio_codec=None,
+        ):
+            self._ffmpeg_api = imageio_ffmpeg
+            self._filename = self.request.get_local_filename()
+            self._pix_fmt = None
+            self._depth = None
+            self._size = None
+
+        def _close(self):
+            if self._write_gen is not None:
+                self._write_gen.close()
+                self._write_gen = None
+
+        def _append_data(self, im, meta):
+            # Get props of image
+            h, w = im.shape[:2]
+            size = w, h
+            depth = 1 if im.ndim == 2 else im.shape[2]
+
+            # Ensure that image is in uint8
+            im = image_as_uint(im, bitdepth=8)
+            # To be written efficiently, ie. without creating an immutable
+            # buffer, by calling im.tobytes() the array must be contiguous.
+            if not im.flags.c_contiguous:
+                # checkign the flag is a micro optimization.
+                # the image will be a numpy subclass. See discussion
+                # https://github.com/numpy/numpy/issues/11804
+                im = np.ascontiguousarray(im)
+
+            # Set size and initialize if not initialized yet
+            if self._size is None:
+                map = {1: "gray", 2: "gray8a", 3: "rgb24", 4: "rgba"}
+                self._pix_fmt = map.get(depth, None)
+                if self._pix_fmt is None:
+                    raise ValueError("Image must have 1, 2, 3 or 4 channels")
+                self._size = size
+                self._depth = depth
+                self._initialize()
+
+            # Check size of image
+            if size != self._size:
+                raise ValueError("All images in a movie should have same size")
+            if depth != self._depth:
+                raise ValueError(
+                    "All images in a movie should have same " "number of channels"
+                )
+
+            assert self._write_gen is not None  # Check status
+
+            # Write. Yes, we can send the data in as a numpy array
+            self._write_gen.send(im)
+
+        def set_meta_data(self, meta):
+            raise RuntimeError(
+                "The ffmpeg format does not support setting " "meta data."
+            )
+
+        def _initialize(self):
+            # Close existing generator
+            if self._write_gen is not None:
+                self._write_gen.close()
+
+            # Get parameters
+            # Use None to let imageio-ffmpeg (or ffmpeg) select good results
+            fps = self.request.kwargs.get("fps", 10)
+            codec = self.request.kwargs.get("codec", None)
+            bitrate = self.request.kwargs.get("bitrate", None)
+            quality = self.request.kwargs.get("quality", None)
+            input_params = self.request.kwargs.get("input_params") or []
+            output_params = self.request.kwargs.get("output_params") or []
+            output_params += self.request.kwargs.get("ffmpeg_params") or []
+            pixelformat = self.request.kwargs.get("pixelformat", None)
+            macro_block_size = self.request.kwargs.get("macro_block_size", 16)
+            ffmpeg_log_level = self.request.kwargs.get("ffmpeg_log_level", None)
+            audio_path = self.request.kwargs.get("audio_path", None)
+            audio_codec = self.request.kwargs.get("audio_codec", None)
+
+            macro_block_size = macro_block_size or 1  # None -> 1
+
+            # Create generator
+            self._write_gen = self._ffmpeg_api.write_frames(
+                self._filename,
+                self._size,
+                pix_fmt_in=self._pix_fmt,
+                pix_fmt_out=pixelformat,
+                fps=fps,
+                quality=quality,
+                bitrate=bitrate,
+                codec=codec,
+                macro_block_size=macro_block_size,
+                ffmpeg_log_level=ffmpeg_log_level,
+                input_params=input_params,
+                output_params=output_params,
+                audio_path=audio_path,
+                audio_codec=audio_codec,
+            )
+
+            # Seed the generator (this is where the ffmpeg subprocess starts)
+            self._write_gen.send(None)
+
+
+class FrameCatcher(threading.Thread):
+    """Thread to keep reading the frame data from stdout. This is
+    useful when streaming from a webcam. Otherwise, if the user code
+    does not grab frames fast enough, the buffer will fill up, leading
+    to lag, and ffmpeg can also stall (experienced on Linux). The
+    get_frame() method always returns the last available image.
+    """
+
+    def __init__(self, gen):
+        self._gen = gen
+        self._frame = None
+        self._frame_is_new = False
+        self._lock = threading.RLock()
+        threading.Thread.__init__(self)
+        self.daemon = True  # do not let this thread hold up Python shutdown
+        self._should_stop = False
+        self.start()
+
+    def stop_me(self):
+        self._should_stop = True
+        while self.is_alive():
+            time.sleep(0.001)
+
+    def get_frame(self):
+        while self._frame is None:  # pragma: no cover - an init thing
+            time.sleep(0.001)
+        with self._lock:
+            is_new = self._frame_is_new
+            self._frame_is_new = False  # reset
+            return self._frame, is_new
+
+    def run(self):
+        # This runs in the worker thread
+        try:
+            while not self._should_stop:
+                time.sleep(0)  # give control to other threads
+                frame = self._gen.__next__()
+                with self._lock:
+                    self._frame = frame
+                    self._frame_is_new = True
+        except (StopIteration, EOFError):
+            pass
+
+
+def parse_device_names(ffmpeg_output):
+    """Parse the output of the ffmpeg -list-devices command"""
+    # Collect device names - get [friendly_name, alt_name] of each
+    device_names = []
+    in_video_devices = False
+    for line in ffmpeg_output.splitlines():
+        if line.startswith("[dshow"):
+            logger.debug(line)
+            line = line.split("]", 1)[1].strip()
+            if in_video_devices and line.startswith('"'):
+                friendly_name = line[1:-1]
+                device_names.append([friendly_name, ""])
+            elif in_video_devices and line.lower().startswith("alternative name"):
+                alt_name = line.split(" name ", 1)[1].strip()[1:-1]
+                if sys.platform.startswith("win"):
+                    alt_name = alt_name.replace("&", "^&")  # Tested to work
+                else:
+                    alt_name = alt_name.replace("&", "\\&")  # Does this work?
+                device_names[-1][-1] = alt_name
+            elif "video devices" in line:
+                in_video_devices = True
+            elif "devices" in line:
+                # set False for subsequent "devices" sections
+                in_video_devices = False
+    # Post-process, see #441
+    # prefer friendly names, use alt name if two cams have same friendly name
+    device_names2 = []
+    for friendly_name, alt_name in device_names:
+        if friendly_name not in device_names2:
+            device_names2.append(friendly_name)
+        elif alt_name:
+            device_names2.append(alt_name)
+        else:
+            device_names2.append(friendly_name)  # duplicate, but not much we can do
+    return device_names2