Add files using upload-large-folder tool

evalkit_tf446/lib/python3.10/site-packages/gradio-5.1.0.dist-info/INSTALLER

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

evalkit_tf446/lib/python3.10/site-packages/gradio-5.1.0.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.3
+Name: gradio
+Version: 5.1.0
+Summary: Python library for easily interacting with trained machine learning models
+Project-URL: Homepage, https://github.com/gradio-app/gradio
+Author-email: Abubakar Abid <gradio-team@huggingface.co>, Ali Abid <gradio-team@huggingface.co>, Ali Abdalla <gradio-team@huggingface.co>, Dawood Khan <gradio-team@huggingface.co>, Ahsen Khaliq <gradio-team@huggingface.co>, Pete Allen <gradio-team@huggingface.co>, Ömer Faruk Özdemir <gradio-team@huggingface.co>, Freddy A Boulton <gradio-team@huggingface.co>, Hannah Blair <gradio-team@huggingface.co>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: machine learning,reproducibility,visualization
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Requires-Dist: aiofiles<24.0,>=22.0
+Requires-Dist: anyio<5.0,>=3.0
+Requires-Dist: fastapi<1.0
+Requires-Dist: ffmpy
+Requires-Dist: gradio-client==1.4.0
+Requires-Dist: httpx>=0.24.1
+Requires-Dist: huggingface-hub>=0.25.1
+Requires-Dist: jinja2<4.0
+Requires-Dist: markupsafe~=2.0
+Requires-Dist: numpy<3.0,>=1.0
+Requires-Dist: orjson~=3.0
+Requires-Dist: packaging
+Requires-Dist: pandas<3.0,>=1.0
+Requires-Dist: pillow<11.0,>=8.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydub
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: pyyaml<7.0,>=5.0
+Requires-Dist: ruff>=0.2.2; sys_platform != 'emscripten'
+Requires-Dist: semantic-version~=2.0
+Requires-Dist: tomlkit==0.12.0
+Requires-Dist: typer<1.0,>=0.12; sys_platform != 'emscripten'
+Requires-Dist: typing-extensions~=4.0
+Requires-Dist: urllib3~=2.0; sys_platform == 'emscripten'
+Requires-Dist: uvicorn>=0.14.0; sys_platform != 'emscripten'
+Provides-Extra: oauth
+Requires-Dist: authlib; extra == 'oauth'
+Requires-Dist: itsdangerous; extra == 'oauth'
+Description-Content-Type: text/markdown
+
+<!-- DO NOT EDIT THIS FILE DIRECTLY. INSTEAD EDIT THE `readme_template.md` OR `guides/1)getting_started/1)quickstart.md` TEMPLATES AND THEN RUN `render_readme.py` SCRIPT. -->
+
+<div align="center">
+
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/gradio.svg" alt="gradio" width=400>](https://gradio.app)<br>
+
+[![gradio-backend](https://github.com/gradio-app/gradio/actions/workflows/test-python.yml/badge.svg)](https://github.com/gradio-app/gradio/actions/workflows/test-python.yml)
+[![gradio-ui](https://github.com/gradio-app/gradio/actions/workflows/tests-js.yml/badge.svg)](https://github.com/gradio-app/gradio/actions/workflows/tests-js.yml)
+ [![PyPI](https://img.shields.io/pypi/v/gradio)](https://pypi.org/project/gradio/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/gradio)](https://pypi.org/project/gradio/)
+![Python version](https://img.shields.io/badge/python-3.10+-important)
+[![Twitter follow](https://img.shields.io/twitter/follow/gradio?style=social&label=follow)](https://twitter.com/gradio)
+
+[Website](https://gradio.app)
+| [Documentation](https://gradio.app/docs/)
+| [Guides](https://gradio.app/guides/)
+| [Getting Started](https://gradio.app/getting_started/)
+| [Examples](demo/)
+
+</div>
+
+<div align="center">
+
+English | [中文](https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/zh-cn#readme)
+
+</div>
+
+# Gradio: Build Machine Learning Web Apps — in Python
+
+
+
+Gradio is an open-source Python package that allows you to quickly **build** a demo or web application for your machine learning model, API, or any arbitrary Python function. You can then **share** a link to your demo or web application in just a few seconds using Gradio's built-in sharing features. *No JavaScript, CSS, or web hosting experience needed!*
+
+<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/gif-version.gif" style="padding-bottom: 10px">
+
+It just takes a few lines of Python to create your own demo, so let's get started 💫
+
+### Installation
+
+**Prerequisite**: Gradio 5 requires [Python 3.10 or higher](https://www.python.org/downloads/)
+
+
+We recommend installing Gradio using `pip`, which is included by default in Python. Run this in your terminal or command prompt:
+
+```
+pip install --upgrade gradio
+```
+
+
+> [!TIP]
+ > It is best to install Gradio in a virtual environment. Detailed installation instructions for all common operating systems <a href="https://www.gradio.app/main/guides/installing-gradio-in-a-virtual-environment">are provided here</a>. 
+
+### Building Your First Demo
+
+You can run Gradio in your favorite code editor, Jupyter notebook, Google Colab, or anywhere else you write Python. Let's write your first Gradio app:
+
+
+```python
+import gradio as gr
+
+def greet(name, intensity):
+    return "Hello " * intensity + name + "!"
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=["text", "slider"],
+    outputs=["text"],
+)
+
+demo.launch()
+```
+
+
+
+> [!TIP]
+ > We shorten the imported name from <code>gradio</code> to <code>gr</code> for better readability of code. This is a widely adopted convention that you should follow so that anyone working with your code can easily understand it. 
+
+Now, run your code. If you've written the Python code in a file named, for example, `app.py`, then you would run `python app.py` from the terminal.
+
+The demo below will open in a browser on [http://localhost:7860](http://localhost:7860) if running from a file. If you are running within a notebook, the demo will appear embedded within the notebook.
+
+![`hello_world_4` demo](https://raw.githubusercontent.com/gradio-app/gradio/main/demo/hello_world_4/screenshot.gif)
+
+Type your name in the textbox on the left, drag the slider, and then press the Submit button. You should see a friendly greeting on the right.
+
+> [!TIP]
+ > When developing locally, you can run your Gradio app in <strong>hot reload mode</strong>, which automatically reloads the Gradio app whenever you make changes to the file. To do this, simply type in <code>gradio</code> before the name of the file instead of <code>python</code>. In the example above, you would type: `gradio app.py` in your terminal. Learn more about hot reloading in the <a href="https://www.gradio.app/guides/developing-faster-with-reload-mode">Hot Reloading Guide</a>.
+
+
+**Understanding the `Interface` Class**
+
+You'll notice that in order to make your first demo, you created an instance of the `gr.Interface` class. The `Interface` class is designed to create demos for machine learning models which accept one or more inputs, and return one or more outputs. 
+
+The `Interface` class has three core arguments:
+
+- `fn`: the function to wrap a user interface (UI) around
+- `inputs`: the Gradio component(s) to use for the input. The number of components should match the number of arguments in your function.
+- `outputs`: the Gradio component(s) to use for the output. The number of components should match the number of return values from your function.
+
+The `fn` argument is very flexible -- you can pass *any* Python function that you want to wrap with a UI. In the example above, we saw a relatively simple function, but the function could be anything from a music generator to a tax calculator to the prediction function of a pretrained machine learning model.
+
+The `input` and `output` arguments take one or more Gradio components. As we'll see, Gradio includes more than [30 built-in components](https://www.gradio.app/docs/gradio/introduction) (such as the `gr.Textbox()`, `gr.Image()`, and `gr.HTML()` components) that are designed for machine learning applications. 
+
+> [!TIP]
+ > For the `inputs` and `outputs` arguments, you can pass in the name of these components as a string (`"textbox"`) or an instance of the class (`gr.Textbox()`).
+
+If your function accepts more than one argument, as is the case above, pass a list of input components to `inputs`, with each input component corresponding to one of the arguments of the function, in order. The same holds true if your function returns more than one value: simply pass in a list of components to `outputs`. This flexibility makes the `Interface` class a very powerful way to create demos.
+
+We'll dive deeper into the `gr.Interface` on our series on [building Interfaces](https://www.gradio.app/main/guides/the-interface-class).
+
+### Sharing Your Demo
+
+What good is a beautiful demo if you can't share it? Gradio lets you easily share a machine learning demo without having to worry about the hassle of hosting on a web server. Simply set `share=True` in `launch()`, and a publicly accessible URL will be created for your demo. Let's revisit our example demo,  but change the last line as follows:
+
+```python
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!"
+
+demo = gr.Interface(fn=greet, inputs="textbox", outputs="textbox")
+    
+demo.launch(share=True)  # Share your demo with just 1 extra parameter 🚀
+```
+
+When you run this code, a public URL will be generated for your demo in a matter of seconds, something like:
+
+👉 &nbsp; `https://a23dsf231adb.gradio.live`
+
+Now, anyone around the world can try your Gradio demo from their browser, while the machine learning model and all computation continues to run locally on your computer.
+
+To learn more about sharing your demo, read our dedicated guide on [sharing your Gradio application](https://www.gradio.app/guides/sharing-your-app).
+
+
+### An Overview of Gradio
+
+So far, we've been discussing the `Interface` class, which is a high-level class that lets to build demos quickly with Gradio. But what else does Gradio do?
+
+#### Chatbots with `gr.ChatInterface`
+
+Gradio includes another high-level class, `gr.ChatInterface`, which is specifically designed to create Chatbot UIs. Similar to `Interface`, you supply a function and Gradio creates a fully working Chatbot UI. If you're interested in creating a chatbot, you can jump straight [our dedicated guide on `gr.ChatInterface`](https://www.gradio.app/guides/creating-a-chatbot-fast).
+
+#### Custom Demos with `gr.Blocks`
+
+Gradio also offers a low-level approach for designing web apps with more flexible layouts and data flows with the `gr.Blocks` class. Blocks allows you to do things like control where components appear on the page, handle complex data flows (e.g. outputs can serve as inputs to other functions), and update properties/visibility of components based on user interaction — still all in Python. 
+
+You can build very custom and complex applications using `gr.Blocks()`. For example, the popular image generation [Automatic1111 Web UI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is built using Gradio Blocks. We dive deeper into the `gr.Blocks` on our series on [building with Blocks](https://www.gradio.app/guides/blocks-and-event-listeners).
+
+
+#### The Gradio Python & JavaScript Ecosystem
+
+That's the gist of the core `gradio` Python library, but Gradio is actually so much more! It's an entire ecosystem of Python and JavaScript libraries that let you build machine learning applications, or query them programmatically, in Python or JavaScript. Here are other related parts of the Gradio ecosystem:
+
+* [Gradio Python Client](https://www.gradio.app/guides/getting-started-with-the-python-client) (`gradio_client`): query any Gradio app programmatically in Python.
+* [Gradio JavaScript Client](https://www.gradio.app/guides/getting-started-with-the-js-client) (`@gradio/client`): query any Gradio app programmatically in JavaScript.
+* [Gradio-Lite](https://www.gradio.app/guides/gradio-lite) (`@gradio/lite`): write Gradio apps in Python that run entirely in the browser (no server needed!), thanks to Pyodide. 
+* [Hugging Face Spaces](https://huggingface.co/spaces): the most popular place to host Gradio applications — for free!
+
+### What's Next?
+
+Keep learning about Gradio sequentially using the Gradio Guides, which include explanations as well as example code and embedded interactive demos. Next up: [key features about Gradio demos](https://www.gradio.app/guides/key-features).
+
+Or, if you already know the basics and are looking for something specific, you can search the more [technical API documentation](https://www.gradio.app/docs/).
+
+
+
+
+## Questions?
+
+If you'd like to report a bug or have a feature request, please create an [issue on GitHub](https://github.com/gradio-app/gradio/issues/new/choose). For general questions about usage, we are available on [our Discord server](https://discord.com/invite/feTf9x3ZSB) and happy to help.
+
+If you like Gradio, please leave us a ⭐ on GitHub!
+
+## Open Source Stack
+
+Gradio is built on top of many wonderful open-source libraries!
+
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/huggingface_mini.svg" alt="huggingface" height=40>](https://huggingface.co)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/python.svg" alt="python" height=40>](https://www.python.org)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/fastapi.svg" alt="fastapi" height=40>](https://fastapi.tiangolo.com)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/encode.svg" alt="encode" height=40>](https://www.encode.io)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/svelte.svg" alt="svelte" height=40>](https://svelte.dev)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/vite.svg" alt="vite" height=40>](https://vitejs.dev)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/pnpm.svg" alt="pnpm" height=40>](https://pnpm.io)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/tailwind.svg" alt="tailwind" height=40>](https://tailwindcss.com)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/storybook.svg" alt="storybook" height=40>](https://storybook.js.org/)
+[<img src="https://raw.githubusercontent.com/gradio-app/gradio/main/readme_files/chromatic.svg" alt="chromatic" height=40>](https://www.chromatic.com/)
+
+## License
+
+Gradio is licensed under the Apache License 2.0 found in the [LICENSE](LICENSE) file in the root directory of this repository.
+
+## Citation
+
+Also check out the paper _[Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild](https://arxiv.org/abs/1906.02569), ICML HILL 2019_, and please cite it if you use Gradio in your work.
+
+```
+@article{abid2019gradio,
+  title = {Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild},
+  author = {Abid, Abubakar and Abdalla, Ali and Abid, Ali and Khan, Dawood and Alfozan, Abdulrahman and Zou, James},
+  journal = {arXiv preprint arXiv:1906.02569},
+  year = {2019},
+}
+```

evalkit_tf446/lib/python3.10/site-packages/gradio-5.1.0.dist-info/WHEEL

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

evalkit_tf446/lib/python3.10/site-packages/gradio-5.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gradio = gradio.cli:cli
+upload_theme = gradio.themes.upload_theme:main

evalkit_tf446/lib/python3.10/site-packages/gradio-5.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/INSTALLER

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

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Peter Odding
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.1
+Name: humanfriendly
+Version: 10.0
+Summary: Human friendly output for text interfaces using Python
+Home-page: https://humanfriendly.readthedocs.io
+Author: Peter Odding
+Author-email: peter@peterodding.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 6 - Mature
+Classifier: Environment :: Console
+Classifier: Framework :: Sphinx :: Extension
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Communications
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: System :: System Shells
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Terminals
+Classifier: Topic :: Text Processing :: General
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+Requires-Dist: monotonic ; python_version == "2.7"
+Requires-Dist: pyreadline ; sys_platform == "win32" and python_version<"3.8"
+Requires-Dist: pyreadline3 ; sys_platform == "win32" and python_version>="3.8"
+
+humanfriendly: Human friendly input/output in Python
+====================================================
+
+.. image:: https://github.com/xolox/python-humanfriendly/actions/workflows/test.yml/badge.svg?branch=master
+   :target: https://github.com/xolox/python-humanfriendly/actions
+
+.. image:: https://codecov.io/gh/xolox/python-humanfriendly/branch/master/graph/badge.svg?token=jYaj4T74TU
+   :target: https://codecov.io/gh/xolox/python-humanfriendly
+
+The functions and classes in the `humanfriendly` package can be used to make
+text interfaces more user friendly. Some example features:
+
+- Parsing and formatting numbers, file sizes, pathnames and timespans in
+  simple, human friendly formats.
+
+- Easy to use timers for long running operations, with human friendly
+  formatting of the resulting timespans.
+
+- Prompting the user to select a choice from a list of options by typing the
+  option's number or a unique substring of the option.
+
+- Terminal interaction including text styling (`ANSI escape sequences`_), user
+  friendly rendering of usage messages and querying the terminal for its
+  size.
+
+The `humanfriendly` package is currently tested on Python 2.7, 3.5+ and PyPy
+(2.7) on Linux and macOS. While the intention is to support Windows as well,
+you may encounter some rough edges.
+
+.. contents::
+   :local:
+
+Getting started
+---------------
+
+It's very simple to start using the `humanfriendly` package::
+
+   >>> from humanfriendly import format_size, parse_size
+   >>> from humanfriendly.prompts import prompt_for_input
+   >>> user_input = prompt_for_input("Enter a readable file size: ")
+
+     Enter a readable file size: 16G
+
+   >>> num_bytes = parse_size(user_input)
+   >>> print(num_bytes)
+   16000000000
+   >>> print("You entered:", format_size(num_bytes))
+   You entered: 16 GB
+   >>> print("You entered:", format_size(num_bytes, binary=True))
+   You entered: 14.9 GiB
+
+To get a demonstration of supported terminal text styles (based on
+`ANSI escape sequences`_) you can run the following command::
+
+   $ humanfriendly --demo
+
+Command line
+------------
+
+.. A DRY solution to avoid duplication of the `humanfriendly --help' text:
+..
+.. [[[cog
+.. from humanfriendly.usage import inject_usage
+.. inject_usage('humanfriendly.cli')
+.. ]]]
+
+**Usage:** `humanfriendly [OPTIONS]`
+
+Human friendly input/output (text formatting) on the command
+line based on the Python package with the same name.
+
+**Supported options:**
+
+.. csv-table::
+   :header: Option, Description
+   :widths: 30, 70
+
+
+   "``-c``, ``--run-command``","Execute an external command (given as the positional arguments) and render
+   a spinner and timer while the command is running. The exit status of the
+   command is propagated."
+   ``--format-table``,"Read tabular data from standard input (each line is a row and each
+   whitespace separated field is a column), format the data as a table and
+   print the resulting table to standard output. See also the ``--delimiter``
+   option."
+   "``-d``, ``--delimiter=VALUE``","Change the delimiter used by ``--format-table`` to ``VALUE`` (a string). By default
+   all whitespace is treated as a delimiter."
+   "``-l``, ``--format-length=LENGTH``","Convert a length count (given as the integer or float ``LENGTH``) into a human
+   readable string and print that string to standard output."
+   "``-n``, ``--format-number=VALUE``","Format a number (given as the integer or floating point number ``VALUE``) with
+   thousands separators and two decimal places (if needed) and print the
+   formatted number to standard output."
+   "``-s``, ``--format-size=BYTES``","Convert a byte count (given as the integer ``BYTES``) into a human readable
+   string and print that string to standard output."
+   "``-b``, ``--binary``","Change the output of ``-s``, ``--format-size`` to use binary multiples of bytes
+   (base-2) instead of the default decimal multiples of bytes (base-10)."
+   "``-t``, ``--format-timespan=SECONDS``","Convert a number of seconds (given as the floating point number ``SECONDS``)
+   into a human readable timespan and print that string to standard output."
+   ``--parse-length=VALUE``,"Parse a human readable length (given as the string ``VALUE``) and print the
+   number of metres to standard output."
+   ``--parse-size=VALUE``,"Parse a human readable data size (given as the string ``VALUE``) and print the
+   number of bytes to standard output."
+   ``--demo``,"Demonstrate changing the style and color of the terminal font using ANSI
+   escape sequences."
+   "``-h``, ``--help``",Show this message and exit.
+
+.. [[[end]]]
+
+A note about size units
+-----------------------
+
+When I originally published the `humanfriendly` package I went with binary
+multiples of bytes (powers of two). It was pointed out several times that this
+was a poor choice (see issue `#4`_ and pull requests `#8`_ and `#9`_) and thus
+the new default became decimal multiples of bytes (powers of ten):
+
++------+---------------+---------------+
+| Unit | Binary value  | Decimal value |
++------+---------------+---------------+
+| KB   |          1024 |          1000 +
++------+---------------+---------------+
+| MB   |       1048576 |       1000000 |
++------+---------------+---------------+
+| GB   |    1073741824 |    1000000000 |
++------+---------------+---------------+
+| TB   | 1099511627776 | 1000000000000 |
++------+---------------+---------------+
+| etc  |               |               |
++------+---------------+---------------+
+
+The option to use binary multiples of bytes remains by passing the keyword
+argument `binary=True` to the `format_size()`_ and `parse_size()`_ functions.
+
+Windows support
+---------------
+
+Windows 10 gained native support for ANSI escape sequences which means commands
+like ``humanfriendly --demo`` should work out of the box (if your system is
+up-to-date enough). If this doesn't work then you can install the colorama_
+package, it will be used automatically once installed.
+
+Contact
+-------
+
+The latest version of `humanfriendly` is available on PyPI_ and GitHub_. The
+documentation is hosted on `Read the Docs`_ and includes a changelog_. For bug
+reports please create an issue on GitHub_. If you have questions, suggestions,
+etc. feel free to send me an e-mail at `peter@peterodding.com`_.
+
+License
+-------
+
+This software is licensed under the `MIT license`_.
+
+© 2021 Peter Odding.
+
+.. External references:
+.. _#4: https://github.com/xolox/python-humanfriendly/issues/4
+.. _#8: https://github.com/xolox/python-humanfriendly/pull/8
+.. _#9: https://github.com/xolox/python-humanfriendly/pull/9
+.. _ANSI escape sequences: https://en.wikipedia.org/wiki/ANSI_escape_code
+.. _changelog: https://humanfriendly.readthedocs.io/en/latest/changelog.html
+.. _colorama: https://pypi.org/project/colorama
+.. _format_size(): https://humanfriendly.readthedocs.io/en/latest/#humanfriendly.format_size
+.. _GitHub: https://github.com/xolox/python-humanfriendly
+.. _MIT license: https://en.wikipedia.org/wiki/MIT_License
+.. _parse_size(): https://humanfriendly.readthedocs.io/en/latest/#humanfriendly.parse_size
+.. _peter@peterodding.com: peter@peterodding.com
+.. _PyPI: https://pypi.org/project/humanfriendly
+.. _Read the Docs: https://humanfriendly.readthedocs.io
+
+

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+../../../bin/humanfriendly,sha256=L4sFudVXsiJ6ccfUnOU4WBxyxC-9lBPyGXRe1-5_lBY,235
+humanfriendly-10.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+humanfriendly-10.0.dist-info/LICENSE.txt,sha256=SsSPQReAnyc0BmFQRQ8SCzuxEKwdOzIXB5XgVg27wfU,1056
+humanfriendly-10.0.dist-info/METADATA,sha256=aLs0k4jN_spgKsw0Vbg6ey_jy-hAJeJ0k7y-dvOrbII,9201
+humanfriendly-10.0.dist-info/RECORD,,
+humanfriendly-10.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanfriendly-10.0.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+humanfriendly-10.0.dist-info/entry_points.txt,sha256=hU-ADsGls3mgf3plBt9B-oYLCtBDQiUJZ00khuAoqXc,58
+humanfriendly-10.0.dist-info/top_level.txt,sha256=7eKAKhckmlD4ZoWJkWmhnTs1pnP_bzF-56VTq0D7WIo,14
+humanfriendly/__init__.py,sha256=sPCMQv16m3p8xYwd3N3kUs1rewVJB3ZGDBkF0_8v6vo,31725
+humanfriendly/__pycache__/__init__.cpython-310.pyc,,
+humanfriendly/__pycache__/case.cpython-310.pyc,,
+humanfriendly/__pycache__/cli.cpython-310.pyc,,
+humanfriendly/__pycache__/compat.cpython-310.pyc,,
+humanfriendly/__pycache__/decorators.cpython-310.pyc,,
+humanfriendly/__pycache__/deprecation.cpython-310.pyc,,
+humanfriendly/__pycache__/prompts.cpython-310.pyc,,
+humanfriendly/__pycache__/sphinx.cpython-310.pyc,,
+humanfriendly/__pycache__/tables.cpython-310.pyc,,
+humanfriendly/__pycache__/testing.cpython-310.pyc,,
+humanfriendly/__pycache__/tests.cpython-310.pyc,,
+humanfriendly/__pycache__/text.cpython-310.pyc,,
+humanfriendly/__pycache__/usage.cpython-310.pyc,,
+humanfriendly/case.py,sha256=fkIinj4V1S8Xl3OCSYSgqKoGzCCbVJOjI5ZznViCT1Q,6008
+humanfriendly/cli.py,sha256=ZpGqTHLwfLjFACsQacYkN9DiBZkGecPzIHysliWN1i8,9822
+humanfriendly/compat.py,sha256=7qoFGMNFizGhs5BIyiMKTDUq29DxzuXGX4MRoZLo4ms,3984
+humanfriendly/decorators.py,sha256=ivxB-U9dfXUjCl4GZ8g_gKFC4a3uyxDVi-3rlxPjvJo,1501
+humanfriendly/deprecation.py,sha256=bdx1_T8L1gF635E41E6bYTqie9P3o7rY6n4wohjkLLk,9499
+humanfriendly/prompts.py,sha256=8PSJ1Hpr3ld6YkCaXQsTHAep9BtTKYlKmQi1RiaHIEc,16335
+humanfriendly/sphinx.py,sha256=BrFxK-rX3LN4iMqgNFuOTweYfppYp--O3HqWBlu05M0,11452
+humanfriendly/tables.py,sha256=lCDnEKyyZRmrIHrDlUzzVpg9z6lKOO8ldP4fh1gzMBI,13968
+humanfriendly/terminal/__init__.py,sha256=5BzxVHKriznclRjrWwYEk2l1ct0q0WdupJIrkuI9glc,30759
+humanfriendly/terminal/__pycache__/__init__.cpython-310.pyc,,
+humanfriendly/terminal/__pycache__/html.cpython-310.pyc,,
+humanfriendly/terminal/__pycache__/spinners.cpython-310.pyc,,
+humanfriendly/terminal/html.py,sha256=_csUZ4hID0ATwTvPXU8KrAe6ZzD_gUS7_tN3FmCHA4Q,16747
+humanfriendly/terminal/spinners.py,sha256=o7nkn8rBdTqr-XHIT972sIgIuxiDymQ5kPVkBzR7utE,11323
+humanfriendly/testing.py,sha256=hErsmBN5Crej5k1P_I0dhQK8IAwFr1IOZ9kQPIrZUys,24359
+humanfriendly/tests.py,sha256=3bkasrRgw0cAdZFHgmTo4DUHgXEnlHtRoq_t2MEafbc,68919
+humanfriendly/text.py,sha256=_WBG4SZ4bT5SH94zLUdfmB6NXbvc4gBYECEmQYXJ1sE,16212
+humanfriendly/usage.py,sha256=AhPo6DcvaBRIFGWNctU22McMzN3Ryc6ZCC83kt2Zbk4,13768

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+humanfriendly = humanfriendly.cli:main
+

evalkit_tf446/lib/python3.10/site-packages/humanfriendly-10.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+humanfriendly

evalkit_tf446/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.36.0"
+
+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",
+]

evalkit_tf446/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")

evalkit_tf446/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",
+]

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

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

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

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

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

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

evalkit_tf446/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 []

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

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

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

evalkit_tf446/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()

evalkit_tf446/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.")

evalkit_tf446/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.")

evalkit_tf446/lib/python3.10/site-packages/imageio/plugins/fits.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+"""Read FITS files.
+
+Backend Library: `Astropy <https://www.astropy.org/>`_
+
+.. note::
+    To use this plugin you have to install its backend::
+
+        pip install imageio[fits]
+
+Flexible Image Transport System (FITS) is an open standard defining a
+digital file format useful for storage, transmission and processing of
+scientific and other images. FITS is the most commonly used digital
+file format in astronomy.
+
+
+Parameters
+----------
+cache : bool
+    If the file name is a URL, `~astropy.utils.data.download_file` is used
+    to open the file.  This specifies whether or not to save the file
+    locally in Astropy's download cache (default: `True`).
+uint : bool
+    Interpret signed integer data where ``BZERO`` is the
+    central value and ``BSCALE == 1`` as unsigned integer
+    data.  For example, ``int16`` data with ``BZERO = 32768``
+    and ``BSCALE = 1`` would be treated as ``uint16`` data.
+
+    Note, for backward compatibility, the kwarg **uint16** may
+    be used instead.  The kwarg was renamed when support was
+    added for integers of any size.
+ignore_missing_end : bool
+    Do not issue an exception when opening a file that is
+    missing an ``END`` card in the last header.
+checksum : bool or str
+    If `True`, verifies that both ``DATASUM`` and
+    ``CHECKSUM`` card values (when present in the HDU header)
+    match the header and data of all HDU's in the file.  Updates to a
+    file that already has a checksum will preserve and update the
+    existing checksums unless this argument is given a value of
+    'remove', in which case the CHECKSUM and DATASUM values are not
+    checked, and are removed when saving changes to the file.
+disable_image_compression : bool, optional
+    If `True`, treats compressed image HDU's like normal
+    binary table HDU's.
+do_not_scale_image_data : bool
+    If `True`, image data is not scaled using BSCALE/BZERO values
+    when read.
+ignore_blank : bool
+    If `True`, the BLANK keyword is ignored if present.
+scale_back : bool
+    If `True`, when saving changes to a file that contained scaled
+    image data, restore the data to the original type and reapply the
+    original BSCALE/BZERO values.  This could lead to loss of accuracy
+    if scaling back to integer values after performing floating point
+    operations on the data.
+
+"""
+
+from ..core import Format
+
+_fits = None  # lazily loaded
+
+
+def load_lib():
+    global _fits
+    try:
+        from astropy.io import fits as _fits
+    except ImportError:
+        raise ImportError(
+            "The FITS format relies on the astropy package."
+            "Please refer to http://www.astropy.org/ "
+            "for further instructions."
+        )
+    return _fits
+
+
+class FitsFormat(Format):
+    """See :mod:`imageio.plugins.fits`"""
+
+    def _can_read(self, request):
+        # We return True if ext matches, because this is the only plugin
+        # that can. If astropy is not installed, a useful error follows.
+        return request.extension in self.extensions
+
+    def _can_write(self, request):
+        # No write support
+        return False
+
+    # -- reader
+
+    class Reader(Format.Reader):
+        def _open(self, cache=False, **kwargs):
+            if not _fits:
+                load_lib()
+            hdulist = _fits.open(self.request.get_file(), cache=cache, **kwargs)
+
+            self._index = []
+            allowed_hdu_types = (_fits.ImageHDU, _fits.PrimaryHDU, _fits.CompImageHDU)
+            for n, hdu in zip(range(len(hdulist)), hdulist):
+                if isinstance(hdu, allowed_hdu_types):
+                    # Ignore (primary) header units with no data (use '.size'
+                    # rather than '.data' to avoid actually loading the image):
+                    if hdu.size > 0:
+                        self._index.append(n)
+            self._hdulist = hdulist
+
+        def _close(self):
+            self._hdulist.close()
+
+        def _get_length(self):
+            return len(self._index)
+
+        def _get_data(self, index):
+            # Get data
+            if index < 0 or index >= len(self._index):
+                raise IndexError("Index out of range while reading from fits")
+            im = self._hdulist[self._index[index]].data
+            # Return array and empty meta data
+            return im, {}
+
+        def _get_meta_data(self, index):
+            # Get the meta data for the given index
+            raise RuntimeError("The fits format does not support meta data.")

evalkit_tf446/lib/python3.10/site-packages/imageio/plugins/npz.py

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

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

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

evalkit_tf446/lib/python3.10/site-packages/imageio/plugins/pillowmulti.py

@@ -0,0 +1,338 @@
+"""
+PIL formats for multiple images.
+"""
+
+import logging
+
+import numpy as np
+
+from .pillow_legacy import PillowFormat, image_as_uint, ndarray_to_pil
+
+logger = logging.getLogger(__name__)
+
+NeuQuant = None  # we can implement this when we need it
+
+
+class TIFFFormat(PillowFormat):
+    _modes = "i"  # arg, why bother; people should use the tiffile version
+    _description = "TIFF format (Pillow)"
+
+
+class GIFFormat(PillowFormat):
+    """See :mod:`imageio.plugins.pillow_legacy`"""
+
+    _modes = "iI"
+    _description = "Static and animated gif (Pillow)"
+
+    # GIF reader needs no modifications compared to base pillow reader
+
+    class Writer(PillowFormat.Writer):  # pragma: no cover
+        def _open(
+            self,
+            loop=0,
+            duration=None,
+            fps=10,
+            palettesize=256,
+            quantizer=0,
+            subrectangles=False,
+        ):
+            from PIL import __version__ as pillow_version
+
+            major, minor, patch = tuple(int(x) for x in pillow_version.split("."))
+            if major == 10 and minor >= 1:
+                raise ImportError(
+                    f"Pillow v{pillow_version} is not supported by ImageIO's legacy "
+                    "pillow plugin when writing GIFs. Consider switching to the new "
+                    "plugin or downgrading to `pillow<10.1.0`."
+                )
+
+            # Check palettesize
+            palettesize = int(palettesize)
+            if palettesize < 2 or palettesize > 256:
+                raise ValueError("GIF quantize param must be 2..256")
+            if palettesize not in [2, 4, 8, 16, 32, 64, 128, 256]:
+                palettesize = 2 ** int(np.log2(128) + 0.999)
+                logger.warning(
+                    "Warning: palettesize (%r) modified to a factor of "
+                    "two between 2-256." % palettesize
+                )
+            #  Duratrion / fps
+            if duration is None:
+                self._duration = 1.0 / float(fps)
+            elif isinstance(duration, (list, tuple)):
+                self._duration = [float(d) for d in duration]
+            else:
+                self._duration = float(duration)
+            # loop
+            loop = float(loop)
+            if loop <= 0 or loop == float("inf"):
+                loop = 0
+            loop = int(loop)
+            # Subrectangles / dispose
+            subrectangles = bool(subrectangles)
+            self._dispose = 1 if subrectangles else 2
+            # The "0" (median cut) quantizer is by far the best
+
+            fp = self.request.get_file()
+            self._writer = GifWriter(
+                fp, subrectangles, loop, quantizer, int(palettesize)
+            )
+
+        def _close(self):
+            self._writer.close()
+
+        def _append_data(self, im, meta):
+            im = image_as_uint(im, bitdepth=8)
+            if im.ndim == 3 and im.shape[-1] == 1:
+                im = im[:, :, 0]
+            duration = self._duration
+            if isinstance(duration, list):
+                duration = duration[min(len(duration) - 1, self._writer._count)]
+            dispose = self._dispose
+            self._writer.add_image(im, duration, dispose)
+
+            return
+
+
+def intToBin(i):
+    return i.to_bytes(2, byteorder="little")
+
+
+class GifWriter:  # pragma: no cover
+    """Class that for helping write the animated GIF file. This is based on
+    code from images2gif.py (part of visvis). The version here is modified
+    to allow streamed writing.
+    """
+
+    def __init__(
+        self,
+        file,
+        opt_subrectangle=True,
+        opt_loop=0,
+        opt_quantizer=0,
+        opt_palette_size=256,
+    ):
+        self.fp = file
+
+        self.opt_subrectangle = opt_subrectangle
+        self.opt_loop = opt_loop
+        self.opt_quantizer = opt_quantizer
+        self.opt_palette_size = opt_palette_size
+
+        self._previous_image = None  # as np array
+        self._global_palette = None  # as bytes
+        self._count = 0
+
+        from PIL.GifImagePlugin import getdata
+
+        self.getdata = getdata
+
+    def add_image(self, im, duration, dispose):
+        # Prepare image
+        im_rect, rect = im, (0, 0)
+        if self.opt_subrectangle:
+            im_rect, rect = self.getSubRectangle(im)
+        im_pil = self.converToPIL(im_rect, self.opt_quantizer, self.opt_palette_size)
+
+        # Get pallette - apparently, this is the 3d element of the header
+        # (but it has not always been). Best we've got. Its not the same
+        # as im_pil.palette.tobytes().
+        from PIL.GifImagePlugin import getheader
+
+        palette = getheader(im_pil)[0][3]
+
+        # Write image
+        if self._count == 0:
+            self.write_header(im_pil, palette, self.opt_loop)
+            self._global_palette = palette
+        self.write_image(im_pil, palette, rect, duration, dispose)
+        # assert len(palette) == len(self._global_palette)
+
+        # Bookkeeping
+        self._previous_image = im
+        self._count += 1
+
+    def write_header(self, im, globalPalette, loop):
+        # Gather info
+        header = self.getheaderAnim(im)
+        appext = self.getAppExt(loop)
+        # Write
+        self.fp.write(header)
+        self.fp.write(globalPalette)
+        self.fp.write(appext)
+
+    def close(self):
+        self.fp.write(";".encode("utf-8"))  # end gif
+
+    def write_image(self, im, palette, rect, duration, dispose):
+        fp = self.fp
+
+        # Gather local image header and data, using PIL's getdata. That
+        # function returns a list of bytes objects, but which parts are
+        # what has changed multiple times, so we put together the first
+        # parts until we have enough to form the image header.
+        data = self.getdata(im)
+        imdes = b""
+        while data and len(imdes) < 11:
+            imdes += data.pop(0)
+        assert len(imdes) == 11
+
+        # Make image descriptor suitable for using 256 local color palette
+        lid = self.getImageDescriptor(im, rect)
+        graphext = self.getGraphicsControlExt(duration, dispose)
+
+        # Write local header
+        if (palette != self._global_palette) or (dispose != 2):
+            # Use local color palette
+            fp.write(graphext)
+            fp.write(lid)  # write suitable image descriptor
+            fp.write(palette)  # write local color table
+            fp.write(b"\x08")  # LZW minimum size code
+        else:
+            # Use global color palette
+            fp.write(graphext)
+            fp.write(imdes)  # write suitable image descriptor
+
+        # Write image data
+        for d in data:
+            fp.write(d)
+
+    def getheaderAnim(self, im):
+        """Get animation header. To replace PILs getheader()[0]"""
+        bb = b"GIF89a"
+        bb += intToBin(im.size[0])
+        bb += intToBin(im.size[1])
+        bb += b"\x87\x00\x00"
+        return bb
+
+    def getImageDescriptor(self, im, xy=None):
+        """Used for the local color table properties per image.
+        Otherwise global color table applies to all frames irrespective of
+        whether additional colors comes in play that require a redefined
+        palette. Still a maximum of 256 color per frame, obviously.
+
+        Written by Ant1 on 2010-08-22
+        Modified by Alex Robinson in Janurari 2011 to implement subrectangles.
+        """
+
+        # Defaule use full image and place at upper left
+        if xy is None:
+            xy = (0, 0)
+
+        # Image separator,
+        bb = b"\x2C"
+
+        # Image position and size
+        bb += intToBin(xy[0])  # Left position
+        bb += intToBin(xy[1])  # Top position
+        bb += intToBin(im.size[0])  # image width
+        bb += intToBin(im.size[1])  # image height
+
+        # packed field: local color table flag1, interlace0, sorted table0,
+        # reserved00, lct size111=7=2^(7 + 1)=256.
+        bb += b"\x87"
+
+        # LZW minimum size code now comes later, begining of [imagedata] blocks
+        return bb
+
+    def getAppExt(self, loop):
+        """Application extension. This part specifies the amount of loops.
+        If loop is 0 or inf, it goes on infinitely.
+        """
+        if loop == 1:
+            return b""
+        if loop == 0:
+            loop = 2**16 - 1
+        bb = b""
+        if loop != 0:  # omit the extension if we would like a nonlooping gif
+            bb = b"\x21\xFF\x0B"  # application extension
+            bb += b"NETSCAPE2.0"
+            bb += b"\x03\x01"
+            bb += intToBin(loop)
+            bb += b"\x00"  # end
+        return bb
+
+    def getGraphicsControlExt(self, duration=0.1, dispose=2):
+        """Graphics Control Extension. A sort of header at the start of
+        each image. Specifies duration and transparancy.
+
+        Dispose
+        -------
+          * 0 - No disposal specified.
+          * 1 - Do not dispose. The graphic is to be left in place.
+          * 2 - Restore to background color. The area used by the graphic
+            must be restored to the background color.
+          * 3 - Restore to previous. The decoder is required to restore the
+            area overwritten by the graphic with what was there prior to
+            rendering the graphic.
+          * 4-7 -To be defined.
+        """
+
+        bb = b"\x21\xF9\x04"
+        bb += chr((dispose & 3) << 2).encode("utf-8")
+        # low bit 1 == transparency,
+        # 2nd bit 1 == user input , next 3 bits, the low two of which are used,
+        # are dispose.
+        bb += intToBin(int(duration * 100 + 0.5))  # in 100th of seconds
+        bb += b"\x00"  # no transparant color
+        bb += b"\x00"  # end
+        return bb
+
+    def getSubRectangle(self, im):
+        """Calculate the minimal rectangle that need updating. Returns
+        a two-element tuple containing the cropped image and an x-y tuple.
+
+        Calculating the subrectangles takes extra time, obviously. However,
+        if the image sizes were reduced, the actual writing of the GIF
+        goes faster. In some cases applying this method produces a GIF faster.
+        """
+
+        # Cannot do subrectangle for first image
+        if self._count == 0:
+            return im, (0, 0)
+
+        prev = self._previous_image
+
+        # Get difference, sum over colors
+        diff = np.abs(im - prev)
+        if diff.ndim == 3:
+            diff = diff.sum(2)
+        # Get begin and end for both dimensions
+        X = np.argwhere(diff.sum(0))
+        Y = np.argwhere(diff.sum(1))
+        # Get rect coordinates
+        if X.size and Y.size:
+            x0, x1 = int(X[0]), int(X[-1] + 1)
+            y0, y1 = int(Y[0]), int(Y[-1] + 1)
+        else:  # No change ... make it minimal
+            x0, x1 = 0, 2
+            y0, y1 = 0, 2
+
+        return im[y0:y1, x0:x1], (x0, y0)
+
+    def converToPIL(self, im, quantizer, palette_size=256):
+        """Convert image to Paletted PIL image.
+
+        PIL used to not do a very good job at quantization, but I guess
+        this has improved a lot (at least in Pillow). I don't think we need
+        neuqant (and we can add it later if we really want).
+        """
+
+        im_pil = ndarray_to_pil(im, "gif")
+
+        if quantizer in ("nq", "neuquant"):
+            # NeuQuant algorithm
+            nq_samplefac = 10  # 10 seems good in general
+            im_pil = im_pil.convert("RGBA")  # NQ assumes RGBA
+            nqInstance = NeuQuant(im_pil, nq_samplefac)  # Learn colors
+            im_pil = nqInstance.quantize(im_pil, colors=palette_size)
+        elif quantizer in (0, 1, 2):
+            # Adaptive PIL algorithm
+            if quantizer == 2:
+                im_pil = im_pil.convert("RGBA")
+            else:
+                im_pil = im_pil.convert("RGB")
+            im_pil = im_pil.quantize(colors=palette_size, method=quantizer)
+        else:
+            raise ValueError("Invalid value for quantizer: %r" % quantizer)
+        return im_pil

evalkit_tf446/lib/python3.10/site-packages/imageio/plugins/pyav.py

@@ -0,0 +1,1199 @@
+"""Read/Write Videos (and images) using PyAV.
+
+.. note::
+    To use this plugin you need to have `PyAV <https://pyav.org/docs/stable/>`_
+    installed::
+
+        pip install av
+
+This plugin wraps pyAV, a pythonic binding for the FFMPEG library. It is similar
+to our FFMPEG plugin, has improved performance, features a robust interface, and
+aims to supersede the FFMPEG plugin in the future.
+
+
+Methods
+-------
+.. note::
+    Check the respective function for a list of supported kwargs and detailed
+    documentation.
+
+.. autosummary::
+    :toctree:
+
+    PyAVPlugin.read
+    PyAVPlugin.iter
+    PyAVPlugin.write
+    PyAVPlugin.properties
+    PyAVPlugin.metadata
+
+Additional methods available inside the :func:`imopen <imageio.v3.imopen>`
+context:
+
+.. autosummary::
+    :toctree:
+
+    PyAVPlugin.init_video_stream
+    PyAVPlugin.write_frame
+    PyAVPlugin.set_video_filter
+    PyAVPlugin.container_metadata
+    PyAVPlugin.video_stream_metadata
+
+Advanced API
+------------
+
+In addition to the default ImageIO v3 API this plugin exposes custom functions
+that are specific to reading/writing video and its metadata. These are available
+inside the :func:`imopen <imageio.v3.imopen>` context and allow fine-grained
+control over how the video is processed. The functions are documented above and
+below you can find a usage example::
+
+    import imageio.v3 as iio
+
+    with iio.imopen("test.mp4", "w", plugin="pyav") as file:
+        file.init_video_stream("libx264")
+        file.container_metadata["comment"] = "This video was created using ImageIO."
+
+        for _ in range(5):
+            for frame in iio.imiter("imageio:newtonscradle.gif"):
+                file.write_frame(frame)
+
+    meta = iio.immeta("test.mp4", plugin="pyav")
+    assert meta["comment"] == "This video was created using ImageIO."
+
+
+
+Pixel Formats (Colorspaces)
+---------------------------
+
+By default, this plugin converts the video into 8-bit RGB (called ``rgb24`` in
+ffmpeg). This is a useful behavior for many use-cases, but sometimes you may
+want to use the video's native colorspace or you may wish to convert the video
+into an entirely different colorspace. This is controlled using the ``format``
+kwarg. You can use ``format=None`` to leave the image in its native colorspace
+or specify any colorspace supported by FFMPEG as long as it is stridable, i.e.,
+as long as it can be represented by a single numpy array. Some useful choices
+include:
+
+- rgb24 (default; 8-bit RGB)
+- rgb48le (16-bit lower-endian RGB)
+- bgr24 (8-bit BGR; openCVs default colorspace)
+- gray (8-bit grayscale)
+- yuv444p (8-bit channel-first YUV)
+
+Further, FFMPEG maintains a list of available formats, albeit not as part of the
+narrative docs. It can be `found here
+<https://ffmpeg.org/doxygen/trunk/pixfmt_8h_source.html>`_ (warning: C source
+code).
+
+Filters
+-------
+
+On top of providing basic read/write functionality, this plugin allows you to
+use the full collection of `video filters available in FFMPEG
+<https://ffmpeg.org/ffmpeg-filters.html#Video-Filters>`_. This means that you
+can apply excessive preprocessing to your video before retrieving it as a numpy
+array or apply excessive post-processing before you encode your data.
+
+Filters come in two forms: sequences or graphs. Filter sequences are, as the
+name suggests, sequences of filters that are applied one after the other. They
+are specified using the ``filter_sequence`` kwarg. Filter graphs, on the other
+hand, come in the form of a directed graph and are specified using the
+``filter_graph`` kwarg.
+
+.. note::
+    All filters are either sequences or graphs. If all you want is to apply a
+    single filter, you can do this by specifying a filter sequence with a single
+    entry.
+
+A ``filter_sequence`` is a list of filters, each defined through a 2-element
+tuple of the form ``(filter_name, filter_parameters)``. The first element of the
+tuple is the name of the filter. The second element are the filter parameters,
+which can be given either as a string or a dict. The string matches the same
+format that you would use when specifying the filter using the ffmpeg
+command-line tool and the dict has entries of the form ``parameter:value``. For
+example::
+
+    import imageio.v3 as iio
+
+    # using a filter_parameters str
+    img1 = iio.imread(
+        "imageio:cockatoo.mp4",
+        plugin="pyav",
+        filter_sequence=[
+            ("rotate", "45*PI/180")
+        ]
+    )
+
+    # using a filter_parameters dict
+    img2 = iio.imread(
+        "imageio:cockatoo.mp4",
+        plugin="pyav",
+        filter_sequence=[
+            ("rotate", {"angle":"45*PI/180", "fillcolor":"AliceBlue"})
+        ]
+    )
+
+A ``filter_graph``, on the other hand, is specified using a ``(nodes, edges)``
+tuple. It is best explained using an example::
+
+    img = iio.imread(
+        "imageio:cockatoo.mp4",
+        plugin="pyav",
+        filter_graph=(
+            {
+                "split": ("split", ""),
+                "scale_overlay":("scale", "512:-1"),
+                "overlay":("overlay", "x=25:y=25:enable='between(t,1,8)'"),
+            },
+            [
+                ("video_in", "split", 0, 0),
+                ("split", "overlay", 0, 0),
+                ("split", "scale_overlay", 1, 0),
+                ("scale_overlay", "overlay", 0, 1),
+                ("overlay", "video_out", 0, 0),
+            ]
+        )
+    )
+
+The above transforms the video to have picture-in-picture of itself in the top
+left corner. As you can see, nodes are specified using a dict which has names as
+its keys and filter tuples as values; the same tuples as the ones used when
+defining a filter sequence. Edges are a list of a 4-tuples of the form
+``(node_out, node_in, output_idx, input_idx)`` and specify which two filters are
+connected and which inputs/outputs should be used for this.
+
+Further, there are two special nodes in a filter graph: ``video_in`` and
+``video_out``, which represent the graph's input and output respectively. These
+names can not be chosen for other nodes (those nodes would simply be
+overwritten), and for a graph to be valid there must be a path from the input to
+the output and all nodes in the graph must be connected.
+
+While most graphs are quite simple, they can become very complex and we
+recommend that you read through the `FFMPEG documentation
+<https://ffmpeg.org/ffmpeg-filters.html#Filtergraph-description>`_ and their
+examples to better understand how to use them.
+
+"""
+
+from fractions import Fraction
+from math import ceil
+from typing import Any, Dict, List, Optional, Tuple, Union, Generator
+
+import av
+import av.filter
+import numpy as np
+from numpy.lib.stride_tricks import as_strided
+
+from ..core import Request
+from ..core.request import URI_BYTES, InitializationError, IOMode
+from ..core.v3_plugin_api import ImageProperties, PluginV3
+
+
+def _format_to_dtype(format: av.VideoFormat) -> np.dtype:
+    """Convert a pyAV video format into a numpy dtype"""
+
+    if len(format.components) == 0:
+        # fake format
+        raise ValueError(
+            f"Can't determine dtype from format `{format.name}`. It has no channels."
+        )
+
+    endian = ">" if format.is_big_endian else "<"
+    dtype = "f" if "f32" in format.name else "u"
+    bits_per_channel = [x.bits for x in format.components]
+    n_bytes = str(int(ceil(bits_per_channel[0] / 8)))
+
+    return np.dtype(endian + dtype + n_bytes)
+
+
+def _get_frame_shape(frame: av.VideoFrame) -> Tuple[int, ...]:
+    """Compute the frame's array shape
+
+    Parameters
+    ----------
+    frame : av.VideoFrame
+        A frame for which the resulting shape should be computed.
+
+    Returns
+    -------
+    shape : Tuple[int, ...]
+        A tuple describing the shape of the image data in the frame.
+
+    """
+
+    widths = [component.width for component in frame.format.components]
+    heights = [component.height for component in frame.format.components]
+    bits = np.array([component.bits for component in frame.format.components])
+    line_sizes = [plane.line_size for plane in frame.planes]
+
+    subsampled_width = widths[:-1] != widths[1:]
+    subsampled_height = heights[:-1] != heights[1:]
+    unaligned_components = np.any(bits % 8 != 0) or (line_sizes[:-1] != line_sizes[1:])
+    if subsampled_width or subsampled_height or unaligned_components:
+        raise IOError(
+            f"{frame.format.name} can't be expressed as a strided array."
+            "Use `format=` to select a format to convert into."
+        )
+
+    shape = [frame.height, frame.width]
+
+    # ffmpeg doesn't have a notion of channel-first or channel-last formats
+    # instead it stores frames in one or more planes which contain individual
+    # components of a pixel depending on the pixel format. For channel-first
+    # formats each component lives on a separate plane (n_planes) and for
+    # channel-last formats all components are packed on a single plane
+    # (n_channels)
+    n_planes = max([component.plane for component in frame.format.components]) + 1
+    if n_planes > 1:
+        shape = [n_planes] + shape
+
+    channels_per_plane = [0] * n_planes
+    for component in frame.format.components:
+        channels_per_plane[component.plane] += 1
+    n_channels = max(channels_per_plane)
+
+    if n_channels > 1:
+        shape = shape + [n_channels]
+
+    return tuple(shape)
+
+
+class PyAVPlugin(PluginV3):
+    """Support for pyAV as backend.
+
+    Parameters
+    ----------
+    request : iio.Request
+        A request object that represents the users intent. It provides a
+        standard interface to access various the various ImageResources and
+        serves them to the plugin as a file object (or file). Check the docs for
+        details.
+    container : str
+        Only used during `iio_mode="w"`! If not None, overwrite the default container
+        format chosen by pyav.
+    kwargs : Any
+        Additional kwargs are forwarded to PyAV's constructor.
+
+    """
+
+    def __init__(self, request: Request, *, container: str = None, **kwargs) -> None:
+        """Initialize a new Plugin Instance.
+
+        See Plugin's docstring for detailed documentation.
+
+        Notes
+        -----
+        The implementation here stores the request as a local variable that is
+        exposed using a @property below. If you inherit from PluginV3, remember
+        to call ``super().__init__(request)``.
+
+        """
+
+        super().__init__(request)
+
+        self._container = None
+        self._video_stream = None
+        self._video_filter = None
+
+        if request.mode.io_mode == IOMode.read:
+            self._next_idx = 0
+            try:
+                if request._uri_type == 5:  # 5 is the value of URI_HTTP
+                    # pyav should read from HTTP by itself. This enables reading
+                    # HTTP-based streams like DASH. Note that solving streams
+                    # like this is temporary until the new request object gets
+                    # implemented.
+                    self._container = av.open(request.raw_uri, **kwargs)
+                else:
+                    self._container = av.open(request.get_file(), **kwargs)
+                self._video_stream = self._container.streams.video[0]
+                self._decoder = self._container.decode(video=0)
+            except av.AVError:
+                if isinstance(request.raw_uri, bytes):
+                    msg = "PyAV does not support these `<bytes>`"
+                else:
+                    msg = f"PyAV does not support `{request.raw_uri}`"
+                raise InitializationError(msg) from None
+        else:
+            self.frames_written = 0
+            file_handle = self.request.get_file()
+            filename = getattr(file_handle, "name", None)
+            extension = self.request.extension or self.request.format_hint
+            if extension is None:
+                raise InitializationError("Can't determine output container to use.")
+
+            # hacky, but beats running our own format selection logic
+            # (since av_guess_format is not exposed)
+            try:
+                setattr(file_handle, "name", filename or "tmp" + extension)
+            except AttributeError:
+                pass  # read-only, nothing we can do
+
+            try:
+                self._container = av.open(
+                    file_handle, mode="w", format=container, **kwargs
+                )
+            except ValueError:
+                raise InitializationError(
+                    f"PyAV can not write to `{self.request.raw_uri}`"
+                )
+
+    # ---------------------
+    # Standard V3 Interface
+    # ---------------------
+
+    def read(
+        self,
+        *,
+        index: int = ...,
+        format: str = "rgb24",
+        filter_sequence: List[Tuple[str, Union[str, dict]]] = None,
+        filter_graph: Tuple[dict, List] = None,
+        constant_framerate: bool = None,
+        thread_count: int = 0,
+        thread_type: str = None,
+    ) -> np.ndarray:
+        """Read frames from the video.
+
+        If ``index`` is an integer, this function reads the index-th frame from
+        the file. If ``index`` is ... (Ellipsis), this function reads all frames
+        from the video, stacks them along the first dimension, and returns a
+        batch of frames.
+
+        Parameters
+        ----------
+        index : int
+            The index of the frame to read, e.g. ``index=5`` reads the 5th
+            frame. If ``...``, read all the frames in the video and stack them
+            along a new, prepended, batch dimension.
+        format : str
+            Set the returned colorspace. If not None (default: rgb24), convert
+            the data into the given format before returning it. If ``None``
+            return the data in the encoded format if it can be expressed as a
+            strided array; otherwise raise an Exception.
+        filter_sequence : List[str, str, dict]
+            If not None, apply the given sequence of FFmpeg filters to each
+            ndimage. Check the (module-level) plugin docs for details and
+            examples.
+        filter_graph : (dict, List)
+            If not None, apply the given graph of FFmpeg filters to each
+            ndimage. The graph is given as a tuple of two dicts. The first dict
+            contains a (named) set of nodes, and the second dict contains a set
+            of edges between nodes of the previous dict. Check the (module-level)
+            plugin docs for details and examples.
+        constant_framerate : bool
+            If True assume the video's framerate is constant. This allows for
+            faster seeking inside the file. If False, the video is reset before
+            each read and searched from the beginning. If None (default), this
+            value will be read from the container format.
+        thread_count : int
+            How many threads to use when decoding a frame. The default is 0,
+            which will set the number using ffmpeg's default, which is based on
+            the codec, number of available cores, threadding model, and other
+            considerations.
+        thread_type : str
+            The threading model to be used. One of
+
+            - `"SLICE"`: threads assemble parts of the current frame
+            - `"FRAME"`: threads may assemble future frames
+            - None (default): Uses ``"FRAME"`` if ``index=...`` and ffmpeg's
+              default otherwise.
+
+
+        Returns
+        -------
+        frame : np.ndarray
+            A numpy array containing loaded frame data.
+
+        Notes
+        -----
+        Accessing random frames repeatedly is costly (O(k), where k is the
+        average distance between two keyframes). You should do so only sparingly
+        if possible. In some cases, it can be faster to bulk-read the video (if
+        it fits into memory) and to then access the returned ndarray randomly.
+
+        The current implementation may cause problems for b-frames, i.e.,
+        bidirectionaly predicted pictures. I lack test videos to write unit
+        tests for this case.
+
+        Reading from an index other than ``...``, i.e. reading a single frame,
+        currently doesn't support filters that introduce delays.
+
+        """
+
+        if index is ...:
+            props = self.properties(format=format)
+            uses_filter = (
+                self._video_filter is not None
+                or filter_graph is not None
+                or filter_sequence is not None
+            )
+
+            self._container.seek(0)
+            if not uses_filter and props.shape[0] != 0:
+                frames = np.empty(props.shape, dtype=props.dtype)
+                for idx, frame in enumerate(
+                    self.iter(
+                        format=format,
+                        filter_sequence=filter_sequence,
+                        filter_graph=filter_graph,
+                        thread_count=thread_count,
+                        thread_type=thread_type or "FRAME",
+                    )
+                ):
+                    frames[idx] = frame
+            else:
+                frames = np.stack(
+                    [
+                        x
+                        for x in self.iter(
+                            format=format,
+                            filter_sequence=filter_sequence,
+                            filter_graph=filter_graph,
+                            thread_count=thread_count,
+                            thread_type=thread_type or "FRAME",
+                        )
+                    ]
+                )
+
+            # reset stream container, because threading model can't change after
+            # first access
+            self._video_stream.close()
+            self._video_stream = self._container.streams.video[0]
+
+            return frames
+
+        if thread_type is not None and thread_type != self._video_stream.thread_type:
+            self._video_stream.thread_type = thread_type
+        if (
+            thread_count != 0
+            and thread_count != self._video_stream.codec_context.thread_count
+        ):
+            # in FFMPEG thread_count == 0 means use the default count, which we
+            # change to mean don't change the thread count.
+            self._video_stream.codec_context.thread_count = thread_count
+
+        if constant_framerate is None:
+            constant_framerate = not self._container.format.variable_fps
+
+        # note: cheap for contigous incremental reads
+        self._seek(index, constant_framerate=constant_framerate)
+        desired_frame = next(self._decoder)
+        self._next_idx += 1
+
+        self.set_video_filter(filter_sequence, filter_graph)
+        if self._video_filter is not None:
+            desired_frame = self._video_filter.send(desired_frame)
+
+        return self._unpack_frame(desired_frame, format=format)
+
+    def iter(
+        self,
+        *,
+        format: str = "rgb24",
+        filter_sequence: List[Tuple[str, Union[str, dict]]] = None,
+        filter_graph: Tuple[dict, List] = None,
+        thread_count: int = 0,
+        thread_type: str = None,
+    ) -> np.ndarray:
+        """Yield frames from the video.
+
+        Parameters
+        ----------
+        frame : np.ndarray
+            A numpy array containing loaded frame data.
+        format : str
+            Convert the data into the given format before returning it. If None,
+            return the data in the encoded format if it can be expressed as a
+            strided array; otherwise raise an Exception.
+        filter_sequence : List[str, str, dict]
+            Set the returned colorspace. If not None (default: rgb24), convert
+            the data into the given format before returning it. If ``None``
+            return the data in the encoded format if it can be expressed as a
+            strided array; otherwise raise an Exception.
+        filter_graph : (dict, List)
+            If not None, apply the given graph of FFmpeg filters to each
+            ndimage. The graph is given as a tuple of two dicts. The first dict
+            contains a (named) set of nodes, and the second dict contains a set
+            of edges between nodes of the previous dict. Check the (module-level)
+            plugin docs for details and examples.
+        thread_count : int
+            How many threads to use when decoding a frame. The default is 0,
+            which will set the number using ffmpeg's default, which is based on
+            the codec, number of available cores, threadding model, and other
+            considerations.
+        thread_type : str
+            The threading model to be used. One of
+
+            - `"SLICE"` (default): threads assemble parts of the current frame
+            - `"FRAME"`: threads may assemble future frames (faster for bulk reading)
+
+
+        Yields
+        ------
+        frame : np.ndarray
+            A (decoded) video frame.
+
+
+        """
+
+        self._video_stream.thread_type = thread_type or "SLICE"
+        self._video_stream.codec_context.thread_count = thread_count
+
+        self.set_video_filter(filter_sequence, filter_graph)
+
+        for frame in self._decoder:
+            self._next_idx += 1
+
+            if self._video_filter is not None:
+                try:
+                    frame = self._video_filter.send(frame)
+                except StopIteration:
+                    break
+
+            if frame is None:
+                continue
+
+            yield self._unpack_frame(frame, format=format)
+
+        if self._video_filter is not None:
+            for frame in self._video_filter:
+                yield self._unpack_frame(frame, format=format)
+
+    def write(
+        self,
+        ndimage: Union[np.ndarray, List[np.ndarray]],
+        *,
+        codec: str = None,
+        is_batch: bool = True,
+        fps: int = 24,
+        in_pixel_format: str = "rgb24",
+        out_pixel_format: str = None,
+        filter_sequence: List[Tuple[str, Union[str, dict]]] = None,
+        filter_graph: Tuple[dict, List] = None,
+    ) -> Optional[bytes]:
+        """Save a ndimage as a video.
+
+        Given a batch of frames (stacked along the first axis) or a list of
+        frames, encode them and add the result to the ImageResource.
+
+        Parameters
+        ----------
+        ndimage : ArrayLike, List[ArrayLike]
+            The ndimage to encode and write to the ImageResource.
+        codec : str
+            The codec to use when encoding frames. Only needed on first write
+            and ignored on subsequent writes.
+        is_batch : bool
+            If True (default), the ndimage is a batch of images, otherwise it is
+            a single image. This parameter has no effect on lists of ndimages.
+        fps : str
+            The resulting videos frames per second.
+        in_pixel_format : str
+            The pixel format of the incoming ndarray. Defaults to "rgb24" and can
+            be any stridable pix_fmt supported by FFmpeg.
+        out_pixel_format : str
+            The pixel format to use while encoding frames. If None (default)
+            use the codec's default.
+        filter_sequence : List[str, str, dict]
+            If not None, apply the given sequence of FFmpeg filters to each
+            ndimage. Check the (module-level) plugin docs for details and
+            examples.
+        filter_graph : (dict, List)
+            If not None, apply the given graph of FFmpeg filters to each
+            ndimage. The graph is given as a tuple of two dicts. The first dict
+            contains a (named) set of nodes, and the second dict contains a set
+            of edges between nodes of the previous dict. Check the (module-level)
+            plugin docs for details and examples.
+
+        Returns
+        -------
+        encoded_image : bytes or None
+            If the chosen ImageResource is the special target ``"<bytes>"`` then
+            write will return a byte string containing the encoded image data.
+            Otherwise, it returns None.
+
+        Notes
+        -----
+        When writing ``<bytes>``, the video is finalized immediately after the
+        first write call and calling write multiple times to append frames is
+        not possible.
+
+        """
+
+        if isinstance(ndimage, list):
+            # frames shapes must agree for video
+            if any(f.shape != ndimage[0].shape for f in ndimage):
+                raise ValueError("All frames should have the same shape")
+        elif not is_batch:
+            ndimage = np.asarray(ndimage)[None, ...]
+        else:
+            ndimage = np.asarray(ndimage)
+
+        if self._video_stream is None:
+            self.init_video_stream(codec, fps=fps, pixel_format=out_pixel_format)
+
+        self.set_video_filter(filter_sequence, filter_graph)
+
+        for img in ndimage:
+            self.write_frame(img, pixel_format=in_pixel_format)
+
+        if self.request._uri_type == URI_BYTES:
+            # bytes are immutuable, so we have to flush immediately
+            # and can't support appending
+            self._flush_writer()
+            self._container.close()
+
+            return self.request.get_file().getvalue()
+
+    def properties(self, index: int = ..., *, format: str = "rgb24") -> ImageProperties:
+        """Standardized ndimage metadata.
+
+        Parameters
+        ----------
+        index : int
+            The index of the ndimage for which to return properties. If ``...``
+            (Ellipsis, default), return the properties for the resulting batch
+            of frames.
+        format : str
+            If not None (default: rgb24), convert the data into the given format
+            before returning it. If None return the data in the encoded format
+            if that can be expressed as a strided array; otherwise raise an
+            Exception.
+
+        Returns
+        -------
+        properties : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        Notes
+        -----
+        This function is efficient and won't process any pixel data.
+
+        The provided metadata does not include modifications by any filters
+        (through ``filter_sequence`` or ``filter_graph``).
+
+        """
+
+        video_width = self._video_stream.codec_context.width
+        video_height = self._video_stream.codec_context.height
+        pix_format = format or self._video_stream.codec_context.pix_fmt
+        frame_template = av.VideoFrame(video_width, video_height, pix_format)
+
+        shape = _get_frame_shape(frame_template)
+        if index is ...:
+            n_frames = self._video_stream.frames
+            shape = (n_frames,) + shape
+
+        return ImageProperties(
+            shape=tuple(shape),
+            dtype=_format_to_dtype(frame_template.format),
+            n_images=shape[0] if index is ... else None,
+            is_batch=index is ...,
+        )
+
+    def metadata(
+        self,
+        index: int = ...,
+        exclude_applied: bool = True,
+        constant_framerate: bool = None,
+    ) -> Dict[str, Any]:
+        """Format-specific metadata.
+
+        Returns a dictionary filled with metadata that is either stored in the
+        container, the video stream, or the frame's side-data.
+
+        Parameters
+        ----------
+        index : int
+            If ... (Ellipsis, default) return global metadata (the metadata
+            stored in the container and video stream). If not ..., return the
+            side data stored in the frame at the given index.
+        exclude_applied : bool
+            Currently, this parameter has no effect. It exists for compliance with
+            the ImageIO v3 API.
+        constant_framerate : bool
+            If True assume the video's framerate is constant. This allows for
+            faster seeking inside the file. If False, the video is reset before
+            each read and searched from the beginning. If None (default), this
+            value will be read from the container format.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary filled with format-specific metadata fields and their
+            values.
+
+        """
+
+        metadata = dict()
+
+        if index is ...:
+            # useful flags defined on the container and/or video stream
+            metadata.update(
+                {
+                    "video_format": self._video_stream.codec_context.pix_fmt,
+                    "codec": self._video_stream.codec.name,
+                    "long_codec": self._video_stream.codec.long_name,
+                    "profile": self._video_stream.profile,
+                    "fps": float(self._video_stream.guessed_rate),
+                }
+            )
+            if self._video_stream.duration is not None:
+                duration = float(
+                    self._video_stream.duration * self._video_stream.time_base
+                )
+                metadata.update({"duration": duration})
+
+            metadata.update(self.container_metadata)
+            metadata.update(self.video_stream_metadata)
+            return metadata
+
+        if constant_framerate is None:
+            constant_framerate = not self._container.format.variable_fps
+
+        self._seek(index, constant_framerate=constant_framerate)
+        desired_frame = next(self._decoder)
+        self._next_idx += 1
+
+        # useful flags defined on the frame
+        metadata.update(
+            {
+                "key_frame": bool(desired_frame.key_frame),
+                "time": desired_frame.time,
+                "interlaced_frame": bool(desired_frame.interlaced_frame),
+                "frame_type": desired_frame.pict_type.name,
+            }
+        )
+
+        # side data
+        metadata.update(
+            {item.type.name: bytes(item) for item in desired_frame.side_data}
+        )
+
+        return metadata
+
+    def close(self) -> None:
+        """Close the Video."""
+
+        is_write = self.request.mode.io_mode == IOMode.write
+        if is_write and self._video_stream is not None:
+            self._flush_writer()
+
+        if self._video_stream is not None:
+            try:
+                self._video_stream.close()
+            except ValueError:
+                pass  # stream already closed
+
+        if self._container is not None:
+            self._container.close()
+
+        self.request.finish()
+
+    def __enter__(self) -> "PyAVPlugin":
+        return super().__enter__()
+
+    # ------------------------------
+    # Add-on Interface inside imopen
+    # ------------------------------
+
+    def init_video_stream(
+        self,
+        codec: str,
+        *,
+        fps: float = 24,
+        pixel_format: str = None,
+        max_keyframe_interval: int = None,
+        force_keyframes: bool = None,
+    ) -> None:
+        """Initialize a new video stream.
+
+        This function adds a new video stream to the ImageResource using the
+        selected encoder (codec), framerate, and colorspace.
+
+        Parameters
+        ----------
+        codec : str
+            The codec to use, e.g. ``"libx264"`` or ``"vp9"``.
+        fps : float
+            The desired framerate of the video stream (frames per second).
+        pixel_format : str
+            The pixel format to use while encoding frames. If None (default) use
+            the codec's default.
+        max_keyframe_interval : int
+            The maximum distance between two intra frames (I-frames). Also known
+            as GOP size. If unspecified use the codec's default. Note that not
+            every I-frame is a keyframe; see the notes for details.
+        force_keyframes : bool
+            If True, limit inter frames dependency to frames within the current
+            keyframe interval (GOP), i.e., force every I-frame to be a keyframe.
+            If unspecified, use the codec's default.
+
+        Notes
+        -----
+        You can usually leave ``max_keyframe_interval`` and ``force_keyframes``
+        at their default values, unless you try to generate seek-optimized video
+        or have a similar specialist use-case. In this case, ``force_keyframes``
+        controls the ability to seek to _every_ I-frame, and
+        ``max_keyframe_interval`` controls how close to a random frame you can
+        seek. Low values allow more fine-grained seek at the expense of
+        file-size (and thus I/O performance).
+
+        """
+
+        fps = Fraction.from_float(fps)
+        stream = self._container.add_stream(codec, fps)
+        stream.time_base = Fraction(1 / fps).limit_denominator(int(2**16 - 1))
+        if pixel_format is not None:
+            stream.pix_fmt = pixel_format
+        if max_keyframe_interval is not None:
+            stream.gop_size = max_keyframe_interval
+        if force_keyframes is not None:
+            stream.closed_gop = force_keyframes
+
+        self._video_stream = stream
+
+    def write_frame(self, frame: np.ndarray, *, pixel_format: str = "rgb24") -> None:
+        """Add a frame to the video stream.
+
+        This function appends a new frame to the video. It assumes that the
+        stream previously has been initialized. I.e., ``init_video_stream`` has
+        to be called before calling this function for the write to succeed.
+
+        Parameters
+        ----------
+        frame : np.ndarray
+            The image to be appended/written to the video stream.
+        pixel_format : str
+            The colorspace (pixel format) of the incoming frame.
+
+        Notes
+        -----
+        Frames may be held in a buffer, e.g., by the filter pipeline used during
+        writing or by FFMPEG to batch them prior to encoding. Make sure to
+        ``.close()`` the plugin or to use a context manager to ensure that all
+        frames are written to the ImageResource.
+
+        """
+
+        # manual packing of ndarray into frame
+        # (this should live in pyAV, but it doesn't support all the formats we
+        # want and PRs there are slow)
+        pixel_format = av.VideoFormat(pixel_format)
+        img_dtype = _format_to_dtype(pixel_format)
+        width = frame.shape[2 if pixel_format.is_planar else 1]
+        height = frame.shape[1 if pixel_format.is_planar else 0]
+        av_frame = av.VideoFrame(width, height, pixel_format.name)
+        if pixel_format.is_planar:
+            for idx, plane in enumerate(av_frame.planes):
+                plane_array = np.frombuffer(plane, dtype=img_dtype)
+                plane_array = as_strided(
+                    plane_array,
+                    shape=(plane.height, plane.width),
+                    strides=(plane.line_size, img_dtype.itemsize),
+                )
+                plane_array[...] = frame[idx]
+        else:
+            if pixel_format.name.startswith("bayer_"):
+                # ffmpeg doesn't describe bayer formats correctly
+                # see https://github.com/imageio/imageio/issues/761#issuecomment-1059318851
+                # and following for details.
+                n_channels = 1
+            else:
+                n_channels = len(pixel_format.components)
+
+            plane = av_frame.planes[0]
+            plane_shape = (plane.height, plane.width)
+            plane_strides = (plane.line_size, n_channels * img_dtype.itemsize)
+            if n_channels > 1:
+                plane_shape += (n_channels,)
+                plane_strides += (img_dtype.itemsize,)
+
+            plane_array = as_strided(
+                np.frombuffer(plane, dtype=img_dtype),
+                shape=plane_shape,
+                strides=plane_strides,
+            )
+            plane_array[...] = frame
+
+        stream = self._video_stream
+        av_frame.time_base = stream.codec_context.time_base
+        av_frame.pts = self.frames_written
+        self.frames_written += 1
+
+        if self._video_filter is not None:
+            av_frame = self._video_filter.send(av_frame)
+            if av_frame is None:
+                return
+
+        if stream.frames == 0:
+            stream.width = av_frame.width
+            stream.height = av_frame.height
+
+        for packet in stream.encode(av_frame):
+            self._container.mux(packet)
+
+    def set_video_filter(
+        self,
+        filter_sequence: List[Tuple[str, Union[str, dict]]] = None,
+        filter_graph: Tuple[dict, List] = None,
+    ) -> None:
+        """Set the filter(s) to use.
+
+        This function creates a new FFMPEG filter graph to use when reading or
+        writing video. In the case of reading, frames are passed through the
+        filter graph before begin returned and, in case of writing, frames are
+        passed through the filter before being written to the video.
+
+        Parameters
+        ----------
+        filter_sequence : List[str, str, dict]
+            If not None, apply the given sequence of FFmpeg filters to each
+            ndimage. Check the (module-level) plugin docs for details and
+            examples.
+        filter_graph : (dict, List)
+            If not None, apply the given graph of FFmpeg filters to each
+            ndimage. The graph is given as a tuple of two dicts. The first dict
+            contains a (named) set of nodes, and the second dict contains a set
+            of edges between nodes of the previous dict. Check the
+            (module-level) plugin docs for details and examples.
+
+        Notes
+        -----
+        Changing a filter graph with lag during reading or writing will
+        currently cause frames in the filter queue to be lost.
+
+        """
+
+        if filter_sequence is None and filter_graph is None:
+            self._video_filter = None
+            return
+
+        if filter_sequence is None:
+            filter_sequence = list()
+
+        node_descriptors: Dict[str, Tuple[str, Union[str, Dict]]]
+        edges: List[Tuple[str, str, int, int]]
+        if filter_graph is None:
+            node_descriptors, edges = dict(), [("video_in", "video_out", 0, 0)]
+        else:
+            node_descriptors, edges = filter_graph
+
+        graph = av.filter.Graph()
+
+        previous_node = graph.add_buffer(template=self._video_stream)
+        for filter_name, argument in filter_sequence:
+            if isinstance(argument, str):
+                current_node = graph.add(filter_name, argument)
+            else:
+                current_node = graph.add(filter_name, **argument)
+            previous_node.link_to(current_node)
+            previous_node = current_node
+
+        nodes = dict()
+        nodes["video_in"] = previous_node
+        nodes["video_out"] = graph.add("buffersink")
+        for name, (filter_name, arguments) in node_descriptors.items():
+            if isinstance(arguments, str):
+                nodes[name] = graph.add(filter_name, arguments)
+            else:
+                nodes[name] = graph.add(filter_name, **arguments)
+
+        for from_note, to_node, out_idx, in_idx in edges:
+            nodes[from_note].link_to(nodes[to_node], out_idx, in_idx)
+
+        graph.configure()
+
+        def video_filter():
+            # this starts a co-routine
+            # send frames using graph.send()
+            frame = yield None
+
+            # send and receive frames in "parallel"
+            while frame is not None:
+                graph.push(frame)
+                try:
+                    frame = yield graph.pull()
+                except av.error.BlockingIOError:
+                    # filter has lag and needs more frames
+                    frame = yield None
+                except av.error.EOFError:
+                    break
+
+            try:
+                # send EOF in av>=9.0
+                graph.push(None)
+            except ValueError:  # pragma: no cover
+                # handle av<9.0
+                pass
+
+            # all frames have been sent, empty the filter
+            while True:
+                try:
+                    yield graph.pull()
+                except av.error.EOFError:
+                    break  # EOF
+                except av.error.BlockingIOError:  # pragma: no cover
+                    # handle av<9.0
+                    break
+
+        self._video_filter = video_filter()
+        self._video_filter.send(None)
+
+    @property
+    def container_metadata(self):
+        """Container-specific metadata.
+
+        A dictionary containing metadata stored at the container level.
+
+        """
+        return self._container.metadata
+
+    @property
+    def video_stream_metadata(self):
+        """Stream-specific metadata.
+
+        A dictionary containing metadata stored at the stream level.
+
+        """
+        return self._video_stream.metadata
+
+    # -------------------------------
+    # Internals and private functions
+    # -------------------------------
+
+    def _unpack_frame(self, frame: av.VideoFrame, *, format: str = None) -> np.ndarray:
+        """Convert a av.VideoFrame into a ndarray
+
+        Parameters
+        ----------
+        frame : av.VideoFrame
+            The frame to unpack.
+        format : str
+            If not None, convert the frame to the given format before unpacking.
+
+        """
+
+        if format is not None:
+            frame = frame.reformat(format=format)
+
+        dtype = _format_to_dtype(frame.format)
+        shape = _get_frame_shape(frame)
+
+        planes = list()
+        for idx in range(len(frame.planes)):
+            n_channels = sum(
+                [
+                    x.bits // (dtype.itemsize * 8)
+                    for x in frame.format.components
+                    if x.plane == idx
+                ]
+            )
+            av_plane = frame.planes[idx]
+            plane_shape = (av_plane.height, av_plane.width)
+            plane_strides = (av_plane.line_size, n_channels * dtype.itemsize)
+            if n_channels > 1:
+                plane_shape += (n_channels,)
+                plane_strides += (dtype.itemsize,)
+
+            np_plane = as_strided(
+                np.frombuffer(av_plane, dtype=dtype),
+                shape=plane_shape,
+                strides=plane_strides,
+            )
+            planes.append(np_plane)
+
+        if len(planes) > 1:
+            # Note: the planes *should* exist inside a contigous memory block
+            # somewhere inside av.Frame however pyAV does not appear to expose this,
+            # so we are forced to copy the planes individually instead of wrapping
+            # them :(
+            out = np.concatenate(planes).reshape(shape)
+        else:
+            out = planes[0]
+
+        return out
+
+    def _seek(self, index, *, constant_framerate: bool = True) -> Generator:
+        """Seeks to the frame at the given index."""
+
+        if index == self._next_idx:
+            return  # fast path :)
+
+        # we must decode at least once before we seek otherwise the
+        # returned frames become corrupt.
+        if self._next_idx == 0:
+            next(self._decoder)
+            self._next_idx += 1
+
+            if index == self._next_idx:
+                return  # fast path :)
+
+        # remove this branch until I find a way to efficiently find the next
+        # keyframe. keeping this as a reminder
+        # if self._next_idx < index and index < self._next_keyframe_idx:
+        #     frames_to_yield = index - self._next_idx
+        if not constant_framerate and index > self._next_idx:
+            frames_to_yield = index - self._next_idx
+        elif not constant_framerate:
+            # seek backwards and can't link idx and pts
+            self._container.seek(0)
+            self._decoder = self._container.decode(video=0)
+            self._next_idx = 0
+
+            frames_to_yield = index
+        else:
+            # we know that the time between consecutive frames is constant
+            # hence we can link index and pts
+
+            # how many pts lie between two frames
+            sec_delta = 1 / self._video_stream.guessed_rate
+            pts_delta = sec_delta / self._video_stream.time_base
+
+            index_pts = int(index * pts_delta)
+
+            # this only seeks to the closed (preceeding) keyframe
+            self._container.seek(index_pts, stream=self._video_stream)
+            self._decoder = self._container.decode(video=0)
+
+            # this may be made faster if we could get the keyframe's time without
+            # decoding it
+            keyframe = next(self._decoder)
+            keyframe_time = keyframe.pts * keyframe.time_base
+            keyframe_pts = int(keyframe_time / self._video_stream.time_base)
+            keyframe_index = keyframe_pts // pts_delta
+
+            self._container.seek(index_pts, stream=self._video_stream)
+            self._next_idx = keyframe_index
+
+            frames_to_yield = index - keyframe_index
+
+        for _ in range(frames_to_yield):
+            next(self._decoder)
+            self._next_idx += 1
+
+    def _flush_writer(self):
+        """Flush the filter and encoder
+
+        This will reset the filter to `None` and send EoF to the encoder,
+        i.e., after calling, no more frames may be written.
+
+        """
+
+        stream = self._video_stream
+
+        if self._video_filter is not None:
+            # flush encoder
+            for av_frame in self._video_filter:
+                if stream.frames == 0:
+                    stream.width = av_frame.width
+                    stream.height = av_frame.height
+                for packet in stream.encode(av_frame):
+                    self._container.mux(packet)
+            self._video_filter = None
+
+        # flush stream
+        for packet in stream.encode():
+            self._container.mux(packet)
+        self._video_stream = None

evalkit_tf446/lib/python3.10/site-packages/imageio/plugins/rawpy.py

@@ -0,0 +1,191 @@
+""" Read/Write images using rawpy.
+
+rawpy is an easy-to-use Python wrapper for the LibRaw library.
+It also contains some extra functionality for finding and repairing hot/dead pixels.
+"""
+
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+import rawpy
+import numpy as np
+
+from ..core.request import URI_BYTES, InitializationError, IOMode, Request
+from ..core.v3_plugin_api import ImageProperties, PluginV3
+from ..typing import ArrayLike
+
+
+class RawPyPlugin(PluginV3):
+    """A class representing the rawpy plugin.
+
+    Methods
+    -------
+
+    .. autosummary::
+    :toctree: _plugins/rawpy
+
+    RawPyPlugin.read
+    """
+
+    def __init__(self, request: Request) -> None:
+        """Instantiates a new rawpy plugin object
+
+        Parameters
+        ----------
+        request: Request
+            A request object representing the resource to be operated on.
+        """
+
+        super().__init__(request)
+
+        self._image_file = None
+
+        if request.mode.io_mode == IOMode.read:
+            try:
+                self._image_file = rawpy.imread(request.get_file())
+            except (
+                rawpy.NotSupportedError,
+                rawpy.LibRawFileUnsupportedError,
+                rawpy.LibRawIOError,
+            ):
+                if request._uri_type == URI_BYTES:
+                    raise InitializationError(
+                        "RawPy can not read the provided bytes."
+                    ) from None
+                else:
+                    raise InitializationError(
+                        f"RawPy can not read {request.raw_uri}."
+                    ) from None
+        elif request.mode.io_mode == IOMode.write:
+            raise InitializationError("RawPy does not support writing.") from None
+
+    def close(self) -> None:
+        if self._image_file:
+            self._image_file.close()
+
+        self._request.finish()
+
+    def read(self, *, index: int = 0, **kwargs) -> np.ndarray:
+        """Read Raw Image.
+
+        Returns
+        -------
+        nd_image: ndarray
+            The image data
+        """
+
+        nd_image: np.ndarray
+
+        try:
+            nd_image = self._image_file.postprocess(**kwargs)
+        except Exception:
+            pass
+
+        if index is Ellipsis:
+            nd_image = nd_image[None, ...]
+
+        return nd_image
+
+    def write(self, ndimage: Union[ArrayLike, List[ArrayLike]]) -> Optional[bytes]:
+        """RawPy does not support writing."""
+        raise NotImplementedError()
+
+    def iter(self) -> Iterator[np.ndarray]:
+        """Load the image.
+
+        Returns
+        -------
+        nd_image: ndarray
+            The image data
+        """
+
+        try:
+            yield self.read()
+        except Exception:
+            pass
+
+    def metadata(
+        self, index: int = None, exclude_applied: bool = True
+    ) -> Dict[str, Any]:
+        """Read ndimage metadata.
+
+        Parameters
+        ----------
+        exclude_applied : bool
+            If True, exclude metadata fields that are applied to the image while
+            reading. For example, if the binary data contains a rotation flag,
+            the image is rotated by default and the rotation flag is excluded
+            from the metadata to avoid confusion.
+
+        Returns
+        -------
+        metadata : dict
+            A dictionary of format-specific metadata.
+
+        """
+
+        metadata = {}
+
+        image_size = self._image_file.sizes
+
+        metadata["black_level_per_channel"] = self._image_file.black_level_per_channel
+        metadata["camera_white_level_per_channel"] = (
+            self._image_file.camera_white_level_per_channel
+        )
+        metadata["color_desc"] = self._image_file.color_desc
+        metadata["color_matrix"] = self._image_file.color_matrix
+        metadata["daylight_whitebalance"] = self._image_file.daylight_whitebalance
+        metadata["dtype"] = self._image_file.raw_image.dtype
+        metadata["flip"] = image_size.flip
+        metadata["num_colors"] = self._image_file.num_colors
+        metadata["tone_curve"] = self._image_file.tone_curve
+        metadata["width"] = image_size.width
+        metadata["height"] = image_size.height
+        metadata["raw_width"] = image_size.raw_width
+        metadata["raw_height"] = image_size.raw_height
+        metadata["raw_shape"] = self._image_file.raw_image.shape
+        metadata["iwidth"] = image_size.iwidth
+        metadata["iheight"] = image_size.iheight
+        metadata["pixel_aspect"] = image_size.pixel_aspect
+        metadata["white_level"] = self._image_file.white_level
+
+        if exclude_applied:
+            metadata.pop("black_level_per_channel", None)
+            metadata.pop("camera_white_level_per_channel", None)
+            metadata.pop("color_desc", None)
+            metadata.pop("color_matrix", None)
+            metadata.pop("daylight_whitebalance", None)
+            metadata.pop("dtype", None)
+            metadata.pop("flip", None)
+            metadata.pop("num_colors", None)
+            metadata.pop("tone_curve", None)
+            metadata.pop("raw_width", None)
+            metadata.pop("raw_height", None)
+            metadata.pop("raw_shape", None)
+            metadata.pop("iwidth", None)
+            metadata.pop("iheight", None)
+            metadata.pop("white_level", None)
+
+        return metadata
+
+    def properties(self, index: int = None) -> ImageProperties:
+        """Standardized ndimage metadata
+
+        Returns
+        -------
+        properties : ImageProperties
+            A dataclass filled with standardized image metadata.
+
+        Notes
+        -----
+        This does not decode pixel data and is fast for large images.
+
+        """
+
+        ImageSize = self._image_file.sizes
+
+        width: int = ImageSize.width
+        height: int = ImageSize.height
+        shape: Tuple[int, ...] = (height, width)
+
+        dtype = self._image_file.raw_image.dtype
+
+        return ImageProperties(shape=shape, dtype=dtype)

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

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

evalkit_tf446/lib/python3.10/site-packages/imageio/testing.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+""" Functionality used for testing. This code itself is not covered in tests.
+"""
+
+import os
+import sys
+import pytest
+
+# Get root dir
+THIS_DIR = os.path.abspath(os.path.dirname(__file__))
+ROOT_DIR = THIS_DIR
+for i in range(9):
+    ROOT_DIR = os.path.dirname(ROOT_DIR)
+    if os.path.isfile(os.path.join(ROOT_DIR, ".gitignore")):
+        break
+
+
+# Functions to use from invoke tasks
+
+
+def test_unit(cov_report="term"):
+    """Run all unit tests. Returns exit code."""
+    orig_dir = os.getcwd()
+    os.chdir(ROOT_DIR)
+    try:
+        _clear_imageio()
+        _enable_faulthandler()
+        return pytest.main(
+            [
+                "-v",
+                "--cov",
+                "imageio",
+                "--cov-config",
+                ".coveragerc",
+                "--cov-report",
+                cov_report,
+                "tests",
+            ]
+        )
+    finally:
+        os.chdir(orig_dir)
+        import imageio
+
+        print("Tests were performed on", str(imageio))
+
+
+# Requirements
+
+
+def _enable_faulthandler():
+    """Enable faulthandler (if we can), so that we get tracebacks
+    on segfaults.
+    """
+    try:
+        import faulthandler
+
+        faulthandler.enable()
+        print("Faulthandler enabled")
+    except Exception:
+        print("Could not enable faulthandler")
+
+
+def _clear_imageio():
+    # Remove ourselves from sys.modules to force an import
+    for key in list(sys.modules.keys()):
+        if key.startswith("imageio"):
+            del sys.modules[key]

evalkit_tf446/lib/python3.10/site-packages/imageio/typing.py

@@ -0,0 +1,17 @@
+from io import BytesIO
+from typing import Union, BinaryIO
+from pathlib import Path
+
+try:
+    from numpy.typing import ArrayLike
+except ImportError:
+    # numpy<1.20 fall back to using ndarray
+    from numpy import ndarray as ArrayLike
+
+ImageResource = Union[str, bytes, BytesIO, Path, BinaryIO]
+
+
+__all__ = [
+    "ArrayLike",
+    "ImageResource",
+]

evalkit_tf446/lib/python3.10/site-packages/imageio/v2.py

@@ -0,0 +1,676 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+import re
+import warnings
+from numbers import Number
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+
+from imageio.core.legacy_plugin_wrapper import LegacyPlugin
+from imageio.core.util import Array
+from imageio.core.v3_plugin_api import PluginV3
+
+from . import formats
+from .config import known_extensions, known_plugins
+from .core import RETURN_BYTES
+from .core.imopen import imopen
+
+MEMTEST_DEFAULT_MIM = "256MB"
+MEMTEST_DEFAULT_MVOL = "1GB"
+
+
+mem_re = re.compile(r"^(\d+\.?\d*)\s*([kKMGTPEZY]?i?)B?$")
+sizes = {"": 1, None: 1}
+for i, si in enumerate([""] + list("kMGTPEZY")):
+    sizes[si] = 1000**i
+    if si:
+        sizes[si.upper() + "i"] = 1024**i
+
+
+def to_nbytes(arg, default=None):
+    if not arg:
+        arg = float("inf")
+
+    if arg is True:
+        arg = default
+
+    if isinstance(arg, Number):
+        return arg
+
+    match = mem_re.match(arg)
+    if match is None:
+        raise ValueError(
+            "Memory size could not be parsed "
+            "(is your capitalisation correct?): {}".format(arg)
+        )
+
+    num, unit = match.groups()
+
+    try:
+        return float(num) * sizes[unit]
+    except KeyError:  # pragma: no cover
+        # Note: I don't think we can reach this
+        raise ValueError(
+            "Memory size unit not recognised "
+            "(is your capitalisation correct?): {}".format(unit)
+        )
+
+
+def help(name=None):
+    """help(name=None)
+
+    Print the documentation of the format specified by name, or a list
+    of supported formats if name is omitted.
+
+    Parameters
+    ----------
+    name : str
+        Can be the name of a format, a filename extension, or a full
+        filename. See also the :doc:`formats page <../formats/index>`.
+    """
+    if not name:
+        print(formats)
+    else:
+        print(formats[name])
+
+
+def decypher_format_arg(format_name: str) -> Dict[str, str]:
+    """Split format into plugin and format
+
+    The V2 API aliases plugins and supported formats. This function
+    splits these so that they can be fed separately to `iio.imopen`.
+
+    """
+
+    plugin = None
+    extension = None
+
+    if format_name is None:
+        pass  # nothing to do
+    elif Path(format_name).suffix.lower() in known_extensions:
+        extension = Path(format_name).suffix.lower()
+    elif format_name in known_plugins:
+        plugin = format_name
+    elif format_name.upper() in known_plugins:
+        plugin = format_name.upper()
+    elif format_name.lower() in known_extensions:
+        extension = format_name.lower()
+    elif "." + format_name.lower() in known_extensions:
+        extension = "." + format_name.lower()
+    else:
+        raise IndexError(f"No format known by name `{plugin}`.")
+
+    return {"plugin": plugin, "extension": extension}
+
+
+class LegacyReader:
+    def __init__(self, plugin_instance: PluginV3, **kwargs):
+        self.instance = plugin_instance
+        self.last_index = 0
+        self.closed = False
+
+        if (
+            type(self.instance).__name__ == "PillowPlugin"
+            and kwargs.get("pilmode") is not None
+        ):
+            kwargs["mode"] = kwargs["pilmode"]
+            del kwargs["pilmode"]
+
+        self.read_args = kwargs
+
+    def close(self):
+        if not self.closed:
+            self.instance.close()
+        self.closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+    @property
+    def request(self):
+        return self.instance.request
+
+    @property
+    def format(self):
+        raise TypeError("V3 Plugins don't have a format.")
+
+    def get_length(self):
+        return self.instance.properties(index=...).n_images
+
+    def get_data(self, index):
+        self.last_index = index
+        img = self.instance.read(index=index, **self.read_args)
+        metadata = self.instance.metadata(index=index, exclude_applied=False)
+        return Array(img, metadata)
+
+    def get_next_data(self):
+        return self.get_data(self.last_index + 1)
+
+    def set_image_index(self, index):
+        self.last_index = index - 1
+
+    def get_meta_data(self, index=None):
+        return self.instance.metadata(index=index, exclude_applied=False)
+
+    def iter_data(self):
+        for idx, img in enumerate(self.instance.iter()):
+            metadata = self.instance.metadata(index=idx, exclude_applied=False)
+            yield Array(img, metadata)
+
+    def __iter__(self):
+        return self.iter_data()
+
+    def __len__(self):
+        return self.get_length()
+
+
+class LegacyWriter:
+    def __init__(self, plugin_instance: PluginV3, **kwargs):
+        self.instance = plugin_instance
+        self.last_index = 0
+        self.closed = False
+
+        if type(self.instance).__name__ == "PillowPlugin" and "pilmode" in kwargs:
+            kwargs["mode"] = kwargs["pilmode"]
+            del kwargs["pilmode"]
+
+        self.write_args = kwargs
+
+    def close(self):
+        if not self.closed:
+            self.instance.close()
+        self.closed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+    @property
+    def request(self):
+        return self.instance.request
+
+    @property
+    def format(self):
+        raise TypeError("V3 Plugins don't have a format.")
+
+    def append_data(self, im, meta=None):
+        # TODO: write metadata in the future; there is currently no
+        # generic way to do this with v3 plugins :(
+        if meta is not None:
+            warnings.warn(
+                "V3 Plugins currently don't have a uniform way to"
+                " write metadata, so any metadata is ignored."
+            )
+
+        # total_meta = dict()
+        # if meta is None:
+        #     meta = {}
+        # if hasattr(im, "meta") and isinstance(im.meta, dict):
+        #     total_meta.update(im.meta)
+        # total_meta.update(meta)
+
+        return self.instance.write(im, **self.write_args)
+
+    def set_meta_data(self, meta):
+        # TODO: write metadata
+        raise NotImplementedError(
+            "V3 Plugins don't have a uniform way to write metadata (yet)."
+        )
+
+
+def is_batch(ndimage):
+    if isinstance(ndimage, (list, tuple)):
+        return True
+
+    ndimage = np.asarray(ndimage)
+    if ndimage.ndim <= 2:
+        return False
+    elif ndimage.ndim == 3 and ndimage.shape[2] < 5:
+        return False
+
+    return True
+
+
+def is_volume(ndimage):
+    ndimage = np.asarray(ndimage)
+    if not is_batch(ndimage):
+        return False
+
+    if ndimage.ndim == 3 and ndimage.shape[2] >= 5:
+        return True
+    elif ndimage.ndim == 4 and ndimage.shape[3] < 5:
+        return True
+    else:
+        return False
+
+
+# Base functions that return a reader/writer
+
+
+def get_reader(uri, format=None, mode="?", **kwargs):
+    """get_reader(uri, format=None, mode='?', **kwargs)
+
+    Returns a :class:`.Reader` object which can be used to read data
+    and meta data from the specified file.
+
+    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.
+    mode : {'i', 'I', 'v', 'V', '?'}
+        Used to give the reader a hint on what the user expects (default "?"):
+        "i" for an image, "I" for multiple images, "v" for a volume,
+        "V" for multiple volumes, "?" for don't care.
+    kwargs : ...
+        Further keyword arguments are passed to the reader. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+
+    image_file = imopen(uri, "r" + mode, **imopen_args)
+
+    if isinstance(image_file, LegacyPlugin):
+        return image_file.legacy_get_reader(**kwargs)
+    else:
+        return LegacyReader(image_file, **kwargs)
+
+
+def get_writer(uri, format=None, mode="?", **kwargs):
+    """get_writer(uri, format=None, mode='?', **kwargs)
+
+    Returns a :class:`.Writer` object which can be used to write data
+    and meta data to the specified file.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, file}
+        The resource to write the image to, e.g. a filename, pathlib.Path
+        or file object, see the docs for more info.
+    format : str
+        The format to use to write the file. By default imageio selects
+        the appropriate for you based on the filename.
+    mode : {'i', 'I', 'v', 'V', '?'}
+        Used to give the writer a hint on what the user expects (default '?'):
+        "i" for an image, "I" for multiple images, "v" for a volume,
+        "V" for multiple volumes, "?" for don't care.
+    kwargs : ...
+        Further keyword arguments are passed to the writer. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+
+    image_file = imopen(uri, "w" + mode, **imopen_args)
+    if isinstance(image_file, LegacyPlugin):
+        return image_file.legacy_get_writer(**kwargs)
+    else:
+        return LegacyWriter(image_file, **kwargs)
+
+
+# Images
+
+
+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.
+    """
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+
+    with imopen(uri, "ri", **imopen_args) as file:
+        result = file.read(index=0, **kwargs)
+
+    return result
+
+
+def imwrite(uri, im, format=None, **kwargs):
+    """imwrite(uri, im, format=None, **kwargs)
+
+    Write an image to the specified file.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, file}
+        The resource to write the image to, e.g. a filename, pathlib.Path
+        or file object, see the docs for more info.
+    im : numpy.ndarray
+        The image data. Must be NxM, NxMx3 or NxMx4.
+    format : str
+        The format to use to write 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 writer. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    # Test image
+    imt = type(im)
+    im = np.asarray(im)
+    if not np.issubdtype(im.dtype, np.number):
+        raise ValueError("Image is not numeric, but {}.".format(imt.__name__))
+
+    if is_batch(im) or im.ndim < 2:
+        raise ValueError("Image must be 2D (grayscale, RGB, or RGBA).")
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "wi", **imopen_args) as file:
+        return file.write(im, **kwargs)
+
+
+# Multiple images
+
+
+def mimread(uri, format=None, memtest=MEMTEST_DEFAULT_MIM, **kwargs):
+    """mimread(uri, format=None, memtest="256MB", **kwargs)
+
+    Reads multiple images from the specified file. Returns a list of
+    numpy arrays, each with a dict of meta data at its 'meta' attribute.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, bytes, file}
+        The resource to load the images 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.
+    memtest : {bool, int, float, str}
+        If truthy, this function will raise an error if the resulting
+        list of images consumes greater than the amount of memory specified.
+        This is to protect the system from using so much memory that it needs
+        to resort to swapping, and thereby stall the computer. E.g.
+        ``mimread('hunger_games.avi')``.
+
+        If the argument is a number, that will be used as the threshold number
+        of bytes.
+
+        If the argument is a string, it will be interpreted as a number of bytes with
+        SI/IEC prefixed units (e.g. '1kB', '250MiB', '80.3YB').
+
+        - Units are case sensitive
+        - k, M etc. represent a 1000-fold change, where Ki, Mi etc. represent 1024-fold
+        - The "B" is optional, but if present, must be capitalised
+
+        If the argument is True, the default will be used, for compatibility reasons.
+
+        Default: '256MB'
+    kwargs : ...
+        Further keyword arguments are passed to the reader. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    # used for mimread and mvolread
+    nbyte_limit = to_nbytes(memtest, MEMTEST_DEFAULT_MIM)
+
+    images = list()
+    nbytes = 0
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "rI", **imopen_args) as file:
+        for image in file.iter(**kwargs):
+            images.append(image)
+            nbytes += image.nbytes
+            if nbytes > nbyte_limit:
+                raise RuntimeError(
+                    "imageio.mimread() has read over {}B of "
+                    "image data.\nStopped to avoid memory problems."
+                    " Use imageio.get_reader(), increase threshold, or memtest=False".format(
+                        int(nbyte_limit)
+                    )
+                )
+
+    if len(images) == 1 and is_batch(images[0]):
+        images = [*images[0]]
+
+    return images
+
+
+def mimwrite(uri, ims, format=None, **kwargs):
+    """mimwrite(uri, ims, format=None, **kwargs)
+
+    Write multiple images to the specified file.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, file}
+        The resource to write the images to, e.g. a filename, pathlib.Path
+        or file object, see the docs for more info.
+    ims : sequence of numpy arrays
+        The image data. Each array must be NxM, NxMx3 or NxMx4.
+    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 writer. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    if not is_batch(ims):
+        raise ValueError("Image data must be a sequence of ndimages.")
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "wI", **imopen_args) as file:
+        return file.write(ims, is_batch=True, **kwargs)
+
+
+# Volumes
+
+
+def volread(uri, format=None, **kwargs):
+    """volread(uri, format=None, **kwargs)
+
+    Reads a volume from the specified file. Returns a numpy array, which
+    comes with a dict of meta data at its 'meta' attribute.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, bytes, file}
+        The resource to load the volume 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.
+    """
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "rv", **imopen_args) as file:
+        return file.read(index=0, **kwargs)
+
+
+def volwrite(uri, im, format=None, **kwargs):
+    """volwrite(uri, vol, format=None, **kwargs)
+
+    Write a volume to the specified file.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, file}
+        The resource to write the image to, e.g. a filename, pathlib.Path
+        or file object, see the docs for more info.
+    vol : numpy.ndarray
+        The image data. Must be NxMxL (or NxMxLxK if each voxel is a tuple).
+    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 writer. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    # Test image
+    im = np.asarray(im)
+    if not is_volume(im):
+        raise ValueError("Image must be 3D, or 4D if each voxel is a tuple.")
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+
+    with imopen(uri, "wv", **imopen_args) as file:
+        return file.write(im, is_batch=False, **kwargs)
+
+
+# Multiple volumes
+
+
+def mvolread(uri, format=None, memtest=MEMTEST_DEFAULT_MVOL, **kwargs):
+    """mvolread(uri, format=None, memtest='1GB', **kwargs)
+
+    Reads multiple volumes from the specified file. Returns a list of
+    numpy arrays, each with a dict of meta data at its 'meta' attribute.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, bytes, file}
+        The resource to load the volumes 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.
+    memtest : {bool, int, float, str}
+        If truthy, this function will raise an error if the resulting
+        list of images consumes greater than the amount of memory specified.
+        This is to protect the system from using so much memory that it needs
+        to resort to swapping, and thereby stall the computer. E.g.
+        ``mimread('hunger_games.avi')``.
+
+        If the argument is a number, that will be used as the threshold number
+        of bytes.
+
+        If the argument is a string, it will be interpreted as a number of bytes with
+        SI/IEC prefixed units (e.g. '1kB', '250MiB', '80.3YB').
+
+        - Units are case sensitive
+        - k, M etc. represent a 1000-fold change, where Ki, Mi etc. represent 1024-fold
+        - The "B" is optional, but if present, must be capitalised
+
+        If the argument is True, the default will be used, for compatibility reasons.
+
+        Default: '1GB'
+    kwargs : ...
+        Further keyword arguments are passed to the reader. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    # used for mimread and mvolread
+    nbyte_limit = to_nbytes(memtest, MEMTEST_DEFAULT_MVOL)
+
+    images = list()
+    nbytes = 0
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "rV", **imopen_args) as file:
+        for image in file.iter(**kwargs):
+            images.append(image)
+            nbytes += image.nbytes
+            if nbytes > nbyte_limit:
+                raise RuntimeError(
+                    "imageio.mimread() has read over {}B of "
+                    "image data.\nStopped to avoid memory problems."
+                    " Use imageio.get_reader(), increase threshold, or memtest=False".format(
+                        int(nbyte_limit)
+                    )
+                )
+
+    return images
+
+
+def mvolwrite(uri, ims, format=None, **kwargs):
+    """mvolwrite(uri, vols, format=None, **kwargs)
+
+    Write multiple volumes to the specified file.
+
+    Parameters
+    ----------
+    uri : {str, pathlib.Path, file}
+        The resource to write the volumes to, e.g. a filename, pathlib.Path
+        or file object, see the docs for more info.
+    ims : sequence of numpy arrays
+        The image data. Each array must be NxMxL (or NxMxLxK if each
+        voxel is a tuple).
+    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 writer. See :func:`.help`
+        to see what arguments are available for a particular format.
+    """
+
+    for im in ims:
+        if not is_volume(im):
+            raise ValueError("Image must be 3D, or 4D if each voxel is a tuple.")
+
+    imopen_args = decypher_format_arg(format)
+    imopen_args["legacy_mode"] = True
+    with imopen(uri, "wV", **imopen_args) as file:
+        return file.write(ims, is_batch=True, **kwargs)
+
+
+# aliases
+read = get_reader
+save = get_writer
+imsave = imwrite
+mimsave = mimwrite
+volsave = volwrite
+mvolsave = mvolwrite
+
+__all__ = [
+    "imread",
+    "mimread",
+    "volread",
+    "mvolread",
+    "imwrite",
+    "mimwrite",
+    "volwrite",
+    "mvolwrite",
+    # misc
+    "help",
+    "get_reader",
+    "get_writer",
+    "RETURN_BYTES",
+]

evalkit_tf446/lib/python3.10/site-packages/imageio/v2.pyi

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+from typing import Dict, Literal, Union, List, overload
+
+import numpy as np
+
+from .core.imopen import imopen
+from .core import RETURN_BYTES, Array
+from .typing import ImageResource, ArrayLike
+from .core.format import Format
+
+MEMTEST_DEFAULT_MIM = "256MB"
+MEMTEST_DEFAULT_MVOL = "1GB"
+
+def to_nbytes(arg: float = None, default=None) -> float: ...
+def help(name=None) -> None: ...
+def decypher_format_arg(format_name: Union[str, None]) -> Dict[str, str]: ...
+def get_reader(
+    uri: ImageResource, format: Format = None, mode: str = "?", **kwargs
+) -> Format.Reader: ...
+def get_writer(
+    uri: ImageResource, format: Format = None, mode: str = "?", **kwargs
+) -> Format.Writer: ...
+def imread(uri: ImageResource, format: Format = None, **kwargs) -> Array: ...
+@overload
+def imwrite(
+    uri: Literal["<bytes>"], im: ArrayLike, format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def imwrite(
+    uri: ImageResource, im: ArrayLike, format: Format = None, **kwargs
+) -> None: ...
+def mimread(
+    uri: ImageResource, format: Format = None, memtest=MEMTEST_DEFAULT_MIM, **kwargs
+) -> List[Array]: ...
+@overload
+def mimwrite(
+    uri: Literal["<bytes>"], ims: List[ArrayLike], format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def mimwrite(
+    uri: ImageResource, ims: List[ArrayLike], format: Format = None, **kwargs
+) -> None: ...
+def volread(uri: ImageResource, format: Format = None, **kwargs) -> Array: ...
+@overload
+def volwrite(
+    uri: Literal["<bytes>"], im: ArrayLike, format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def volwrite(
+    uri: ImageResource, im: ArrayLike, format: Format = None, **kwargs
+) -> None: ...
+def mvolread(
+    uri: ImageResource,
+    format: Format = None,
+    memtest: float = MEMTEST_DEFAULT_MVOL,
+    **kwargs
+) -> List[Array]: ...
+@overload
+def mvolwrite(
+    uri: Literal["<bytes>"], ims: List[ArrayLike], format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def mvolwrite(
+    uri: ImageResource, ims: List[ArrayLike], format: Format = None, **kwargs
+) -> None: ...
+
+# aliases
+read = get_reader
+save = get_writer
+imsave = imwrite
+mimsave = mimwrite
+volsave = volwrite
+mvolsave = mvolwrite

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

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

evalkit_tf446/lib/python3.10/site-packages/imageio/v3.pyi

@@ -0,0 +1,62 @@
+from typing import Any, Dict, Iterator, List, Literal, Optional, Union, overload
+
+import numpy as np
+
+from .core.imopen import imopen as imopen
+from .core.v3_plugin_api import ImageProperties
+from .typing import ArrayLike, ImageResource
+
+def imread(
+    uri: ImageResource,
+    *,
+    index: Optional[int] = 0,
+    plugin: str = None,
+    extension: str = None,
+    format_hint: str = None,
+    **kwargs
+) -> np.ndarray: ...
+def imiter(
+    uri: ImageResource,
+    *,
+    plugin: str = None,
+    extension: str = None,
+    format_hint: str = None,
+    **kwargs
+) -> Iterator[np.ndarray]: ...
+@overload
+def imwrite(
+    uri: Literal["<bytes>"],
+    image: Union[ArrayLike, List[ArrayLike]],
+    *,
+    plugin: str = None,
+    extension: str = None,
+    format_hint: str = None,
+    **kwargs
+) -> bytes: ...
+@overload
+def imwrite(
+    uri: ImageResource,
+    image: Union[ArrayLike, List[ArrayLike]],
+    *,
+    plugin: str = None,
+    extension: str = None,
+    format_hint: str = None,
+    **kwargs
+) -> None: ...
+def improps(
+    uri,
+    *,
+    index: Optional[int] = 0,
+    plugin: str = None,
+    extension: str = None,
+    **kwargs
+) -> ImageProperties: ...
+def immeta(
+    uri,
+    *,
+    index: Optional[int] = 0,
+    plugin: str = None,
+    extension: str = None,
+    exclude_applied: bool = True,
+    **kwargs
+) -> Dict[str, Any]: ...