Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,49 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/channels.cpython-39.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-39.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/cv2/cv2.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/cv2/opencv_videoio_ffmpeg4100_64.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/gradio/frpc_windows_amd64_v0.2 filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/gradio/templates/frontend/assets/Index-CUTYDExL.js.map filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy/_core/_multiarray_umath.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy/_core/_simd.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy.libs/libscipy_openblas64_-fb1711452d4d8cee9f276fd1449ee5c7.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/algos.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/groupby.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/hashtable.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/interval.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/join.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/PIL/_imaging.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/PIL/_imagingft.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pydantic_core/_pydantic_core.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/fft/_pocketfft/pypocketfft.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/interpolate/_rbfinterp_pythran.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/io/_fast_matrix_market/_fmm_core.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/linalg/_flapack.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/misc/face.dat filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/optimize/_group_columns.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/optimize/_highs/_highs_wrapper.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/signal/_max_len_seq_inner.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/signal/_spectral.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/sparse/_sparsetools.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/spatial/_ckdtree.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/spatial/_distance_pybind.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/spatial/_qhull.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/special/_ufuncs.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/special/_ufuncs_cxx.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/special/cython_special.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/beta_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/binom_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/hypergeom_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/invgauss_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/nbinom_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/ncf_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/nct_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_boost/ncx2_ufunc.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_stats_pythran.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy/stats/_unuran/unuran_wrapper.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/scipy.libs/libopenblas_v0.3.27--3aa239bc726cfb0bd8e5330d8d4c15c6.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/sklearn/_loss/_loss.cp39-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Scripts/ruff.exe filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/colorchecker.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="Flask">
+    <option name="enabled" value="true" />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="TemplatesService">
+    <option name="TEMPLATE_CONFIGURATION" value="Jinja2" />
+    <option name="TEMPLATE_FOLDERS">
+      <list>
+        <option value="$MODULE_DIR$/../colorchecker\templates" />
+      </list>
+    </option>
+  </component>
+</module>

.idea/deployment.xml

@@ -0,0 +1,448 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PublishConfigData" remoteFilesAllowedToDisappearOnAutoupload="false">
+    <serverData>
+      <paths name="[email protected]:22">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (1)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (10)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (11)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (2)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (3)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (4)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (5)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (6)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (7)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (8)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (9)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:52895">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (1)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (10)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (11)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (12)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (13)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (14)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (15)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (16)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (17)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (18)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (19)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (2)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (20)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (21)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (22)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (23)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (24)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (25)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (26)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (27)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (28)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (29)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (3)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (30)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (31)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (32)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (33)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (34)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (35)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (36)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (37)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (38)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (39)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (4)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (40)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (41)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (42)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (43)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (44)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (45)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (46)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (47)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (5)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (6)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (7)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (8)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+      <paths name="[email protected]:22 password (9)">
+        <serverdata>
+          <mappings>
+            <mapping local="$PROJECT_DIR$" web="/" />
+          </mappings>
+        </serverdata>
+      </paths>
+    </serverData>
+  </component>
+</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,214 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <Languages>
+        <language minSize="718" name="Python" />
+      </Languages>
+    </inspection_tool>
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="LossyEncoding" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="164">
+            <item index="0" class="java.lang.String" itemvalue="sklearn" />
+            <item index="1" class="java.lang.String" itemvalue="tensorflow" />
+            <item index="2" class="java.lang.String" itemvalue="pip" />
+            <item index="3" class="java.lang.String" itemvalue="tqdm" />
+            <item index="4" class="java.lang.String" itemvalue="pandas" />
+            <item index="5" class="java.lang.String" itemvalue="scipy" />
+            <item index="6" class="java.lang.String" itemvalue="seaborn" />
+            <item index="7" class="java.lang.String" itemvalue="scikit-learn" />
+            <item index="8" class="java.lang.String" itemvalue="wheel" />
+            <item index="9" class="java.lang.String" itemvalue="setuptools" />
+            <item index="10" class="java.lang.String" itemvalue="numpy" />
+            <item index="11" class="java.lang.String" itemvalue="Pillow" />
+            <item index="12" class="java.lang.String" itemvalue="opencv-python" />
+            <item index="13" class="java.lang.String" itemvalue="python" />
+            <item index="14" class="java.lang.String" itemvalue="tensorboard" />
+            <item index="15" class="java.lang.String" itemvalue="matplotlib" />
+            <item index="16" class="java.lang.String" itemvalue="skimage" />
+            <item index="17" class="java.lang.String" itemvalue="tensorflow-gpu" />
+            <item index="18" class="java.lang.String" itemvalue="boto3" />
+            <item index="19" class="java.lang.String" itemvalue="neo4j" />
+            <item index="20" class="java.lang.String" itemvalue="smart-open" />
+            <item index="21" class="java.lang.String" itemvalue="ijson" />
+            <item index="22" class="java.lang.String" itemvalue="google-pasta" />
+            <item index="23" class="java.lang.String" itemvalue="tensorflow-estimator" />
+            <item index="24" class="java.lang.String" itemvalue="tzlocal" />
+            <item index="25" class="java.lang.String" itemvalue="testpath" />
+            <item index="26" class="java.lang.String" itemvalue="validators" />
+            <item index="27" class="java.lang.String" itemvalue="pickleshare" />
+            <item index="28" class="java.lang.String" itemvalue="defusedxml" />
+            <item index="29" class="java.lang.String" itemvalue="pycparser" />
+            <item index="30" class="java.lang.String" itemvalue="gitdb" />
+            <item index="31" class="java.lang.String" itemvalue="pyasn1-modules" />
+            <item index="32" class="java.lang.String" itemvalue="ipython-genutils" />
+            <item index="33" class="java.lang.String" itemvalue="Pygments" />
+            <item index="34" class="java.lang.String" itemvalue="bleach" />
+            <item index="35" class="java.lang.String" itemvalue="astunparse" />
+            <item index="36" class="java.lang.String" itemvalue="jsonschema" />
+            <item index="37" class="java.lang.String" itemvalue="terminado" />
+            <item index="38" class="java.lang.String" itemvalue="GitPython" />
+            <item index="39" class="java.lang.String" itemvalue="Werkzeug" />
+            <item index="40" class="java.lang.String" itemvalue="streamlit" />
+            <item index="41" class="java.lang.String" itemvalue="tensorboard-data-server" />
+            <item index="42" class="java.lang.String" itemvalue="typing-extensions" />
+            <item index="43" class="java.lang.String" itemvalue="jupyter-client" />
+            <item index="44" class="java.lang.String" itemvalue="jupyterlab-pygments" />
+            <item index="45" class="java.lang.String" itemvalue="click" />
+            <item index="46" class="java.lang.String" itemvalue="ipykernel" />
+            <item index="47" class="java.lang.String" itemvalue="nbconvert" />
+            <item index="48" class="java.lang.String" itemvalue="attrs" />
+            <item index="49" class="java.lang.String" itemvalue="jedi" />
+            <item index="50" class="java.lang.String" itemvalue="flatbuffers" />
+            <item index="51" class="java.lang.String" itemvalue="imageio" />
+            <item index="52" class="java.lang.String" itemvalue="idna" />
+            <item index="53" class="java.lang.String" itemvalue="rsa" />
+            <item index="54" class="java.lang.String" itemvalue="decorator" />
+            <item index="55" class="java.lang.String" itemvalue="networkx" />
+            <item index="56" class="java.lang.String" itemvalue="smmap" />
+            <item index="57" class="java.lang.String" itemvalue="cffi" />
+            <item index="58" class="java.lang.String" itemvalue="pandocfilters" />
+            <item index="59" class="java.lang.String" itemvalue="pyasn1" />
+            <item index="60" class="java.lang.String" itemvalue="requests" />
+            <item index="61" class="java.lang.String" itemvalue="opencv-python-headless" />
+            <item index="62" class="java.lang.String" itemvalue="pyrsistent" />
+            <item index="63" class="java.lang.String" itemvalue="tensorboard-plugin-wit" />
+            <item index="64" class="java.lang.String" itemvalue="PyWavelets" />
+            <item index="65" class="java.lang.String" itemvalue="zipp" />
+            <item index="66" class="java.lang.String" itemvalue="nest-asyncio" />
+            <item index="67" class="java.lang.String" itemvalue="prompt-toolkit" />
+            <item index="68" class="java.lang.String" itemvalue="cached-property" />
+            <item index="69" class="java.lang.String" itemvalue="ipywidgets" />
+            <item index="70" class="java.lang.String" itemvalue="blinker" />
+            <item index="71" class="java.lang.String" itemvalue="pyarrow" />
+            <item index="72" class="java.lang.String" itemvalue="tornado" />
+            <item index="73" class="java.lang.String" itemvalue="google-auth-oauthlib" />
+            <item index="74" class="java.lang.String" itemvalue="astor" />
+            <item index="75" class="java.lang.String" itemvalue="Send2Trash" />
+            <item index="76" class="java.lang.String" itemvalue="toml" />
+            <item index="77" class="java.lang.String" itemvalue="mistune" />
+            <item index="78" class="java.lang.String" itemvalue="termcolor" />
+            <item index="79" class="java.lang.String" itemvalue="watchdog" />
+            <item index="80" class="java.lang.String" itemvalue="toolz" />
+            <item index="81" class="java.lang.String" itemvalue="cachetools" />
+            <item index="82" class="java.lang.String" itemvalue="debugpy" />
+            <item index="83" class="java.lang.String" itemvalue="argon2-cffi" />
+            <item index="84" class="java.lang.String" itemvalue="pytz" />
+            <item index="85" class="java.lang.String" itemvalue="webencodings" />
+            <item index="86" class="java.lang.String" itemvalue="traitlets" />
+            <item index="87" class="java.lang.String" itemvalue="absl-py" />
+            <item index="88" class="java.lang.String" itemvalue="protobuf" />
+            <item index="89" class="java.lang.String" itemvalue="opt-einsum" />
+            <item index="90" class="java.lang.String" itemvalue="python-dateutil" />
+            <item index="91" class="java.lang.String" itemvalue="nbclient" />
+            <item index="92" class="java.lang.String" itemvalue="cycler" />
+            <item index="93" class="java.lang.String" itemvalue="gast" />
+            <item index="94" class="java.lang.String" itemvalue="MarkupSafe" />
+            <item index="95" class="java.lang.String" itemvalue="jupyterlab-widgets" />
+            <item index="96" class="java.lang.String" itemvalue="backports.zoneinfo" />
+            <item index="97" class="java.lang.String" itemvalue="pyzmq" />
+            <item index="98" class="java.lang.String" itemvalue="certifi" />
+            <item index="99" class="java.lang.String" itemvalue="oauthlib" />
+            <item index="100" class="java.lang.String" itemvalue="entrypoints" />
+            <item index="101" class="java.lang.String" itemvalue="pyparsing" />
+            <item index="102" class="java.lang.String" itemvalue="Markdown" />
+            <item index="103" class="java.lang.String" itemvalue="notebook" />
+            <item index="104" class="java.lang.String" itemvalue="tifffile" />
+            <item index="105" class="java.lang.String" itemvalue="argcomplete" />
+            <item index="106" class="java.lang.String" itemvalue="h5py" />
+            <item index="107" class="java.lang.String" itemvalue="wrapt" />
+            <item index="108" class="java.lang.String" itemvalue="kiwisolver" />
+            <item index="109" class="java.lang.String" itemvalue="altair" />
+            <item index="110" class="java.lang.String" itemvalue="backcall" />
+            <item index="111" class="java.lang.String" itemvalue="widgetsnbextension" />
+            <item index="112" class="java.lang.String" itemvalue="charset-normalizer" />
+            <item index="113" class="java.lang.String" itemvalue="scikit-image" />
+            <item index="114" class="java.lang.String" itemvalue="jupyter-core" />
+            <item index="115" class="java.lang.String" itemvalue="matplotlib-inline" />
+            <item index="116" class="java.lang.String" itemvalue="pydeck" />
+            <item index="117" class="java.lang.String" itemvalue="wcwidth" />
+            <item index="118" class="java.lang.String" itemvalue="importlib-metadata" />
+            <item index="119" class="java.lang.String" itemvalue="Jinja2" />
+            <item index="120" class="java.lang.String" itemvalue="requests-oauthlib" />
+            <item index="121" class="java.lang.String" itemvalue="Keras-Preprocessing" />
+            <item index="122" class="java.lang.String" itemvalue="urllib3" />
+            <item index="123" class="java.lang.String" itemvalue="six" />
+            <item index="124" class="java.lang.String" itemvalue="parso" />
+            <item index="125" class="java.lang.String" itemvalue="nbformat" />
+            <item index="126" class="java.lang.String" itemvalue="tzdata" />
+            <item index="127" class="java.lang.String" itemvalue="ipython" />
+            <item index="128" class="java.lang.String" itemvalue="packaging" />
+            <item index="129" class="java.lang.String" itemvalue="prometheus-client" />
+            <item index="130" class="java.lang.String" itemvalue="base58" />
+            <item index="131" class="java.lang.String" itemvalue="colorama" />
+            <item index="132" class="java.lang.String" itemvalue="grpcio" />
+            <item index="133" class="java.lang.String" itemvalue="google-auth" />
+            <item index="134" class="java.lang.String" itemvalue="pillow" />
+            <item index="135" class="java.lang.String" itemvalue="opencv-contrib-python" />
+            <item index="136" class="java.lang.String" itemvalue="PyAutoGUI" />
+            <item index="137" class="java.lang.String" itemvalue="referencing" />
+            <item index="138" class="java.lang.String" itemvalue="pyperclip" />
+            <item index="139" class="java.lang.String" itemvalue="EasyProcess" />
+            <item index="140" class="java.lang.String" itemvalue="pytweening" />
+            <item index="141" class="java.lang.String" itemvalue="rich" />
+            <item index="142" class="java.lang.String" itemvalue="PyMsgBox" />
+            <item index="143" class="java.lang.String" itemvalue="mss" />
+            <item index="144" class="java.lang.String" itemvalue="markdown-it-py" />
+            <item index="145" class="java.lang.String" itemvalue="jsonschema-specifications" />
+            <item index="146" class="java.lang.String" itemvalue="pyscreenshot" />
+            <item index="147" class="java.lang.String" itemvalue="rpds-py" />
+            <item index="148" class="java.lang.String" itemvalue="MouseInfo" />
+            <item index="149" class="java.lang.String" itemvalue="mdurl" />
+            <item index="150" class="java.lang.String" itemvalue="tenacity" />
+            <item index="151" class="java.lang.String" itemvalue="entrypoint2" />
+            <item index="152" class="java.lang.String" itemvalue="PyGetWindow" />
+            <item index="153" class="java.lang.String" itemvalue="PyRect" />
+            <item index="154" class="java.lang.String" itemvalue="PyScreeze" />
+            <item index="155" class="java.lang.String" itemvalue="tensorflow-intel" />
+            <item index="156" class="java.lang.String" itemvalue="lazy_loader" />
+            <item index="157" class="java.lang.String" itemvalue="libclang" />
+            <item index="158" class="java.lang.String" itemvalue="typing_extensions" />
+            <item index="159" class="java.lang.String" itemvalue="keras" />
+            <item index="160" class="java.lang.String" itemvalue="tensorflow-io-gcs-filesystem" />
+            <item index="161" class="java.lang.String" itemvalue="kornia" />
+            <item index="162" class="java.lang.String" itemvalue="torch" />
+            <item index="163" class="java.lang.String" itemvalue="torchvision" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E501" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N806" />
+          <option value="N801" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyStubPackagesAdvertiser" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <list>
+          <option value="pyspark-stubs==3.0.0.post2" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnboundLocalVariableInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="nearest_neighbor.kmeans" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (colorchecker)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/colorchecker.iml" filepath="$PROJECT_DIR$/.idea/colorchecker.iml" />
+    </modules>
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,154 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="fd181dc1-4687-4ecc-9b45-9a08d0ef7b64" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Flask Main" />
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="FlaskConsoleOptions" custom-start-script="import sys&#10;sys.path.extend([WORKING_DIR_AND_PYTHON_PATHS])&#10;from flask.cli import ScriptInfo&#10;locals().update(ScriptInfo(create_app=None).load_app().make_shell_context())&#10;print(&quot;Python %s on %s\nApp: %s [%s]\nInstance: %s&quot; % (sys.version, sys.platform, app.import_name, app.env, app.instance_path))">
+    <envs>
+      <env key="FLASK_APP" value="app" />
+    </envs>
+    <option name="myCustomStartScript" value="import sys&#10;sys.path.extend([WORKING_DIR_AND_PYTHON_PATHS])&#10;from flask.cli import ScriptInfo&#10;locals().update(ScriptInfo(create_app=None).load_app().make_shell_context())&#10;print(&quot;Python %s on %s\nApp: %s [%s]\nInstance: %s&quot; % (sys.version, sys.platform, app.import_name, app.env, app.instance_path))" />
+    <option name="myEnvs">
+      <map>
+        <entry key="FLASK_APP" value="app" />
+      </map>
+    </option>
+  </component>
+  <component name="GitSEFilterConfiguration">
+    <file-type-list>
+      <filtered-out-file-type name="LOCAL_BRANCH" />
+      <filtered-out-file-type name="REMOTE_BRANCH" />
+      <filtered-out-file-type name="TAG" />
+      <filtered-out-file-type name="COMMIT_BY_MESSAGE" />
+    </file-type-list>
+  </component>
+  <component name="ProjectId" id="2iKZXBURNknjhtQFeZZ8Eeq3vjW" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="WebServerToolWindowFactoryState" value="true" />
+    <property name="last_opened_file_path" value="$PROJECT_DIR$/../color_checker_mdi" />
+    <property name="node.js.detected.package.eslint" value="true" />
+    <property name="node.js.selected.package.eslint" value="(autodetect)" />
+    <property name="settings.editor.selected.configurable" value="com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable" />
+  </component>
+  <component name="RecentsManager">
+    <key name="CopyFile.RECENT_KEYS">
+      <recent name="D:\colorchecker" />
+      <recent name="D:\colorchecker\templates" />
+    </key>
+  </component>
+  <component name="RunManager" selected="Python.gradio_app">
+    <configuration name="gradio_app" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="colorchecker" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/gradio_app.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Flask (app.py)" type="Python.FlaskServer" temporary="true" nameIsGenerated="true">
+      <module name="colorchecker" />
+      <option name="target" value="$PROJECT_DIR$/app.py" />
+      <option name="targetType" value="PATH" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <option name="launchJavascriptDebuger" value="false" />
+      <method v="2" />
+    </configuration>
+    <configuration name="colorchecker" type="Python.FlaskServer">
+      <module name="colorchecker" />
+      <option name="target" value="$PROJECT_DIR$/app.py" />
+      <option name="targetType" value="PATH" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="false" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <option name="launchJavascriptDebuger" value="false" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python.gradio_app" />
+        <item itemvalue="Flask server.Flask (app.py)" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="fd181dc1-4687-4ecc-9b45-9a08d0ef7b64" name="Changes" comment="" />
+      <created>1719241268233</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1719241268233</updated>
+      <workItem from="1719241288594" duration="2651000" />
+      <workItem from="1719322367282" duration="1832000" />
+      <workItem from="1719324250050" duration="6933000" />
+      <workItem from="1719377258122" duration="259000" />
+      <workItem from="1719394020828" duration="148000" />
+      <workItem from="1719572953807" duration="300000" />
+      <workItem from="1719576294073" duration="647000" />
+      <workItem from="1719638200293" duration="96000" />
+      <workItem from="1719933127555" duration="1038000" />
+      <workItem from="1720263902602" duration="2211000" />
+      <workItem from="1720462470706" duration="6886000" />
+      <workItem from="1720505947969" duration="13942000" />
+      <workItem from="1720602705793" duration="7282000" />
+      <workItem from="1720614448144" duration="2267000" />
+      <workItem from="1720625798354" duration="1823000" />
+      <workItem from="1720700523199" duration="4722000" />
+      <workItem from="1720708763097" duration="864000" />
+      <workItem from="1720770674965" duration="2843000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/colorchecker$gradio_app.coverage" NAME="gradio_app Coverage Results" MODIFIED="1720774406786" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/colorchecker$Flask__app_py_.coverage" NAME="Flask (app.py) Coverage Results" MODIFIED="1720773700414" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/colorchecker$colorchecker.coverage" NAME="colorchecker Coverage Results" MODIFIED="1720607111175" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+  </component>
+</project>

README.md

@@ -1,12 +1,6 @@
 ---
-title: Colorchecker
-emoji: 👁
-colorFrom: purple
-colorTo: gray
+title: colorchecker
+app_file: gradio_app.py
 sdk: gradio
-sdk_version: 4.37.2
-app_file: app.py
-pinned: false
+sdk_version: 4.36.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

gradio_app.py

@@ -0,0 +1,293 @@
+import cv2
+import gradio as gr
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+checker_large_real = 10.8
+checker_small_real = 6.35
+
+
+def check_orientation(image):
+    #image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+    orientation = np.argmax(image.shape)
+    if orientation == 0:
+        image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+    return image, orientation
+
+
+def get_color_checker_table(data_points, y, yend):
+    sorted_points = sorted(data_points, key=lambda point: (point[1], point[0]))
+    differences_y = [sorted_points[0][1] - y] + \
+                    [abs(sorted_points[i][1] - sorted_points[i + 1][1]) for i in range(len(sorted_points) - 1)] + \
+                    [yend - sorted_points[-1][1]]
+
+    most_usual_y = 10
+    local_max = round((yend - y) * 0.2184)
+    lines = []
+    last_id = 0
+    label_upper = differences_y[0] // local_max if differences_y[0] > local_max + 10 else 0
+    label_lower = differences_y[-1] // local_max if differences_y[-1] > local_max + 10 else 0
+
+    for j in range(len(differences_y) - 1):
+        if differences_y[j] > local_max + 10:
+            lines.extend([[] for _ in range(label_upper)])
+            break
+
+    for i in range(1, len(differences_y) - 1):
+        if differences_y[i] > most_usual_y:
+            lines.append(sorted_points[last_id:i])
+            last_id = i
+
+    if differences_y[-1] < local_max + 10:
+        lines.append(sorted_points[last_id:])
+    else:
+        lines.append(sorted_points[last_id:])
+        lines.extend([[] for _ in range(label_lower)])
+    lines = [sorted(line, key=lambda point: point[0]) for line in lines]
+    return label_upper, label_lower, local_max, lines
+
+
+def check_points(data_points, x, xend, y, yend, image):
+    most_usual = int((xend - x) / 7.016)
+    label_upper, label_lower, usual_y, lines = get_color_checker_table(data_points, y, yend)
+
+    for q in lines:
+        if not q:
+            continue
+
+        differences_x = [q[0][0] - x] + [q[i + 1][0] - q[i][0] for i in range(len(q) - 1)] + [xend - q[-1][0]]
+        threshold_x = int(most_usual * (1 + 1 / 5.6))
+
+        for j, distance in enumerate(differences_x[:-1]):
+            if distance > threshold_x:
+                positions = distance // int(most_usual * (1 - 1 / 11.2)) - 1
+                for t in range(positions):
+                    cnt = (q[j][0] - (t + 1) * most_usual, q[j][1])
+                    # cv2.circle(image, cnt, 5, (255, 0, 0), -1)
+                    data_points.append(cnt)
+
+        if differences_x[-1] > threshold_x:
+            positions = differences_x[-1] // int(most_usual * (1 - 1 / 11.2)) - 1
+            for t in range(positions):
+                cnt = (q[-1][0] + (t + 1) * most_usual, q[-1][1])
+                # cv2.circle(image, cnt, 5, (255, 0, 0), -1)
+                data_points.append(cnt)
+    data_points.sort(key=lambda point: (point[1], point[0]))
+    _, _, _, new_lines = get_color_checker_table(data_points, y, yend)
+    return label_upper, label_lower, usual_y, image, new_lines, data_points
+
+
+def get_reference_values(points, image):
+    values = []
+    for i in points:
+        point_value = image[i[1], i[0]]
+        values.append(point_value)
+    return values
+
+
+def detect_RGB_values(image, dst):
+    x1, y1 = map(round, dst[0][0])
+    x2, y2 = map(round, dst[2][0])
+    y2 = max(0, y2)
+    image_checker = image[y1:y2, x2:x1]
+    if image_checker.size != 0:
+        # Apply GaussianBlur to reduce noise and improve edge detection
+        blurred = cv2.GaussianBlur(image_checker, (5, 5), 0)
+        # Apply edge detection
+        edges = cv2.Canny(blurred, 50, 120)
+        # Find contours
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        centers = [
+            (x + w // 2 + x2, y + h // 2 + y1)
+            for contour in contours
+            for x, y, w, h in [cv2.boundingRect(contour)]
+            if 0.8 < (aspect_ratio := w / float(h)) < 1.2 and (area := cv2.contourArea(contour)) > 100
+        ]
+        if centers:
+            # Filter out centers too close to the edges
+            centers = [
+                center for center in centers
+                if abs(center[0] - x2) >= (x1 - x2) / 7.29 and abs(center[0] - x1) >= (x1 - x2) / 7.29
+            ]
+            if centers:
+                label_upper, label_lower, usual, image, lines, M_T = check_points(centers, x2, x1, y1, y2, image)
+            else:
+                label_upper, label_lower, lines, M_T = 0, 0, [], []
+        else:
+            label_upper, label_lower, lines, M_T = 0, 0, [],[]
+    else:
+        label_upper, label_lower, lines, M_T = 0, 0, [],[]
+    M_R = [
+        [52, 52, 52], [85, 85, 85], [122, 122, 121], [160, 160, 160],
+        [200, 200, 200], [243, 243, 242], [8, 133, 161], [187, 86, 149],
+        [231, 199, 31], [175, 54, 60], [70, 148, 73], [56, 61, 150],
+        [224, 163, 46], [157, 188, 64], [94, 60, 108], [193, 90, 99],
+        [80, 91, 166], [214, 126, 44], [103, 189, 170], [133, 128, 177],
+        [87, 108, 67], [98, 122, 157], [194, 150, 130], [115, 82, 68]
+    ]
+    # show_color_points(M_T, image)
+    new_lines = lines.copy()
+    if len(M_T) < 24:
+        for i in range(label_upper):
+            new_lines[0] = [(x, y - round(usual)) for x, y in lines[1]]
+        for j in range(label_lower):
+            new_lines[-1] = [(x, y + round(usual)) for x, y in lines[-2]]
+    if len(M_T) < 24:
+        missing = 24 - len(M_T)
+        empty_indices = [index for index, sublist in enumerate(lines) if not sublist]
+        if missing == 6 and len(empty_indices) == 1:
+            l_index = 6 * empty_indices[0] - 1
+            M_R = M_R[::-1]
+            del M_R[l_index + 1:l_index + 7]
+            del new_lines[empty_indices[0]]
+            M_R = M_R[::-1]
+        if missing == 12 and len(empty_indices) == 2:
+            pass
+    elif len(M_T) > 24:
+        new_lines = []
+    M_T = [point for sublist in new_lines for point in sublist]
+    M_T_values = np.array(get_reference_values(M_T, image))
+    M_R = np.array(M_R)
+    return M_T_values, M_R
+
+
+css = ".input_image {height: 10% !important; width: 10% !important;}"
+
+
+def detect_template(image, orientation):
+    MIN_MATCH_COUNT = 10
+    template_path = 'template_img.png'
+    template_image = cv2.imread(template_path, cv2.IMREAD_GRAYSCALE)
+    gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    image_c = image.copy()
+    # Initiate SIFT detector
+    sift = cv2.SIFT_create()
+    keypoints1, descriptors1 = sift.detectAndCompute(template_image, None)
+    keypoints2, descriptors2 = sift.detectAndCompute(gray_image, None)
+
+    # FLANN parameters
+    index_params = dict(algorithm=1, trees=5)
+    search_params = dict(checks=50)
+    flann = cv2.FlannBasedMatcher(index_params, search_params)
+    matches = flann.knnMatch(descriptors1, descriptors2, k=2)
+
+    # Apply ratio test
+    good_matches = [m for m, n in matches if m.distance < 0.7 * n.distance]
+
+    if len(good_matches) > MIN_MATCH_COUNT:
+        src_points = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+        dst_points = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+
+        M, mask = cv2.findHomography(src_points, dst_points, cv2.RANSAC, 5.0)
+        h, w = template_image.shape
+        template_corners = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1], [w - 1, 0]]).reshape(-1, 1, 2)
+        dst_corners = cv2.perspectiveTransform(template_corners, M)
+        x1, y1 = map(round, dst_corners[0][0])
+        x2, y2 = map(round, dst_corners[2][0])
+        # if orientation == 0:
+        #     checker_large_im = abs(y2 - y1)
+        #     checker_small_im = abs(x2 - x1)
+        # else:
+        checker_small_im = abs(y2 - y1)
+        checker_large_im = abs(x2 - x1)
+        if checker_small_im != 0 and checker_large_im != 0:
+            px_cm_ratio_small = checker_small_real / checker_small_im
+            px_cm_ratio_large = checker_large_real / checker_large_im
+        else:
+            px_cm_ratio_small = 0
+            px_cm_ratio_large = 0
+
+        annotated_image = cv2.polylines(image_c, [np.int32(dst_corners)], True, 255, 3, cv2.LINE_AA)
+
+        if orientation == 0:
+            annotated_image = cv2.rotate(annotated_image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    else:
+        print(f"Not enough matches are found - {len(good_matches)}/{MIN_MATCH_COUNT}")
+        return None, 0, 0
+    if orientation ==0:
+        cm_per_pixel_width = px_cm_ratio_small
+        cm_per_pixel_height = px_cm_ratio_large
+    else:
+        cm_per_pixel_width = px_cm_ratio_large
+        cm_per_pixel_height = px_cm_ratio_small
+
+    return annotated_image, dst_corners, cm_per_pixel_width, cm_per_pixel_height,checker_small_im,checker_large_im
+
+
+def srgb_to_linear(rgb):
+    rgb = rgb / 255.0
+    linear_rgb = np.where(rgb <= 0.04045, rgb / 12.92, ((rgb + 0.055) / 1.055) ** 2.4)
+    return linear_rgb
+
+
+def linear_to_srgb(linear_rgb):
+    # Clip linear_rgb to ensure no negative values
+    linear_rgb = np.clip(linear_rgb, 0, 1)
+    srgb = np.where(linear_rgb <= 0.0031308, linear_rgb * 12.92, 1.055 * (linear_rgb ** (1 / 2.4)) - 0.055)
+    srgb = np.clip(srgb * 255, 0, 255)
+    return srgb.astype(np.uint8)
+
+
+def calculate_color_correction_matrix_ransac(sample_rgb, reference_rgb):
+    sample_rgb = sample_rgb[::-1]
+    sample_rgb_linear = srgb_to_linear(sample_rgb)
+    reference_rgb_linear = srgb_to_linear(reference_rgb)
+
+    # Reshape the data for RANSAC
+    X = sample_rgb_linear
+    y = reference_rgb_linear
+
+    # Initialize RANSAC regressor for each color channel
+    models = []
+    scores = []
+    for i in range(3):  # For each RGB channel
+        ransac = LinearRegression()
+        ransac.fit(X, y[:, i])
+        scores.append(ransac.score(X, y[:, i]))
+        models.append(ransac.coef_)
+    score = np.mean(scores)
+    # Stack coefficients to form the transformation matrix
+    M = np.stack(models, axis=-1)
+
+    return M, score
+
+
+def apply_color_correction(image, M):
+    image_linear = srgb_to_linear(image)
+    corrected_image_linear = np.dot(image_linear, M)
+    corrected_image_srgb = linear_to_srgb(corrected_image_linear)
+    return corrected_image_srgb
+
+
+def calibrate_img(img):
+    image, orientation = check_orientation(img)
+    annotated_image, polygon, px_width, px_height,small_side,large_side = detect_template(image, orientation)
+    a, b = detect_RGB_values(image, polygon)
+    M, score = calculate_color_correction_matrix_ransac(a, b)
+    if orientation == 0:
+        image = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    corrected_image = apply_color_correction(image, M)
+    #corrected_image = cv2.cvtColor(corrected_image, cv2.COLOR_BGR2RGB)
+    if orientation == 0:
+        width = small_side
+        height = large_side
+    else:
+        width = large_side
+        height = small_side
+    return annotated_image, corrected_image, px_width, px_height, width, height
+
+
+def process_img(img):
+    return calibrate_img(img)
+
+
+app = gr.Interface(
+    fn=process_img,
+    inputs=gr.Image(label="Input"),
+    css=css,
+    outputs=[gr.Image(label="Output"), gr.Image(label="Corrected"), gr.Label(label='Cm/px for Width'),
+             gr.Label(label='Cm/px for Height'), gr.Label(label='Checker Width'),
+             gr.Label(label='Checker Height')],
+    allow_flagging='never')
+
+app.launch(share=True)

venv/.gitignore

@@ -0,0 +1,2 @@
+# created by virtualenv automatically
+*

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/INSTALLER

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

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2016 Cory Dolphin, Olin College
+
+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.

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.1
+Name: Flask-Cors
+Version: 4.0.1
+Summary: A Flask extension adding a decorator for CORS support
+Home-page: https://github.com/corydolphin/flask-cors
+Author: Cory Dolphin
+Author-email: [email protected]
+License: MIT
+Platform: any
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: Flask >=0.9
+
+Flask-CORS
+==========
+
+|Build Status| |Latest Version| |Supported Python versions|
+|License|
+
+A Flask extension for handling Cross Origin Resource Sharing (CORS), making cross-origin AJAX possible.
+
+This package has a simple philosophy: when you want to enable CORS, you wish to enable it for all use cases on a domain.
+This means no mucking around with different allowed headers, methods, etc.
+
+By default, submission of cookies across domains is disabled due to the security implications.
+Please see the documentation for how to enable credential'ed requests, and please make sure you add some sort of `CSRF <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`__ protection before doing so!
+
+Installation
+------------
+
+Install the extension with using pip, or easy\_install.
+
+.. code:: bash
+
+    $ pip install -U flask-cors
+
+Usage
+-----
+
+This package exposes a Flask extension which by default enables CORS support on all routes, for all origins and methods.
+It allows parameterization of all CORS headers on a per-resource level.
+The package also contains a decorator, for those who prefer this approach.
+
+Simple Usage
+~~~~~~~~~~~~
+
+In the simplest case, initialize the Flask-Cors extension with default arguments in order to allow CORS for all domains on all routes.
+See the full list of options in the `documentation <https://flask-cors.corydolphin.com/en/latest/api.html#extension>`__.
+
+.. code:: python
+
+
+    from flask import Flask
+    from flask_cors import CORS
+
+    app = Flask(__name__)
+    CORS(app)
+
+    @app.route("/")
+    def helloWorld():
+      return "Hello, cross-origin-world!"
+
+Resource specific CORS
+^^^^^^^^^^^^^^^^^^^^^^
+
+Alternatively, you can specify CORS options on a resource and origin level of granularity by passing a dictionary as the `resources` option, mapping paths to a set of options.
+See the full list of options in the `documentation <https://flask-cors.corydolphin.com/en/latest/api.html#extension>`__.
+
+.. code:: python
+
+    app = Flask(__name__)
+    cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
+
+    @app.route("/api/v1/users")
+    def list_users():
+      return "user example"
+
+Route specific CORS via decorator
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This extension also exposes a simple decorator to decorate flask routes with.
+Simply add ``@cross_origin()`` below a call to Flask's ``@app.route(..)`` to allow CORS on a given route.
+See the full list of options in the `decorator documentation <https://flask-cors.corydolphin.com/en/latest/api.html#decorator>`__.
+
+.. code:: python
+
+    @app.route("/")
+    @cross_origin()
+    def helloWorld():
+      return "Hello, cross-origin-world!"
+
+Documentation
+-------------
+
+For a full list of options, please see the full `documentation <https://flask-cors.corydolphin.com/en/latest/api.html>`__
+
+Troubleshooting
+---------------
+
+If things aren't working as you expect, enable logging to help understand what is going on under the hood, and why.
+
+.. code:: python
+
+    logging.getLogger('flask_cors').level = logging.DEBUG
+
+
+Tests
+-----
+
+A simple set of tests is included in ``test/``.
+To run, install nose, and simply invoke ``nosetests`` or ``python setup.py test`` to exercise the tests.
+
+If nosetests does not work for you, due to it no longer working with newer python versions.
+You can use pytest to run the tests instead.
+
+Contributing
+------------
+
+Questions, comments or improvements?
+Please create an issue on `Github <https://github.com/corydolphin/flask-cors>`__, tweet at `@corydolphin <https://twitter.com/corydolphin>`__ or send me an email.
+I do my best to include every contribution proposed in any way that I can.
+
+Credits
+-------
+
+This Flask extension is based upon the `Decorator for the HTTP Access Control <https://web.archive.org/web/20190128010149/http://flask.pocoo.org/snippets/56/>`__ written by Armin Ronacher.
+
+.. |Build Status| image:: https://github.com/corydolphin/flask-cors/actions/workflows/unittests.yaml/badge.svg
+   :target: https://travis-ci.org/corydolphin/flask-cors
+.. |Latest Version| image:: https://img.shields.io/pypi/v/Flask-Cors.svg
+   :target: https://pypi.python.org/pypi/Flask-Cors/
+.. |Supported Python versions| image:: https://img.shields.io/pypi/pyversions/Flask-Cors.svg
+   :target: https://img.shields.io/pypi/pyversions/Flask-Cors.svg
+.. |License| image:: http://img.shields.io/:license-mit-blue.svg
+   :target: https://pypi.python.org/pypi/Flask-Cors/

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+Flask_Cors-4.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Flask_Cors-4.0.1.dist-info/LICENSE,sha256=bhob3FSDTB4HQMvOXV9vLK4chG_Sp_SCsRZJWU-vvV0,1069
+Flask_Cors-4.0.1.dist-info/METADATA,sha256=NyVEWcY6gn4ZrDqXr_pWZYP8WDq_cqBhobJjeAePkcE,5474
+Flask_Cors-4.0.1.dist-info/RECORD,,
+Flask_Cors-4.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Flask_Cors-4.0.1.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+Flask_Cors-4.0.1.dist-info/top_level.txt,sha256=aWye_0QNZPp_QtPF4ZluLHqnyVLT9CPJsfiGhwqkWuo,11
+flask_cors/__init__.py,sha256=wZDCvPTHspA2g1VV7KyKN7R-uCdBnirTlsCzgPDcQtI,792
+flask_cors/__pycache__/__init__.cpython-39.pyc,,
+flask_cors/__pycache__/core.cpython-39.pyc,,
+flask_cors/__pycache__/decorator.cpython-39.pyc,,
+flask_cors/__pycache__/extension.cpython-39.pyc,,
+flask_cors/__pycache__/version.cpython-39.pyc,,
+flask_cors/core.py,sha256=e1u_o5SOcS_gMWGjcQrkyk91uPICnzZ3AXZvy5jQ_FE,14063
+flask_cors/decorator.py,sha256=BeJsyX1wYhVKWN04FAhb6z8YqffiRr7wKqwzHPap4bw,5009
+flask_cors/extension.py,sha256=9IsibtRtr5ylAtvR9R-vQI0RASp0dT5ri6KnhIjLfvU,7857
+flask_cors/version.py,sha256=t3_GiRZvVdqtOM0gRAa8vnfrcrUkhvgVNLEwrIaUIcw,22

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/WHEEL

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

venv/Lib/site-packages/Flask_Cors-4.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+flask_cors

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/INSTALLER

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

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/LICENSE.rst

@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 2.1.5
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Maintainer: Pallets
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/markupsafe/
+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape("<script>alert(document.cookie);</script>")
+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup("<strong>Hello</strong>")
+    Markup('<strong>hello</strong>')
+
+    >>> escape(Markup("<strong>Hello</strong>"))
+    Markup('<strong>hello</strong>')
+
+    >>> # Markup is a str subclass
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>{name}</em>")
+    >>> template.format(name='"World"')
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+`please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://markupsafe.palletsprojects.com/
+-   Changes: https://markupsafe.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/MarkupSafe/
+-   Source Code: https://github.com/pallets/markupsafe/
+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/
+-   Chat: https://discord.gg/pallets

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+MarkupSafe-2.1.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-2.1.5.dist-info/LICENSE.rst,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503
+MarkupSafe-2.1.5.dist-info/METADATA,sha256=icNlaniV7YIQZ1BScCVqNaRtm7MAgfw8d3OBmoSVyAY,3096
+MarkupSafe-2.1.5.dist-info/RECORD,,
+MarkupSafe-2.1.5.dist-info/WHEEL,sha256=GZFS91_ufm4WrNPBaFVPB9MvOXR6bMZQhPcZRRTN5YM,100
+MarkupSafe-2.1.5.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=m1ysNeqf55zbEoJtaovca40ivrkEFolPlw5bGoC5Gi4,11290
+markupsafe/__pycache__/__init__.cpython-39.pyc,,
+markupsafe/__pycache__/_native.cpython-39.pyc,,
+markupsafe/_native.py,sha256=_Q7UsXCOvgdonCgqG3l5asANI6eo50EKnDM-mlwEC5M,1776
+markupsafe/_speedups.c,sha256=n3jzzaJwXcoN8nTFyA53f3vSqsWK2vujI-v6QYifjhQ,7403
+markupsafe/_speedups.cp39-win_amd64.pyd,sha256=mxpVr1JPAspPHonOfxzkg7mQIKFTQuzl9v95Ejv5zks,15872
+markupsafe/_speedups.pyi,sha256=f5QtwIOP0eLrxh2v5p6SmaYmlcHIGIfmz0DovaqL0OU,238
+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64
+

venv/Lib/site-packages/MarkupSafe-2.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+markupsafe

venv/Lib/site-packages/PIL/BdfFontFile.py

@@ -0,0 +1,133 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# bitmap distribution font (bdf) file parser
+#
+# history:
+# 1996-05-16 fl   created (as bdf2pil)
+# 1997-08-25 fl   converted to FontFile driver
+# 2001-05-25 fl   removed bogus __init__ call
+# 2002-11-20 fl   robustification (from Kevin Cazabon, Dmitry Vasiliev)
+# 2003-04-22 fl   more robustification (from Graham Dumpleton)
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1997-2003 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+Parse X Bitmap Distribution Format (BDF)
+"""
+from __future__ import annotations
+
+from typing import BinaryIO
+
+from . import FontFile, Image
+
+bdf_slant = {
+    "R": "Roman",
+    "I": "Italic",
+    "O": "Oblique",
+    "RI": "Reverse Italic",
+    "RO": "Reverse Oblique",
+    "OT": "Other",
+}
+
+bdf_spacing = {"P": "Proportional", "M": "Monospaced", "C": "Cell"}
+
+
+def bdf_char(
+    f: BinaryIO,
+) -> (
+    tuple[
+        str,
+        int,
+        tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]],
+        Image.Image,
+    ]
+    | None
+):
+    # skip to STARTCHAR
+    while True:
+        s = f.readline()
+        if not s:
+            return None
+        if s[:9] == b"STARTCHAR":
+            break
+    id = s[9:].strip().decode("ascii")
+
+    # load symbol properties
+    props = {}
+    while True:
+        s = f.readline()
+        if not s or s[:6] == b"BITMAP":
+            break
+        i = s.find(b" ")
+        props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+
+    # load bitmap
+    bitmap = bytearray()
+    while True:
+        s = f.readline()
+        if not s or s[:7] == b"ENDCHAR":
+            break
+        bitmap += s[:-1]
+
+    # The word BBX
+    # followed by the width in x (BBw), height in y (BBh),
+    # and x and y displacement (BBxoff0, BByoff0)
+    # of the lower left corner from the origin of the character.
+    width, height, x_disp, y_disp = (int(p) for p in props["BBX"].split())
+
+    # The word DWIDTH
+    # followed by the width in x and y of the character in device pixels.
+    dwx, dwy = (int(p) for p in props["DWIDTH"].split())
+
+    bbox = (
+        (dwx, dwy),
+        (x_disp, -y_disp - height, width + x_disp, -y_disp),
+        (0, 0, width, height),
+    )
+
+    try:
+        im = Image.frombytes("1", (width, height), bitmap, "hex", "1")
+    except ValueError:
+        # deal with zero-width characters
+        im = Image.new("1", (width, height))
+
+    return id, int(props["ENCODING"]), bbox, im
+
+
+class BdfFontFile(FontFile.FontFile):
+    """Font file plugin for the X11 BDF format."""
+
+    def __init__(self, fp: BinaryIO):
+        super().__init__()
+
+        s = fp.readline()
+        if s[:13] != b"STARTFONT 2.1":
+            msg = "not a valid BDF file"
+            raise SyntaxError(msg)
+
+        props = {}
+        comments = []
+
+        while True:
+            s = fp.readline()
+            if not s or s[:13] == b"ENDPROPERTIES":
+                break
+            i = s.find(b" ")
+            props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
+            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
+                if s.find(b"LogicalFontDescription") < 0:
+                    comments.append(s[i + 1 : -1].decode("ascii"))
+
+        while True:
+            c = bdf_char(fp)
+            if not c:
+                break
+            id, ch, (xy, dst, src), im = c
+            if 0 <= ch < len(self.glyph):
+                self.glyph[ch] = xy, dst, src, im

venv/Lib/site-packages/PIL/BlpImagePlugin.py

@@ -0,0 +1,476 @@
+"""
+Blizzard Mipmap Format (.blp)
+Jerome Leclanche <[email protected]>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+BLP1 files, used mostly in Warcraft III, are not fully supported.
+All types of BLP2 files used in World of Warcraft are supported.
+
+The BLP file structure consists of a header, up to 16 mipmaps of the
+texture
+
+Texture sizes must be powers of two, though the two dimensions do
+not have to be equal; 512x256 is valid, but 512x200 is not.
+The first mipmap (mipmap #0) is the full size image; each subsequent
+mipmap halves both dimensions. The final mipmap should be 1x1.
+
+BLP files come in many different flavours:
+* JPEG-compressed (type == 0) - only supported for BLP1.
+* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
+  array of 8-bit values, one per pixel, left to right, top to bottom.
+  Each value is an index to the palette.
+* DXT-compressed (type == 1, encoding == 2):
+- DXT1 compression is used if alpha_encoding == 0.
+  - An additional alpha bit is used if alpha_depth == 1.
+  - DXT3 compression is used if alpha_encoding == 1.
+  - DXT5 compression is used if alpha_encoding == 7.
+"""
+
+from __future__ import annotations
+
+import os
+import struct
+from enum import IntEnum
+from io import BytesIO
+
+from . import Image, ImageFile
+
+
+class Format(IntEnum):
+    JPEG = 0
+
+
+class Encoding(IntEnum):
+    UNCOMPRESSED = 1
+    DXT = 2
+    UNCOMPRESSED_RAW_BGRA = 3
+
+
+class AlphaEncoding(IntEnum):
+    DXT1 = 0
+    DXT3 = 1
+    DXT5 = 7
+
+
+def unpack_565(i):
+    return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
+
+
+def decode_dxt1(data, alpha=False):
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 8  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        # Decode next 8-byte block.
+        idx = block * 8
+        color0, color1, bits = struct.unpack_from("<HHI", data, idx)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        # Decode this block into 4x4 pixels
+        # Accumulate the results onto our 4 row accumulators
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+
+                control = bits & 3
+                bits = bits >> 2
+
+                a = 0xFF
+                if control == 0:
+                    r, g, b = r0, g0, b0
+                elif control == 1:
+                    r, g, b = r1, g1, b1
+                elif control == 2:
+                    if color0 > color1:
+                        r = (2 * r0 + r1) // 3
+                        g = (2 * g0 + g1) // 3
+                        b = (2 * b0 + b1) // 3
+                    else:
+                        r = (r0 + r1) // 2
+                        g = (g0 + g1) // 2
+                        b = (b0 + b1) // 2
+                elif control == 3:
+                    if color0 > color1:
+                        r = (2 * r1 + r0) // 3
+                        g = (2 * g1 + g0) // 3
+                        b = (2 * b1 + b0) // 3
+                    else:
+                        r, g, b, a = 0, 0, 0, 0
+
+                if alpha:
+                    ret[j].extend([r, g, b, a])
+                else:
+                    ret[j].extend([r, g, b])
+
+    return ret
+
+
+def decode_dxt3(data):
+    """
+    input: one "row" of data (i.e. will produce 4*width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        idx = block * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        bits = struct.unpack_from("<8B", block)
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            high = False  # Do we want the higher bits?
+            for i in range(4):
+                alphacode_index = (4 * j + i) // 2
+                a = bits[alphacode_index]
+                if high:
+                    high = False
+                    a >>= 4
+                else:
+                    high = True
+                    a &= 0xF
+                a *= 17  # We get a value between 0 and 15
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+def decode_dxt5(data):
+    """
+    input: one "row" of data (i.e. will produce 4 * width pixels)
+    """
+
+    blocks = len(data) // 16  # number of blocks in row
+    ret = (bytearray(), bytearray(), bytearray(), bytearray())
+
+    for block in range(blocks):
+        idx = block * 16
+        block = data[idx : idx + 16]
+        # Decode next 16-byte block.
+        a0, a1 = struct.unpack_from("<BB", block)
+
+        bits = struct.unpack_from("<6B", block, 2)
+        alphacode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
+        alphacode2 = bits[0] | (bits[1] << 8)
+
+        color0, color1 = struct.unpack_from("<HH", block, 8)
+
+        (code,) = struct.unpack_from("<I", block, 12)
+
+        r0, g0, b0 = unpack_565(color0)
+        r1, g1, b1 = unpack_565(color1)
+
+        for j in range(4):
+            for i in range(4):
+                # get next control op and generate a pixel
+                alphacode_index = 3 * (4 * j + i)
+
+                if alphacode_index <= 12:
+                    alphacode = (alphacode2 >> alphacode_index) & 0x07
+                elif alphacode_index == 15:
+                    alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
+                else:  # alphacode_index >= 18 and alphacode_index <= 45
+                    alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
+
+                if alphacode == 0:
+                    a = a0
+                elif alphacode == 1:
+                    a = a1
+                elif a0 > a1:
+                    a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
+                elif alphacode == 6:
+                    a = 0
+                elif alphacode == 7:
+                    a = 255
+                else:
+                    a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
+
+                color_code = (code >> 2 * (4 * j + i)) & 0x03
+
+                if color_code == 0:
+                    r, g, b = r0, g0, b0
+                elif color_code == 1:
+                    r, g, b = r1, g1, b1
+                elif color_code == 2:
+                    r = (2 * r0 + r1) // 3
+                    g = (2 * g0 + g1) // 3
+                    b = (2 * b0 + b1) // 3
+                elif color_code == 3:
+                    r = (2 * r1 + r0) // 3
+                    g = (2 * g1 + g0) // 3
+                    b = (2 * b1 + b0) // 3
+
+                ret[j].extend([r, g, b, a])
+
+    return ret
+
+
+class BLPFormatError(NotImplementedError):
+    pass
+
+
+def _accept(prefix):
+    return prefix[:4] in (b"BLP1", b"BLP2")
+
+
+class BlpImageFile(ImageFile.ImageFile):
+    """
+    Blizzard Mipmap Format
+    """
+
+    format = "BLP"
+    format_description = "Blizzard Mipmap Format"
+
+    def _open(self):
+        self.magic = self.fp.read(4)
+
+        self.fp.seek(5, os.SEEK_CUR)
+        (self._blp_alpha_depth,) = struct.unpack("<b", self.fp.read(1))
+
+        self.fp.seek(2, os.SEEK_CUR)
+        self._size = struct.unpack("<II", self.fp.read(8))
+
+        if self.magic in (b"BLP1", b"BLP2"):
+            decoder = self.magic.decode()
+        else:
+            msg = f"Bad BLP magic {repr(self.magic)}"
+            raise BLPFormatError(msg)
+
+        self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
+        self.tile = [(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
+
+
+class _BLPBaseDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        try:
+            self._read_blp_header()
+            self._load()
+        except struct.error as e:
+            msg = "Truncated BLP file"
+            raise OSError(msg) from e
+        return -1, 0
+
+    def _read_blp_header(self):
+        self.fd.seek(4)
+        (self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
+
+        (self._blp_encoding,) = struct.unpack("<b", self._safe_read(1))
+        (self._blp_alpha_depth,) = struct.unpack("<b", self._safe_read(1))
+        (self._blp_alpha_encoding,) = struct.unpack("<b", self._safe_read(1))
+        self.fd.seek(1, os.SEEK_CUR)  # mips
+
+        self.size = struct.unpack("<II", self._safe_read(8))
+
+        if isinstance(self, BLP1Decoder):
+            # Only present for BLP1
+            (self._blp_encoding,) = struct.unpack("<i", self._safe_read(4))
+            self.fd.seek(4, os.SEEK_CUR)  # subtype
+
+        self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
+        self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
+
+    def _safe_read(self, length):
+        return ImageFile._safe_read(self.fd, length)
+
+    def _read_palette(self):
+        ret = []
+        for i in range(256):
+            try:
+                b, g, r, a = struct.unpack("<4B", self._safe_read(4))
+            except struct.error:
+                break
+            ret.append((b, g, r, a))
+        return ret
+
+    def _read_bgra(self, palette):
+        data = bytearray()
+        _data = BytesIO(self._safe_read(self._blp_lengths[0]))
+        while True:
+            try:
+                (offset,) = struct.unpack("<B", _data.read(1))
+            except struct.error:
+                break
+            b, g, r, a = palette[offset]
+            d = (r, g, b)
+            if self._blp_alpha_depth:
+                d += (a,)
+            data.extend(d)
+        return data
+
+
+class BLP1Decoder(_BLPBaseDecoder):
+    def _load(self):
+        if self._blp_compression == Format.JPEG:
+            self._decode_jpeg_stream()
+
+        elif self._blp_compression == 1:
+            if self._blp_encoding in (4, 5):
+                palette = self._read_palette()
+                data = self._read_bgra(palette)
+                self.set_as_raw(data)
+            else:
+                msg = f"Unsupported BLP encoding {repr(self._blp_encoding)}"
+                raise BLPFormatError(msg)
+        else:
+            msg = f"Unsupported BLP compression {repr(self._blp_encoding)}"
+            raise BLPFormatError(msg)
+
+    def _decode_jpeg_stream(self):
+        from .JpegImagePlugin import JpegImageFile
+
+        (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
+        jpeg_header = self._safe_read(jpeg_header_size)
+        self._safe_read(self._blp_offsets[0] - self.fd.tell())  # What IS this?
+        data = self._safe_read(self._blp_lengths[0])
+        data = jpeg_header + data
+        data = BytesIO(data)
+        image = JpegImageFile(data)
+        Image._decompression_bomb_check(image.size)
+        if image.mode == "CMYK":
+            decoder_name, extents, offset, args = image.tile[0]
+            image.tile = [(decoder_name, extents, offset, (args[0], "CMYK"))]
+        r, g, b = image.convert("RGB").split()
+        image = Image.merge("RGB", (b, g, r))
+        self.set_as_raw(image.tobytes())
+
+
+class BLP2Decoder(_BLPBaseDecoder):
+    def _load(self):
+        palette = self._read_palette()
+
+        self.fd.seek(self._blp_offsets[0])
+
+        if self._blp_compression == 1:
+            # Uncompressed or DirectX compression
+
+            if self._blp_encoding == Encoding.UNCOMPRESSED:
+                data = self._read_bgra(palette)
+
+            elif self._blp_encoding == Encoding.DXT:
+                data = bytearray()
+                if self._blp_alpha_encoding == AlphaEncoding.DXT1:
+                    linesize = (self.size[0] + 3) // 4 * 8
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt1(
+                            self._safe_read(linesize), alpha=bool(self._blp_alpha_depth)
+                        ):
+                            data += d
+
+                elif self._blp_alpha_encoding == AlphaEncoding.DXT3:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt3(self._safe_read(linesize)):
+                            data += d
+
+                elif self._blp_alpha_encoding == AlphaEncoding.DXT5:
+                    linesize = (self.size[0] + 3) // 4 * 16
+                    for yb in range((self.size[1] + 3) // 4):
+                        for d in decode_dxt5(self._safe_read(linesize)):
+                            data += d
+                else:
+                    msg = f"Unsupported alpha encoding {repr(self._blp_alpha_encoding)}"
+                    raise BLPFormatError(msg)
+            else:
+                msg = f"Unknown BLP encoding {repr(self._blp_encoding)}"
+                raise BLPFormatError(msg)
+
+        else:
+            msg = f"Unknown BLP compression {repr(self._blp_compression)}"
+            raise BLPFormatError(msg)
+
+        self.set_as_raw(data)
+
+
+class BLPEncoder(ImageFile.PyEncoder):
+    _pushes_fd = True
+
+    def _write_palette(self):
+        data = b""
+        palette = self.im.getpalette("RGBA", "RGBA")
+        for i in range(len(palette) // 4):
+            r, g, b, a = palette[i * 4 : (i + 1) * 4]
+            data += struct.pack("<4B", b, g, r, a)
+        while len(data) < 256 * 4:
+            data += b"\x00" * 4
+        return data
+
+    def encode(self, bufsize):
+        palette_data = self._write_palette()
+
+        offset = 20 + 16 * 4 * 2 + len(palette_data)
+        data = struct.pack("<16I", offset, *((0,) * 15))
+
+        w, h = self.im.size
+        data += struct.pack("<16I", w * h, *((0,) * 15))
+
+        data += palette_data
+
+        for y in range(h):
+            for x in range(w):
+                data += struct.pack("<B", self.im.getpixel((x, y)))
+
+        return len(data), 0, data
+
+
+def _save(im, fp, filename):
+    if im.mode != "P":
+        msg = "Unsupported BLP image mode"
+        raise ValueError(msg)
+
+    magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
+    fp.write(magic)
+
+    fp.write(struct.pack("<i", 1))  # Uncompressed or DirectX compression
+    fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
+    fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
+    fp.write(struct.pack("<b", 0))  # alpha encoding
+    fp.write(struct.pack("<b", 0))  # mips
+    fp.write(struct.pack("<II", *im.size))
+    if magic == b"BLP1":
+        fp.write(struct.pack("<i", 5))
+        fp.write(struct.pack("<i", 0))
+
+    ImageFile._save(im, fp, [("BLP", (0, 0) + im.size, 0, im.mode)])
+
+
+Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
+Image.register_extension(BlpImageFile.format, ".blp")
+Image.register_decoder("BLP1", BLP1Decoder)
+Image.register_decoder("BLP2", BLP2Decoder)
+
+Image.register_save(BlpImageFile.format, _save)
+Image.register_encoder("BLP", BLPEncoder)

venv/Lib/site-packages/PIL/BmpImagePlugin.py

@@ -0,0 +1,472 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# BMP file handler
+#
+# Windows (and OS/2) native bitmap storage format.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-04-30 fl   Added save
+# 1997-08-27 fl   Fixed save of 1-bit images
+# 1998-03-06 fl   Load P images as L where possible
+# 1998-07-03 fl   Load P images as 1 where possible
+# 1998-12-29 fl   Handle small palettes
+# 2002-12-30 fl   Fixed load of 1-bit palette images
+# 2003-04-21 fl   Fixed load of 1-bit monochrome images
+# 2003-04-23 fl   Added limited support for BI_BITFIELDS compression
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o16le as o16
+from ._binary import o32le as o32
+
+#
+# --------------------------------------------------------------------
+# Read BMP file
+
+BIT2MODE = {
+    # bits => mode, rawmode
+    1: ("P", "P;1"),
+    4: ("P", "P;4"),
+    8: ("P", "P"),
+    16: ("RGB", "BGR;15"),
+    24: ("RGB", "BGR"),
+    32: ("RGB", "BGRX"),
+}
+
+
+def _accept(prefix):
+    return prefix[:2] == b"BM"
+
+
+def _dib_accept(prefix):
+    return i32(prefix) in [12, 40, 64, 108, 124]
+
+
+# =============================================================================
+# Image plugin for the Windows BMP format.
+# =============================================================================
+class BmpImageFile(ImageFile.ImageFile):
+    """Image plugin for the Windows Bitmap format (BMP)"""
+
+    # ------------------------------------------------------------- Description
+    format_description = "Windows Bitmap"
+    format = "BMP"
+
+    # -------------------------------------------------- BMP Compression values
+    COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
+    for k, v in COMPRESSIONS.items():
+        vars()[k] = v
+
+    def _bitmap(self, header=0, offset=0):
+        """Read relevant info about the BMP"""
+        read, seek = self.fp.read, self.fp.seek
+        if header:
+            seek(header)
+        # read bmp header size @offset 14 (this is part of the header size)
+        file_info = {"header_size": i32(read(4)), "direction": -1}
+
+        # -------------------- If requested, read header at a specific position
+        # read the rest of the bmp header, without its size
+        header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
+
+        # -------------------------------------------------- IBM OS/2 Bitmap v1
+        # ----- This format has different offsets because of width/height types
+        if file_info["header_size"] == 12:
+            file_info["width"] = i16(header_data, 0)
+            file_info["height"] = i16(header_data, 2)
+            file_info["planes"] = i16(header_data, 4)
+            file_info["bits"] = i16(header_data, 6)
+            file_info["compression"] = self.RAW
+            file_info["palette_padding"] = 3
+
+        # --------------------------------------------- Windows Bitmap v2 to v5
+        # v3, OS/2 v2, v4, v5
+        elif file_info["header_size"] in (40, 64, 108, 124):
+            file_info["y_flip"] = header_data[7] == 0xFF
+            file_info["direction"] = 1 if file_info["y_flip"] else -1
+            file_info["width"] = i32(header_data, 0)
+            file_info["height"] = (
+                i32(header_data, 4)
+                if not file_info["y_flip"]
+                else 2**32 - i32(header_data, 4)
+            )
+            file_info["planes"] = i16(header_data, 8)
+            file_info["bits"] = i16(header_data, 10)
+            file_info["compression"] = i32(header_data, 12)
+            # byte size of pixel data
+            file_info["data_size"] = i32(header_data, 16)
+            file_info["pixels_per_meter"] = (
+                i32(header_data, 20),
+                i32(header_data, 24),
+            )
+            file_info["colors"] = i32(header_data, 28)
+            file_info["palette_padding"] = 4
+            self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
+            if file_info["compression"] == self.BITFIELDS:
+                if len(header_data) >= 52:
+                    for idx, mask in enumerate(
+                        ["r_mask", "g_mask", "b_mask", "a_mask"]
+                    ):
+                        file_info[mask] = i32(header_data, 36 + idx * 4)
+                else:
+                    # 40 byte headers only have the three components in the
+                    # bitfields masks, ref:
+                    # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
+                    # See also
+                    # https://github.com/python-pillow/Pillow/issues/1293
+                    # There is a 4th component in the RGBQuad, in the alpha
+                    # location, but it is listed as a reserved component,
+                    # and it is not generally an alpha channel
+                    file_info["a_mask"] = 0x0
+                    for mask in ["r_mask", "g_mask", "b_mask"]:
+                        file_info[mask] = i32(read(4))
+                file_info["rgb_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                )
+                file_info["rgba_mask"] = (
+                    file_info["r_mask"],
+                    file_info["g_mask"],
+                    file_info["b_mask"],
+                    file_info["a_mask"],
+                )
+        else:
+            msg = f"Unsupported BMP header type ({file_info['header_size']})"
+            raise OSError(msg)
+
+        # ------------------ Special case : header is reported 40, which
+        # ---------------------- is shorter than real size for bpp >= 16
+        self._size = file_info["width"], file_info["height"]
+
+        # ------- If color count was not found in the header, compute from bits
+        file_info["colors"] = (
+            file_info["colors"]
+            if file_info.get("colors", 0)
+            else (1 << file_info["bits"])
+        )
+        if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
+            offset += 4 * file_info["colors"]
+
+        # ---------------------- Check bit depth for unusual unsupported values
+        self._mode, raw_mode = BIT2MODE.get(file_info["bits"], (None, None))
+        if self.mode is None:
+            msg = f"Unsupported BMP pixel depth ({file_info['bits']})"
+            raise OSError(msg)
+
+        # ---------------- Process BMP with Bitfields compression (not palette)
+        decoder_name = "raw"
+        if file_info["compression"] == self.BITFIELDS:
+            SUPPORTED = {
+                32: [
+                    (0xFF0000, 0xFF00, 0xFF, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0x0),
+                    (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
+                    (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
+                    (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
+                    (0x0, 0x0, 0x0, 0x0),
+                ],
+                24: [(0xFF0000, 0xFF00, 0xFF)],
+                16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
+            }
+            MASK_MODES = {
+                (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
+                (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
+                (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
+                (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
+                (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
+                (24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
+                (16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
+                (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
+            }
+            if file_info["bits"] in SUPPORTED:
+                if (
+                    file_info["bits"] == 32
+                    and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
+                    self._mode = "RGBA" if "A" in raw_mode else self.mode
+                elif (
+                    file_info["bits"] in (24, 16)
+                    and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
+                ):
+                    raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
+                else:
+                    msg = "Unsupported BMP bitfields layout"
+                    raise OSError(msg)
+            else:
+                msg = "Unsupported BMP bitfields layout"
+                raise OSError(msg)
+        elif file_info["compression"] == self.RAW:
+            if file_info["bits"] == 32 and header == 22:  # 32-bit .cur offset
+                raw_mode, self._mode = "BGRA", "RGBA"
+        elif file_info["compression"] in (self.RLE8, self.RLE4):
+            decoder_name = "bmp_rle"
+        else:
+            msg = f"Unsupported BMP compression ({file_info['compression']})"
+            raise OSError(msg)
+
+        # --------------- Once the header is processed, process the palette/LUT
+        if self.mode == "P":  # Paletted for 1, 4 and 8 bit images
+            # ---------------------------------------------------- 1-bit images
+            if not (0 < file_info["colors"] <= 65536):
+                msg = f"Unsupported BMP Palette size ({file_info['colors']})"
+                raise OSError(msg)
+            else:
+                padding = file_info["palette_padding"]
+                palette = read(padding * file_info["colors"])
+                grayscale = True
+                indices = (
+                    (0, 255)
+                    if file_info["colors"] == 2
+                    else list(range(file_info["colors"]))
+                )
+
+                # ----------------- Check if grayscale and ignore palette if so
+                for ind, val in enumerate(indices):
+                    rgb = palette[ind * padding : ind * padding + 3]
+                    if rgb != o8(val) * 3:
+                        grayscale = False
+
+                # ------- If all colors are gray, white or black, ditch palette
+                if grayscale:
+                    self._mode = "1" if file_info["colors"] == 2 else "L"
+                    raw_mode = self.mode
+                else:
+                    self._mode = "P"
+                    self.palette = ImagePalette.raw(
+                        "BGRX" if padding == 4 else "BGR", palette
+                    )
+
+        # ---------------------------- Finally set the tile data for the plugin
+        self.info["compression"] = file_info["compression"]
+        args = [raw_mode]
+        if decoder_name == "bmp_rle":
+            args.append(file_info["compression"] == self.RLE4)
+        else:
+            args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
+        args.append(file_info["direction"])
+        self.tile = [
+            (
+                decoder_name,
+                (0, 0, file_info["width"], file_info["height"]),
+                offset or self.fp.tell(),
+                tuple(args),
+            )
+        ]
+
+    def _open(self):
+        """Open file, check magic number and read header"""
+        # read 14 bytes: magic number, filesize, reserved, header final offset
+        head_data = self.fp.read(14)
+        # choke if the file does not have the required magic bytes
+        if not _accept(head_data):
+            msg = "Not a BMP file"
+            raise SyntaxError(msg)
+        # read the start position of the BMP image data (u32)
+        offset = i32(head_data, 10)
+        # load bitmap information (offset=raster info)
+        self._bitmap(offset=offset)
+
+
+class BmpRleDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        rle4 = self.args[1]
+        data = bytearray()
+        x = 0
+        dest_length = self.state.xsize * self.state.ysize
+        while len(data) < dest_length:
+            pixels = self.fd.read(1)
+            byte = self.fd.read(1)
+            if not pixels or not byte:
+                break
+            num_pixels = pixels[0]
+            if num_pixels:
+                # encoded mode
+                if x + num_pixels > self.state.xsize:
+                    # Too much data for row
+                    num_pixels = max(0, self.state.xsize - x)
+                if rle4:
+                    first_pixel = o8(byte[0] >> 4)
+                    second_pixel = o8(byte[0] & 0x0F)
+                    for index in range(num_pixels):
+                        if index % 2 == 0:
+                            data += first_pixel
+                        else:
+                            data += second_pixel
+                else:
+                    data += byte * num_pixels
+                x += num_pixels
+            else:
+                if byte[0] == 0:
+                    # end of line
+                    while len(data) % self.state.xsize != 0:
+                        data += b"\x00"
+                    x = 0
+                elif byte[0] == 1:
+                    # end of bitmap
+                    break
+                elif byte[0] == 2:
+                    # delta
+                    bytes_read = self.fd.read(2)
+                    if len(bytes_read) < 2:
+                        break
+                    right, up = self.fd.read(2)
+                    data += b"\x00" * (right + up * self.state.xsize)
+                    x = len(data) % self.state.xsize
+                else:
+                    # absolute mode
+                    if rle4:
+                        # 2 pixels per byte
+                        byte_count = byte[0] // 2
+                        bytes_read = self.fd.read(byte_count)
+                        for byte_read in bytes_read:
+                            data += o8(byte_read >> 4)
+                            data += o8(byte_read & 0x0F)
+                    else:
+                        byte_count = byte[0]
+                        bytes_read = self.fd.read(byte_count)
+                        data += bytes_read
+                    if len(bytes_read) < byte_count:
+                        break
+                    x += byte[0]
+
+                    # align to 16-bit word boundary
+                    if self.fd.tell() % 2 != 0:
+                        self.fd.seek(1, os.SEEK_CUR)
+        rawmode = "L" if self.mode == "L" else "P"
+        self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
+        return -1, 0
+
+
+# =============================================================================
+# Image plugin for the DIB format (BMP alias)
+# =============================================================================
+class DibImageFile(BmpImageFile):
+    format = "DIB"
+    format_description = "Windows Bitmap"
+
+    def _open(self):
+        self._bitmap()
+
+
+#
+# --------------------------------------------------------------------
+# Write BMP file
+
+
+SAVE = {
+    "1": ("1", 1, 2),
+    "L": ("L", 8, 256),
+    "P": ("P", 8, 256),
+    "RGB": ("BGR", 24, 0),
+    "RGBA": ("BGRA", 32, 0),
+}
+
+
+def _dib_save(im, fp, filename):
+    _save(im, fp, filename, False)
+
+
+def _save(im, fp, filename, bitmap_header=True):
+    try:
+        rawmode, bits, colors = SAVE[im.mode]
+    except KeyError as e:
+        msg = f"cannot write mode {im.mode} as BMP"
+        raise OSError(msg) from e
+
+    info = im.encoderinfo
+
+    dpi = info.get("dpi", (96, 96))
+
+    # 1 meter == 39.3701 inches
+    ppm = tuple(int(x * 39.3701 + 0.5) for x in dpi)
+
+    stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
+    header = 40  # or 64 for OS/2 version 2
+    image = stride * im.size[1]
+
+    if im.mode == "1":
+        palette = b"".join(o8(i) * 4 for i in (0, 255))
+    elif im.mode == "L":
+        palette = b"".join(o8(i) * 4 for i in range(256))
+    elif im.mode == "P":
+        palette = im.im.getpalette("RGB", "BGRX")
+        colors = len(palette) // 4
+    else:
+        palette = None
+
+    # bitmap header
+    if bitmap_header:
+        offset = 14 + header + colors * 4
+        file_size = offset + image
+        if file_size > 2**32 - 1:
+            msg = "File size is too large for the BMP format"
+            raise ValueError(msg)
+        fp.write(
+            b"BM"  # file type (magic)
+            + o32(file_size)  # file size
+            + o32(0)  # reserved
+            + o32(offset)  # image data offset
+        )
+
+    # bitmap info header
+    fp.write(
+        o32(header)  # info header size
+        + o32(im.size[0])  # width
+        + o32(im.size[1])  # height
+        + o16(1)  # planes
+        + o16(bits)  # depth
+        + o32(0)  # compression (0=uncompressed)
+        + o32(image)  # size of bitmap
+        + o32(ppm[0])  # resolution
+        + o32(ppm[1])  # resolution
+        + o32(colors)  # colors used
+        + o32(colors)  # colors important
+    )
+
+    fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
+
+    if palette:
+        fp.write(palette)
+
+    ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
+
+
+#
+# --------------------------------------------------------------------
+# Registry
+
+
+Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
+Image.register_save(BmpImageFile.format, _save)
+
+Image.register_extension(BmpImageFile.format, ".bmp")
+
+Image.register_mime(BmpImageFile.format, "image/bmp")
+
+Image.register_decoder("bmp_rle", BmpRleDecoder)
+
+Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
+Image.register_save(DibImageFile.format, _dib_save)
+
+Image.register_extension(DibImageFile.format, ".dib")
+
+Image.register_mime(DibImageFile.format, "image/bmp")

venv/Lib/site-packages/PIL/BufrStubImagePlugin.py

@@ -0,0 +1,74 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# BUFR stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler):
+    """
+    Install application-specific BUFR image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix):
+    return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
+
+
+class BufrStubImageFile(ImageFile.StubImageFile):
+    format = "BUFR"
+    format_description = "BUFR"
+
+    def _open(self):
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(4)):
+            msg = "Not a BUFR file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(offset)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self):
+        return _handler
+
+
+def _save(im, fp, filename):
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "BUFR save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
+Image.register_save(BufrStubImageFile.format, _save)
+
+Image.register_extension(BufrStubImageFile.format, ".bufr")

venv/Lib/site-packages/PIL/ContainerIO.py

@@ -0,0 +1,121 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a class to read from a container file
+#
+# History:
+# 1995-06-18 fl     Created
+# 1995-09-07 fl     Added readline(), readlines()
+#
+# Copyright (c) 1997-2001 by Secret Labs AB
+# Copyright (c) 1995 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+from typing import IO, AnyStr, Generic, Literal
+
+
+class ContainerIO(Generic[AnyStr]):
+    """
+    A file object that provides read access to a part of an existing
+    file (for example a TAR file).
+    """
+
+    def __init__(self, file: IO[AnyStr], offset: int, length: int) -> None:
+        """
+        Create file object.
+
+        :param file: Existing file.
+        :param offset: Start of region, in bytes.
+        :param length: Size of region, in bytes.
+        """
+        self.fh: IO[AnyStr] = file
+        self.pos = 0
+        self.offset = offset
+        self.length = length
+        self.fh.seek(offset)
+
+    ##
+    # Always false.
+
+    def isatty(self) -> bool:
+        return False
+
+    def seek(self, offset: int, mode: Literal[0, 1, 2] = io.SEEK_SET) -> None:
+        """
+        Move file pointer.
+
+        :param offset: Offset in bytes.
+        :param mode: Starting position. Use 0 for beginning of region, 1
+           for current offset, and 2 for end of region.  You cannot move
+           the pointer outside the defined region.
+        """
+        if mode == 1:
+            self.pos = self.pos + offset
+        elif mode == 2:
+            self.pos = self.length + offset
+        else:
+            self.pos = offset
+        # clamp
+        self.pos = max(0, min(self.pos, self.length))
+        self.fh.seek(self.offset + self.pos)
+
+    def tell(self) -> int:
+        """
+        Get current file pointer.
+
+        :returns: Offset from start of region, in bytes.
+        """
+        return self.pos
+
+    def read(self, n: int = 0) -> AnyStr:
+        """
+        Read data.
+
+        :param n: Number of bytes to read. If omitted or zero,
+            read until end of region.
+        :returns: An 8-bit string.
+        """
+        if n:
+            n = min(n, self.length - self.pos)
+        else:
+            n = self.length - self.pos
+        if not n:  # EOF
+            return b"" if "b" in self.fh.mode else ""  # type: ignore[return-value]
+        self.pos = self.pos + n
+        return self.fh.read(n)
+
+    def readline(self) -> AnyStr:
+        """
+        Read a line of text.
+
+        :returns: An 8-bit string.
+        """
+        s: AnyStr = b"" if "b" in self.fh.mode else ""  # type: ignore[assignment]
+        newline_character = b"\n" if "b" in self.fh.mode else "\n"
+        while True:
+            c = self.read(1)
+            if not c:
+                break
+            s = s + c
+            if c == newline_character:
+                break
+        return s
+
+    def readlines(self) -> list[AnyStr]:
+        """
+        Read multiple lines of text.
+
+        :returns: A list of 8-bit strings.
+        """
+        lines = []
+        while True:
+            s = self.readline()
+            if not s:
+                break
+            lines.append(s)
+        return lines

venv/Lib/site-packages/PIL/CurImagePlugin.py

@@ -0,0 +1,75 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Windows Cursor support for PIL
+#
+# notes:
+#       uses BmpImagePlugin.py to read the bitmap data.
+#
+# history:
+#       96-05-27 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import BmpImagePlugin, Image
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix):
+    return prefix[:4] == b"\0\0\2\0"
+
+
+##
+# Image plugin for Windows Cursor files.
+
+
+class CurImageFile(BmpImagePlugin.BmpImageFile):
+    format = "CUR"
+    format_description = "Windows Cursor"
+
+    def _open(self):
+        offset = self.fp.tell()
+
+        # check magic
+        s = self.fp.read(6)
+        if not _accept(s):
+            msg = "not a CUR file"
+            raise SyntaxError(msg)
+
+        # pick the largest cursor in the file
+        m = b""
+        for i in range(i16(s, 4)):
+            s = self.fp.read(16)
+            if not m:
+                m = s
+            elif s[0] > m[0] and s[1] > m[1]:
+                m = s
+        if not m:
+            msg = "No cursors were found"
+            raise TypeError(msg)
+
+        # load as bitmap
+        self._bitmap(i32(m, 12) + offset)
+
+        # patch up the bitmap height
+        self._size = self.size[0], self.size[1] // 2
+        d, e, o, a = self.tile[0]
+        self.tile[0] = d, (0, 0) + self.size, o, a
+
+
+#
+# --------------------------------------------------------------------
+
+Image.register_open(CurImageFile.format, CurImageFile, _accept)
+
+Image.register_extension(CurImageFile.format, ".cur")

venv/Lib/site-packages/PIL/DcxImagePlugin.py

@@ -0,0 +1,80 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# DCX file handling
+#
+# DCX is a container file format defined by Intel, commonly used
+# for fax applications.  Each DCX file consists of a directory
+# (a list of file offsets) followed by a set of (usually 1-bit)
+# PCX files.
+#
+# History:
+# 1995-09-09 fl   Created
+# 1996-03-20 fl   Properly derived from PcxImageFile.
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 2002-07-30 fl   Fixed file handling
+#
+# Copyright (c) 1997-98 by Secret Labs AB.
+# Copyright (c) 1995-96 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image
+from ._binary import i32le as i32
+from .PcxImagePlugin import PcxImageFile
+
+MAGIC = 0x3ADE68B1  # QUIZ: what's this value, then?
+
+
+def _accept(prefix):
+    return len(prefix) >= 4 and i32(prefix) == MAGIC
+
+
+##
+# Image plugin for the Intel DCX format.
+
+
+class DcxImageFile(PcxImageFile):
+    format = "DCX"
+    format_description = "Intel DCX"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self):
+        # Header
+        s = self.fp.read(4)
+        if not _accept(s):
+            msg = "not a DCX file"
+            raise SyntaxError(msg)
+
+        # Component directory
+        self._offset = []
+        for i in range(1024):
+            offset = i32(self.fp.read(4))
+            if not offset:
+                break
+            self._offset.append(offset)
+
+        self._fp = self.fp
+        self.frame = None
+        self.n_frames = len(self._offset)
+        self.is_animated = self.n_frames > 1
+        self.seek(0)
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        self.frame = frame
+        self.fp = self._fp
+        self.fp.seek(self._offset[frame])
+        PcxImageFile._open(self)
+
+    def tell(self):
+        return self.frame
+
+
+Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
+
+Image.register_extension(DcxImageFile.format, ".dcx")

venv/Lib/site-packages/PIL/DdsImagePlugin.py

@@ -0,0 +1,572 @@
+"""
+A Pillow loader for .dds files (S3TC-compressed aka DXTC)
+Jerome Leclanche <[email protected]>
+
+Documentation:
+https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+https://creativecommons.org/publicdomain/zero/1.0/
+"""
+
+from __future__ import annotations
+
+import io
+import struct
+import sys
+from enum import IntEnum, IntFlag
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i32le as i32
+from ._binary import o8
+from ._binary import o32le as o32
+
+# Magic ("DDS ")
+DDS_MAGIC = 0x20534444
+
+
+# DDS flags
+class DDSD(IntFlag):
+    CAPS = 0x1
+    HEIGHT = 0x2
+    WIDTH = 0x4
+    PITCH = 0x8
+    PIXELFORMAT = 0x1000
+    MIPMAPCOUNT = 0x20000
+    LINEARSIZE = 0x80000
+    DEPTH = 0x800000
+
+
+# DDS caps
+class DDSCAPS(IntFlag):
+    COMPLEX = 0x8
+    TEXTURE = 0x1000
+    MIPMAP = 0x400000
+
+
+class DDSCAPS2(IntFlag):
+    CUBEMAP = 0x200
+    CUBEMAP_POSITIVEX = 0x400
+    CUBEMAP_NEGATIVEX = 0x800
+    CUBEMAP_POSITIVEY = 0x1000
+    CUBEMAP_NEGATIVEY = 0x2000
+    CUBEMAP_POSITIVEZ = 0x4000
+    CUBEMAP_NEGATIVEZ = 0x8000
+    VOLUME = 0x200000
+
+
+# Pixel Format
+class DDPF(IntFlag):
+    ALPHAPIXELS = 0x1
+    ALPHA = 0x2
+    FOURCC = 0x4
+    PALETTEINDEXED8 = 0x20
+    RGB = 0x40
+    LUMINANCE = 0x20000
+
+
+# dxgiformat.h
+class DXGI_FORMAT(IntEnum):
+    UNKNOWN = 0
+    R32G32B32A32_TYPELESS = 1
+    R32G32B32A32_FLOAT = 2
+    R32G32B32A32_UINT = 3
+    R32G32B32A32_SINT = 4
+    R32G32B32_TYPELESS = 5
+    R32G32B32_FLOAT = 6
+    R32G32B32_UINT = 7
+    R32G32B32_SINT = 8
+    R16G16B16A16_TYPELESS = 9
+    R16G16B16A16_FLOAT = 10
+    R16G16B16A16_UNORM = 11
+    R16G16B16A16_UINT = 12
+    R16G16B16A16_SNORM = 13
+    R16G16B16A16_SINT = 14
+    R32G32_TYPELESS = 15
+    R32G32_FLOAT = 16
+    R32G32_UINT = 17
+    R32G32_SINT = 18
+    R32G8X24_TYPELESS = 19
+    D32_FLOAT_S8X24_UINT = 20
+    R32_FLOAT_X8X24_TYPELESS = 21
+    X32_TYPELESS_G8X24_UINT = 22
+    R10G10B10A2_TYPELESS = 23
+    R10G10B10A2_UNORM = 24
+    R10G10B10A2_UINT = 25
+    R11G11B10_FLOAT = 26
+    R8G8B8A8_TYPELESS = 27
+    R8G8B8A8_UNORM = 28
+    R8G8B8A8_UNORM_SRGB = 29
+    R8G8B8A8_UINT = 30
+    R8G8B8A8_SNORM = 31
+    R8G8B8A8_SINT = 32
+    R16G16_TYPELESS = 33
+    R16G16_FLOAT = 34
+    R16G16_UNORM = 35
+    R16G16_UINT = 36
+    R16G16_SNORM = 37
+    R16G16_SINT = 38
+    R32_TYPELESS = 39
+    D32_FLOAT = 40
+    R32_FLOAT = 41
+    R32_UINT = 42
+    R32_SINT = 43
+    R24G8_TYPELESS = 44
+    D24_UNORM_S8_UINT = 45
+    R24_UNORM_X8_TYPELESS = 46
+    X24_TYPELESS_G8_UINT = 47
+    R8G8_TYPELESS = 48
+    R8G8_UNORM = 49
+    R8G8_UINT = 50
+    R8G8_SNORM = 51
+    R8G8_SINT = 52
+    R16_TYPELESS = 53
+    R16_FLOAT = 54
+    D16_UNORM = 55
+    R16_UNORM = 56
+    R16_UINT = 57
+    R16_SNORM = 58
+    R16_SINT = 59
+    R8_TYPELESS = 60
+    R8_UNORM = 61
+    R8_UINT = 62
+    R8_SNORM = 63
+    R8_SINT = 64
+    A8_UNORM = 65
+    R1_UNORM = 66
+    R9G9B9E5_SHAREDEXP = 67
+    R8G8_B8G8_UNORM = 68
+    G8R8_G8B8_UNORM = 69
+    BC1_TYPELESS = 70
+    BC1_UNORM = 71
+    BC1_UNORM_SRGB = 72
+    BC2_TYPELESS = 73
+    BC2_UNORM = 74
+    BC2_UNORM_SRGB = 75
+    BC3_TYPELESS = 76
+    BC3_UNORM = 77
+    BC3_UNORM_SRGB = 78
+    BC4_TYPELESS = 79
+    BC4_UNORM = 80
+    BC4_SNORM = 81
+    BC5_TYPELESS = 82
+    BC5_UNORM = 83
+    BC5_SNORM = 84
+    B5G6R5_UNORM = 85
+    B5G5R5A1_UNORM = 86
+    B8G8R8A8_UNORM = 87
+    B8G8R8X8_UNORM = 88
+    R10G10B10_XR_BIAS_A2_UNORM = 89
+    B8G8R8A8_TYPELESS = 90
+    B8G8R8A8_UNORM_SRGB = 91
+    B8G8R8X8_TYPELESS = 92
+    B8G8R8X8_UNORM_SRGB = 93
+    BC6H_TYPELESS = 94
+    BC6H_UF16 = 95
+    BC6H_SF16 = 96
+    BC7_TYPELESS = 97
+    BC7_UNORM = 98
+    BC7_UNORM_SRGB = 99
+    AYUV = 100
+    Y410 = 101
+    Y416 = 102
+    NV12 = 103
+    P010 = 104
+    P016 = 105
+    OPAQUE_420 = 106
+    YUY2 = 107
+    Y210 = 108
+    Y216 = 109
+    NV11 = 110
+    AI44 = 111
+    IA44 = 112
+    P8 = 113
+    A8P8 = 114
+    B4G4R4A4_UNORM = 115
+    P208 = 130
+    V208 = 131
+    V408 = 132
+    SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189
+    SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190
+
+
+class D3DFMT(IntEnum):
+    UNKNOWN = 0
+    R8G8B8 = 20
+    A8R8G8B8 = 21
+    X8R8G8B8 = 22
+    R5G6B5 = 23
+    X1R5G5B5 = 24
+    A1R5G5B5 = 25
+    A4R4G4B4 = 26
+    R3G3B2 = 27
+    A8 = 28
+    A8R3G3B2 = 29
+    X4R4G4B4 = 30
+    A2B10G10R10 = 31
+    A8B8G8R8 = 32
+    X8B8G8R8 = 33
+    G16R16 = 34
+    A2R10G10B10 = 35
+    A16B16G16R16 = 36
+    A8P8 = 40
+    P8 = 41
+    L8 = 50
+    A8L8 = 51
+    A4L4 = 52
+    V8U8 = 60
+    L6V5U5 = 61
+    X8L8V8U8 = 62
+    Q8W8V8U8 = 63
+    V16U16 = 64
+    A2W10V10U10 = 67
+    D16_LOCKABLE = 70
+    D32 = 71
+    D15S1 = 73
+    D24S8 = 75
+    D24X8 = 77
+    D24X4S4 = 79
+    D16 = 80
+    D32F_LOCKABLE = 82
+    D24FS8 = 83
+    D32_LOCKABLE = 84
+    S8_LOCKABLE = 85
+    L16 = 81
+    VERTEXDATA = 100
+    INDEX16 = 101
+    INDEX32 = 102
+    Q16W16V16U16 = 110
+    R16F = 111
+    G16R16F = 112
+    A16B16G16R16F = 113
+    R32F = 114
+    G32R32F = 115
+    A32B32G32R32F = 116
+    CxV8U8 = 117
+    A1 = 118
+    A2B10G10R10_XR_BIAS = 119
+    BINARYBUFFER = 199
+
+    UYVY = i32(b"UYVY")
+    R8G8_B8G8 = i32(b"RGBG")
+    YUY2 = i32(b"YUY2")
+    G8R8_G8B8 = i32(b"GRGB")
+    DXT1 = i32(b"DXT1")
+    DXT2 = i32(b"DXT2")
+    DXT3 = i32(b"DXT3")
+    DXT4 = i32(b"DXT4")
+    DXT5 = i32(b"DXT5")
+    DX10 = i32(b"DX10")
+    BC4S = i32(b"BC4S")
+    BC4U = i32(b"BC4U")
+    BC5S = i32(b"BC5S")
+    BC5U = i32(b"BC5U")
+    ATI1 = i32(b"ATI1")
+    ATI2 = i32(b"ATI2")
+    MULTI2_ARGB8 = i32(b"MET1")
+
+
+# Backward compatibility layer
+module = sys.modules[__name__]
+for item in DDSD:
+    assert item.name is not None
+    setattr(module, "DDSD_" + item.name, item.value)
+for item1 in DDSCAPS:
+    assert item1.name is not None
+    setattr(module, "DDSCAPS_" + item1.name, item1.value)
+for item2 in DDSCAPS2:
+    assert item2.name is not None
+    setattr(module, "DDSCAPS2_" + item2.name, item2.value)
+for item3 in DDPF:
+    assert item3.name is not None
+    setattr(module, "DDPF_" + item3.name, item3.value)
+
+DDS_FOURCC = DDPF.FOURCC
+DDS_RGB = DDPF.RGB
+DDS_RGBA = DDPF.RGB | DDPF.ALPHAPIXELS
+DDS_LUMINANCE = DDPF.LUMINANCE
+DDS_LUMINANCEA = DDPF.LUMINANCE | DDPF.ALPHAPIXELS
+DDS_ALPHA = DDPF.ALPHA
+DDS_PAL8 = DDPF.PALETTEINDEXED8
+
+DDS_HEADER_FLAGS_TEXTURE = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT
+DDS_HEADER_FLAGS_MIPMAP = DDSD.MIPMAPCOUNT
+DDS_HEADER_FLAGS_VOLUME = DDSD.DEPTH
+DDS_HEADER_FLAGS_PITCH = DDSD.PITCH
+DDS_HEADER_FLAGS_LINEARSIZE = DDSD.LINEARSIZE
+
+DDS_HEIGHT = DDSD.HEIGHT
+DDS_WIDTH = DDSD.WIDTH
+
+DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS.TEXTURE
+DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS.COMPLEX | DDSCAPS.MIPMAP
+DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS.COMPLEX
+
+DDS_CUBEMAP_POSITIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEX
+DDS_CUBEMAP_NEGATIVEX = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEX
+DDS_CUBEMAP_POSITIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEY
+DDS_CUBEMAP_NEGATIVEY = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEY
+DDS_CUBEMAP_POSITIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_POSITIVEZ
+DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2.CUBEMAP | DDSCAPS2.CUBEMAP_NEGATIVEZ
+
+DXT1_FOURCC = D3DFMT.DXT1
+DXT3_FOURCC = D3DFMT.DXT3
+DXT5_FOURCC = D3DFMT.DXT5
+
+DXGI_FORMAT_R8G8B8A8_TYPELESS = DXGI_FORMAT.R8G8B8A8_TYPELESS
+DXGI_FORMAT_R8G8B8A8_UNORM = DXGI_FORMAT.R8G8B8A8_UNORM
+DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = DXGI_FORMAT.R8G8B8A8_UNORM_SRGB
+DXGI_FORMAT_BC5_TYPELESS = DXGI_FORMAT.BC5_TYPELESS
+DXGI_FORMAT_BC5_UNORM = DXGI_FORMAT.BC5_UNORM
+DXGI_FORMAT_BC5_SNORM = DXGI_FORMAT.BC5_SNORM
+DXGI_FORMAT_BC6H_UF16 = DXGI_FORMAT.BC6H_UF16
+DXGI_FORMAT_BC6H_SF16 = DXGI_FORMAT.BC6H_SF16
+DXGI_FORMAT_BC7_TYPELESS = DXGI_FORMAT.BC7_TYPELESS
+DXGI_FORMAT_BC7_UNORM = DXGI_FORMAT.BC7_UNORM
+DXGI_FORMAT_BC7_UNORM_SRGB = DXGI_FORMAT.BC7_UNORM_SRGB
+
+
+class DdsImageFile(ImageFile.ImageFile):
+    format = "DDS"
+    format_description = "DirectDraw Surface"
+
+    def _open(self):
+        if not _accept(self.fp.read(4)):
+            msg = "not a DDS file"
+            raise SyntaxError(msg)
+        (header_size,) = struct.unpack("<I", self.fp.read(4))
+        if header_size != 124:
+            msg = f"Unsupported header size {repr(header_size)}"
+            raise OSError(msg)
+        header_bytes = self.fp.read(header_size - 4)
+        if len(header_bytes) != 120:
+            msg = f"Incomplete header: {len(header_bytes)} bytes"
+            raise OSError(msg)
+        header = io.BytesIO(header_bytes)
+
+        flags, height, width = struct.unpack("<3I", header.read(12))
+        self._size = (width, height)
+        extents = (0, 0) + self.size
+
+        pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))
+        struct.unpack("<11I", header.read(44))  # reserved
+
+        # pixel format
+        pfsize, pfflags, fourcc, bitcount = struct.unpack("<4I", header.read(16))
+        n = 0
+        rawmode = None
+        if pfflags & DDPF.RGB:
+            # Texture contains uncompressed RGB data
+            if pfflags & DDPF.ALPHAPIXELS:
+                self._mode = "RGBA"
+                mask_count = 4
+            else:
+                self._mode = "RGB"
+                mask_count = 3
+
+            masks = struct.unpack(f"<{mask_count}I", header.read(mask_count * 4))
+            self.tile = [("dds_rgb", extents, 0, (bitcount, masks))]
+            return
+        elif pfflags & DDPF.LUMINANCE:
+            if bitcount == 8:
+                self._mode = "L"
+            elif bitcount == 16 and pfflags & DDPF.ALPHAPIXELS:
+                self._mode = "LA"
+            else:
+                msg = f"Unsupported bitcount {bitcount} for {pfflags}"
+                raise OSError(msg)
+        elif pfflags & DDPF.PALETTEINDEXED8:
+            self._mode = "P"
+            self.palette = ImagePalette.raw("RGBA", self.fp.read(1024))
+        elif pfflags & DDPF.FOURCC:
+            offset = header_size + 4
+            if fourcc == D3DFMT.DXT1:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT1"
+                n = 1
+            elif fourcc == D3DFMT.DXT3:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT3"
+                n = 2
+            elif fourcc == D3DFMT.DXT5:
+                self._mode = "RGBA"
+                self.pixel_format = "DXT5"
+                n = 3
+            elif fourcc in (D3DFMT.BC4U, D3DFMT.ATI1):
+                self._mode = "L"
+                self.pixel_format = "BC4"
+                n = 4
+            elif fourcc == D3DFMT.BC5S:
+                self._mode = "RGB"
+                self.pixel_format = "BC5S"
+                n = 5
+            elif fourcc in (D3DFMT.BC5U, D3DFMT.ATI2):
+                self._mode = "RGB"
+                self.pixel_format = "BC5"
+                n = 5
+            elif fourcc == D3DFMT.DX10:
+                offset += 20
+                # ignoring flags which pertain to volume textures and cubemaps
+                (dxgi_format,) = struct.unpack("<I", self.fp.read(4))
+                self.fp.read(16)
+                if dxgi_format in (
+                    DXGI_FORMAT.BC1_UNORM,
+                    DXGI_FORMAT.BC1_TYPELESS,
+                ):
+                    self._mode = "RGBA"
+                    self.pixel_format = "BC1"
+                    n = 1
+                elif dxgi_format in (DXGI_FORMAT.BC4_TYPELESS, DXGI_FORMAT.BC4_UNORM):
+                    self._mode = "L"
+                    self.pixel_format = "BC4"
+                    n = 4
+                elif dxgi_format in (DXGI_FORMAT.BC5_TYPELESS, DXGI_FORMAT.BC5_UNORM):
+                    self._mode = "RGB"
+                    self.pixel_format = "BC5"
+                    n = 5
+                elif dxgi_format == DXGI_FORMAT.BC5_SNORM:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC5S"
+                    n = 5
+                elif dxgi_format == DXGI_FORMAT.BC6H_UF16:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC6H"
+                    n = 6
+                elif dxgi_format == DXGI_FORMAT.BC6H_SF16:
+                    self._mode = "RGB"
+                    self.pixel_format = "BC6HS"
+                    n = 6
+                elif dxgi_format in (
+                    DXGI_FORMAT.BC7_TYPELESS,
+                    DXGI_FORMAT.BC7_UNORM,
+                    DXGI_FORMAT.BC7_UNORM_SRGB,
+                ):
+                    self._mode = "RGBA"
+                    self.pixel_format = "BC7"
+                    n = 7
+                    if dxgi_format == DXGI_FORMAT.BC7_UNORM_SRGB:
+                        self.info["gamma"] = 1 / 2.2
+                elif dxgi_format in (
+                    DXGI_FORMAT.R8G8B8A8_TYPELESS,
+                    DXGI_FORMAT.R8G8B8A8_UNORM,
+                    DXGI_FORMAT.R8G8B8A8_UNORM_SRGB,
+                ):
+                    self._mode = "RGBA"
+                    if dxgi_format == DXGI_FORMAT.R8G8B8A8_UNORM_SRGB:
+                        self.info["gamma"] = 1 / 2.2
+                else:
+                    msg = f"Unimplemented DXGI format {dxgi_format}"
+                    raise NotImplementedError(msg)
+            else:
+                msg = f"Unimplemented pixel format {repr(fourcc)}"
+                raise NotImplementedError(msg)
+        else:
+            msg = f"Unknown pixel format flags {pfflags}"
+            raise NotImplementedError(msg)
+
+        if n:
+            self.tile = [
+                ImageFile._Tile("bcn", extents, offset, (n, self.pixel_format))
+            ]
+        else:
+            self.tile = [ImageFile._Tile("raw", extents, 0, rawmode or self.mode)]
+
+    def load_seek(self, pos):
+        pass
+
+
+class DdsRgbDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        bitcount, masks = self.args
+
+        # Some masks will be padded with zeros, e.g. R 0b11 G 0b1100
+        # Calculate how many zeros each mask is padded with
+        mask_offsets = []
+        # And the maximum value of each channel without the padding
+        mask_totals = []
+        for mask in masks:
+            offset = 0
+            if mask != 0:
+                while mask >> (offset + 1) << (offset + 1) == mask:
+                    offset += 1
+            mask_offsets.append(offset)
+            mask_totals.append(mask >> offset)
+
+        data = bytearray()
+        bytecount = bitcount // 8
+        dest_length = self.state.xsize * self.state.ysize * len(masks)
+        while len(data) < dest_length:
+            value = int.from_bytes(self.fd.read(bytecount), "little")
+            for i, mask in enumerate(masks):
+                masked_value = value & mask
+                # Remove the zero padding, and scale it to 8 bits
+                data += o8(
+                    int(((masked_value >> mask_offsets[i]) / mask_totals[i]) * 255)
+                )
+        self.set_as_raw(data)
+        return -1, 0
+
+
+def _save(im, fp, filename):
+    if im.mode not in ("RGB", "RGBA", "L", "LA"):
+        msg = f"cannot write mode {im.mode} as DDS"
+        raise OSError(msg)
+
+    alpha = im.mode[-1] == "A"
+    if im.mode[0] == "L":
+        pixel_flags = DDPF.LUMINANCE
+        rawmode = im.mode
+        if alpha:
+            rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
+        else:
+            rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
+    else:
+        pixel_flags = DDPF.RGB
+        rawmode = im.mode[::-1]
+        rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]
+
+        if alpha:
+            r, g, b, a = im.split()
+            im = Image.merge("RGBA", (a, r, g, b))
+    if alpha:
+        pixel_flags |= DDPF.ALPHAPIXELS
+    rgba_mask.append(0xFF000000 if alpha else 0)
+
+    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PITCH | DDSD.PIXELFORMAT
+    bitcount = len(im.getbands()) * 8
+    pitch = (im.width * bitcount + 7) // 8
+
+    fp.write(
+        o32(DDS_MAGIC)
+        + struct.pack(
+            "<7I",
+            124,  # header size
+            flags,  # flags
+            im.height,
+            im.width,
+            pitch,
+            0,  # depth
+            0,  # mipmaps
+        )
+        + struct.pack("11I", *((0,) * 11))  # reserved
+        # pfsize, pfflags, fourcc, bitcount
+        + struct.pack("<4I", 32, pixel_flags, 0, bitcount)
+        + struct.pack("<4I", *rgba_mask)  # dwRGBABitMask
+        + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)
+    )
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))]
+    )
+
+
+def _accept(prefix):
+    return prefix[:4] == b"DDS "
+
+
+Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
+Image.register_decoder("dds_rgb", DdsRgbDecoder)
+Image.register_save(DdsImageFile.format, _save)
+Image.register_extension(DdsImageFile.format, ".dds")

venv/Lib/site-packages/PIL/EpsImagePlugin.py

@@ -0,0 +1,474 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EPS file handling
+#
+# History:
+# 1995-09-01 fl   Created (0.1)
+# 1996-05-18 fl   Don't choke on "atend" fields, Ghostscript interface (0.2)
+# 1996-08-22 fl   Don't choke on floating point BoundingBox values
+# 1996-08-23 fl   Handle files from Macintosh (0.3)
+# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.4)
+# 2003-09-07 fl   Check gs.close status (from Federico Di Gregorio) (0.5)
+# 2014-05-07 e    Handling of EPS with binary preview and fixed resolution
+#                 resizing
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import re
+import subprocess
+import sys
+import tempfile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+from ._deprecate import deprecate
+
+# --------------------------------------------------------------------
+
+
+split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
+field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
+
+gs_binary: str | bool | None = None
+gs_windows_binary = None
+
+
+def has_ghostscript():
+    global gs_binary, gs_windows_binary
+    if gs_binary is None:
+        if sys.platform.startswith("win"):
+            if gs_windows_binary is None:
+                import shutil
+
+                for binary in ("gswin32c", "gswin64c", "gs"):
+                    if shutil.which(binary) is not None:
+                        gs_windows_binary = binary
+                        break
+                else:
+                    gs_windows_binary = False
+            gs_binary = gs_windows_binary
+        else:
+            try:
+                subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
+                gs_binary = "gs"
+            except OSError:
+                gs_binary = False
+    return gs_binary is not False
+
+
+def Ghostscript(tile, size, fp, scale=1, transparency=False):
+    """Render an image using Ghostscript"""
+    global gs_binary
+    if not has_ghostscript():
+        msg = "Unable to locate Ghostscript on paths"
+        raise OSError(msg)
+
+    # Unpack decoder tile
+    decoder, tile, offset, data = tile[0]
+    length, bbox = data
+
+    # Hack to support hi-res rendering
+    scale = int(scale) or 1
+    width = size[0] * scale
+    height = size[1] * scale
+    # resolution is dependent on bbox and size
+    res_x = 72.0 * width / (bbox[2] - bbox[0])
+    res_y = 72.0 * height / (bbox[3] - bbox[1])
+
+    out_fd, outfile = tempfile.mkstemp()
+    os.close(out_fd)
+
+    infile_temp = None
+    if hasattr(fp, "name") and os.path.exists(fp.name):
+        infile = fp.name
+    else:
+        in_fd, infile_temp = tempfile.mkstemp()
+        os.close(in_fd)
+        infile = infile_temp
+
+        # Ignore length and offset!
+        # Ghostscript can read it
+        # Copy whole file to read in Ghostscript
+        with open(infile_temp, "wb") as f:
+            # fetch length of fp
+            fp.seek(0, io.SEEK_END)
+            fsize = fp.tell()
+            # ensure start position
+            # go back
+            fp.seek(0)
+            lengthfile = fsize
+            while lengthfile > 0:
+                s = fp.read(min(lengthfile, 100 * 1024))
+                if not s:
+                    break
+                lengthfile -= len(s)
+                f.write(s)
+
+    device = "pngalpha" if transparency else "ppmraw"
+
+    # Build Ghostscript command
+    command = [
+        gs_binary,
+        "-q",  # quiet mode
+        f"-g{width:d}x{height:d}",  # set output geometry (pixels)
+        f"-r{res_x:f}x{res_y:f}",  # set input DPI (dots per inch)
+        "-dBATCH",  # exit after processing
+        "-dNOPAUSE",  # don't pause between pages
+        "-dSAFER",  # safe mode
+        f"-sDEVICE={device}",
+        f"-sOutputFile={outfile}",  # output file
+        # adjust for image origin
+        "-c",
+        f"{-bbox[0]} {-bbox[1]} translate",
+        "-f",
+        infile,  # input file
+        # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
+        "-c",
+        "showpage",
+    ]
+
+    # push data through Ghostscript
+    try:
+        startupinfo = None
+        if sys.platform.startswith("win"):
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        subprocess.check_call(command, startupinfo=startupinfo)
+        out_im = Image.open(outfile)
+        out_im.load()
+    finally:
+        try:
+            os.unlink(outfile)
+            if infile_temp:
+                os.unlink(infile_temp)
+        except OSError:
+            pass
+
+    im = out_im.im.copy()
+    out_im.close()
+    return im
+
+
+class PSFile:
+    """
+    Wrapper for bytesio object that treats either CR or LF as end of line.
+    This class is no longer used internally, but kept for backwards compatibility.
+    """
+
+    def __init__(self, fp):
+        deprecate(
+            "PSFile",
+            11,
+            action="If you need the functionality of this class "
+            "you will need to implement it yourself.",
+        )
+        self.fp = fp
+        self.char = None
+
+    def seek(self, offset, whence=io.SEEK_SET):
+        self.char = None
+        self.fp.seek(offset, whence)
+
+    def readline(self):
+        s = [self.char or b""]
+        self.char = None
+
+        c = self.fp.read(1)
+        while (c not in b"\r\n") and len(c):
+            s.append(c)
+            c = self.fp.read(1)
+
+        self.char = self.fp.read(1)
+        # line endings can be 1 or 2 of \r \n, in either order
+        if self.char in b"\r\n":
+            self.char = None
+
+        return b"".join(s).decode("latin-1")
+
+
+def _accept(prefix):
+    return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
+
+
+##
+# Image plugin for Encapsulated PostScript. This plugin supports only
+# a few variants of this format.
+
+
+class EpsImageFile(ImageFile.ImageFile):
+    """EPS File Parser for the Python Imaging Library"""
+
+    format = "EPS"
+    format_description = "Encapsulated Postscript"
+
+    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
+
+    def _open(self):
+        (length, offset) = self._find_offset(self.fp)
+
+        # go to offset - start of "%!PS"
+        self.fp.seek(offset)
+
+        self._mode = "RGB"
+        self._size = None
+
+        byte_arr = bytearray(255)
+        bytes_mv = memoryview(byte_arr)
+        bytes_read = 0
+        reading_header_comments = True
+        reading_trailer_comments = False
+        trailer_reached = False
+
+        def check_required_header_comments():
+            if "PS-Adobe" not in self.info:
+                msg = 'EPS header missing "%!PS-Adobe" comment'
+                raise SyntaxError(msg)
+            if "BoundingBox" not in self.info:
+                msg = 'EPS header missing "%%BoundingBox" comment'
+                raise SyntaxError(msg)
+
+        def _read_comment(s):
+            nonlocal reading_trailer_comments
+            try:
+                m = split.match(s)
+            except re.error as e:
+                msg = "not an EPS file"
+                raise SyntaxError(msg) from e
+
+            if m:
+                k, v = m.group(1, 2)
+                self.info[k] = v
+                if k == "BoundingBox":
+                    if v == "(atend)":
+                        reading_trailer_comments = True
+                    elif not self._size or (
+                        trailer_reached and reading_trailer_comments
+                    ):
+                        try:
+                            # Note: The DSC spec says that BoundingBox
+                            # fields should be integers, but some drivers
+                            # put floating point values there anyway.
+                            box = [int(float(i)) for i in v.split()]
+                            self._size = box[2] - box[0], box[3] - box[1]
+                            self.tile = [
+                                ("eps", (0, 0) + self.size, offset, (length, box))
+                            ]
+                        except Exception:
+                            pass
+                return True
+
+        while True:
+            byte = self.fp.read(1)
+            if byte == b"":
+                # if we didn't read a byte we must be at the end of the file
+                if bytes_read == 0:
+                    break
+            elif byte in b"\r\n":
+                # if we read a line ending character, ignore it and parse what
+                # we have already read. if we haven't read any other characters,
+                # continue reading
+                if bytes_read == 0:
+                    continue
+            else:
+                # ASCII/hexadecimal lines in an EPS file must not exceed
+                # 255 characters, not including line ending characters
+                if bytes_read >= 255:
+                    # only enforce this for lines starting with a "%",
+                    # otherwise assume it's binary data
+                    if byte_arr[0] == ord("%"):
+                        msg = "not an EPS file"
+                        raise SyntaxError(msg)
+                    else:
+                        if reading_header_comments:
+                            check_required_header_comments()
+                            reading_header_comments = False
+                        # reset bytes_read so we can keep reading
+                        # data until the end of the line
+                        bytes_read = 0
+                byte_arr[bytes_read] = byte[0]
+                bytes_read += 1
+                continue
+
+            if reading_header_comments:
+                # Load EPS header
+
+                # if this line doesn't start with a "%",
+                # or does start with "%%EndComments",
+                # then we've reached the end of the header/comments
+                if byte_arr[0] != ord("%") or bytes_mv[:13] == b"%%EndComments":
+                    check_required_header_comments()
+                    reading_header_comments = False
+                    continue
+
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                if not _read_comment(s):
+                    m = field.match(s)
+                    if m:
+                        k = m.group(1)
+                        if k[:8] == "PS-Adobe":
+                            self.info["PS-Adobe"] = k[9:]
+                        else:
+                            self.info[k] = ""
+                    elif s[0] == "%":
+                        # handle non-DSC PostScript comments that some
+                        # tools mistakenly put in the Comments section
+                        pass
+                    else:
+                        msg = "bad EPS header"
+                        raise OSError(msg)
+            elif bytes_mv[:11] == b"%ImageData:":
+                # Check for an "ImageData" descriptor
+                # https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577413_pgfId-1035096
+
+                # Values:
+                # columns
+                # rows
+                # bit depth (1 or 8)
+                # mode (1: L, 2: LAB, 3: RGB, 4: CMYK)
+                # number of padding channels
+                # block size (number of bytes per row per channel)
+                # binary/ascii (1: binary, 2: ascii)
+                # data start identifier (the image data follows after a single line
+                #   consisting only of this quoted value)
+                image_data_values = byte_arr[11:bytes_read].split(None, 7)
+                columns, rows, bit_depth, mode_id = (
+                    int(value) for value in image_data_values[:4]
+                )
+
+                if bit_depth == 1:
+                    self._mode = "1"
+                elif bit_depth == 8:
+                    try:
+                        self._mode = self.mode_map[mode_id]
+                    except ValueError:
+                        break
+                else:
+                    break
+
+                self._size = columns, rows
+                return
+            elif bytes_mv[:5] == b"%%EOF":
+                break
+            elif trailer_reached and reading_trailer_comments:
+                # Load EPS trailer
+                s = str(bytes_mv[:bytes_read], "latin-1")
+                _read_comment(s)
+            elif bytes_mv[:9] == b"%%Trailer":
+                trailer_reached = True
+            bytes_read = 0
+
+        check_required_header_comments()
+
+        if not self._size:
+            msg = "cannot determine EPS bounding box"
+            raise OSError(msg)
+
+    def _find_offset(self, fp):
+        s = fp.read(4)
+
+        if s == b"%!PS":
+            # for HEAD without binary preview
+            fp.seek(0, io.SEEK_END)
+            length = fp.tell()
+            offset = 0
+        elif i32(s) == 0xC6D3D0C5:
+            # FIX for: Some EPS file not handled correctly / issue #302
+            # EPS can contain binary data
+            # or start directly with latin coding
+            # more info see:
+            # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
+            s = fp.read(8)
+            offset = i32(s)
+            length = i32(s, 4)
+        else:
+            msg = "not an EPS file"
+            raise SyntaxError(msg)
+
+        return length, offset
+
+    def load(self, scale=1, transparency=False):
+        # Load EPS via Ghostscript
+        if self.tile:
+            self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
+            self._mode = self.im.mode
+            self._size = self.im.size
+            self.tile = []
+        return Image.Image.load(self)
+
+    def load_seek(self, pos):
+        # we can't incrementally load, so force ImageFile.parser to
+        # use our custom load method by defining this method.
+        pass
+
+
+# --------------------------------------------------------------------
+
+
+def _save(im, fp, filename, eps=1):
+    """EPS Writer for the Python Imaging Library."""
+
+    # make sure image data is available
+    im.load()
+
+    # determine PostScript image mode
+    if im.mode == "L":
+        operator = (8, 1, b"image")
+    elif im.mode == "RGB":
+        operator = (8, 3, b"false 3 colorimage")
+    elif im.mode == "CMYK":
+        operator = (8, 4, b"false 4 colorimage")
+    else:
+        msg = "image mode is not supported"
+        raise ValueError(msg)
+
+    if eps:
+        # write EPS header
+        fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
+        fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
+        # fp.write("%%CreationDate: %s"...)
+        fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
+        fp.write(b"%%Pages: 1\n")
+        fp.write(b"%%EndComments\n")
+        fp.write(b"%%Page: 1 1\n")
+        fp.write(b"%%ImageData: %d %d " % im.size)
+        fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
+
+    # image header
+    fp.write(b"gsave\n")
+    fp.write(b"10 dict begin\n")
+    fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
+    fp.write(b"%d %d scale\n" % im.size)
+    fp.write(b"%d %d 8\n" % im.size)  # <= bits
+    fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
+    fp.write(b"{ currentfile buf readhexstring pop } bind\n")
+    fp.write(operator[2] + b"\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
+
+    fp.write(b"\n%%%%EndBinary\n")
+    fp.write(b"grestore end\n")
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+# --------------------------------------------------------------------
+
+
+Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
+
+Image.register_save(EpsImageFile.format, _save)
+
+Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
+
+Image.register_mime(EpsImageFile.format, "application/postscript")

venv/Lib/site-packages/PIL/ExifTags.py

@@ -0,0 +1,381 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# EXIF tags
+#
+# Copyright (c) 2003 by Secret Labs AB
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+This module provides constants and clear-text names for various
+well-known EXIF tags.
+"""
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class Base(IntEnum):
+    # possibly incomplete
+    InteropIndex = 0x0001
+    ProcessingSoftware = 0x000B
+    NewSubfileType = 0x00FE
+    SubfileType = 0x00FF
+    ImageWidth = 0x0100
+    ImageLength = 0x0101
+    BitsPerSample = 0x0102
+    Compression = 0x0103
+    PhotometricInterpretation = 0x0106
+    Thresholding = 0x0107
+    CellWidth = 0x0108
+    CellLength = 0x0109
+    FillOrder = 0x010A
+    DocumentName = 0x010D
+    ImageDescription = 0x010E
+    Make = 0x010F
+    Model = 0x0110
+    StripOffsets = 0x0111
+    Orientation = 0x0112
+    SamplesPerPixel = 0x0115
+    RowsPerStrip = 0x0116
+    StripByteCounts = 0x0117
+    MinSampleValue = 0x0118
+    MaxSampleValue = 0x0119
+    XResolution = 0x011A
+    YResolution = 0x011B
+    PlanarConfiguration = 0x011C
+    PageName = 0x011D
+    FreeOffsets = 0x0120
+    FreeByteCounts = 0x0121
+    GrayResponseUnit = 0x0122
+    GrayResponseCurve = 0x0123
+    T4Options = 0x0124
+    T6Options = 0x0125
+    ResolutionUnit = 0x0128
+    PageNumber = 0x0129
+    TransferFunction = 0x012D
+    Software = 0x0131
+    DateTime = 0x0132
+    Artist = 0x013B
+    HostComputer = 0x013C
+    Predictor = 0x013D
+    WhitePoint = 0x013E
+    PrimaryChromaticities = 0x013F
+    ColorMap = 0x0140
+    HalftoneHints = 0x0141
+    TileWidth = 0x0142
+    TileLength = 0x0143
+    TileOffsets = 0x0144
+    TileByteCounts = 0x0145
+    SubIFDs = 0x014A
+    InkSet = 0x014C
+    InkNames = 0x014D
+    NumberOfInks = 0x014E
+    DotRange = 0x0150
+    TargetPrinter = 0x0151
+    ExtraSamples = 0x0152
+    SampleFormat = 0x0153
+    SMinSampleValue = 0x0154
+    SMaxSampleValue = 0x0155
+    TransferRange = 0x0156
+    ClipPath = 0x0157
+    XClipPathUnits = 0x0158
+    YClipPathUnits = 0x0159
+    Indexed = 0x015A
+    JPEGTables = 0x015B
+    OPIProxy = 0x015F
+    JPEGProc = 0x0200
+    JpegIFOffset = 0x0201
+    JpegIFByteCount = 0x0202
+    JpegRestartInterval = 0x0203
+    JpegLosslessPredictors = 0x0205
+    JpegPointTransforms = 0x0206
+    JpegQTables = 0x0207
+    JpegDCTables = 0x0208
+    JpegACTables = 0x0209
+    YCbCrCoefficients = 0x0211
+    YCbCrSubSampling = 0x0212
+    YCbCrPositioning = 0x0213
+    ReferenceBlackWhite = 0x0214
+    XMLPacket = 0x02BC
+    RelatedImageFileFormat = 0x1000
+    RelatedImageWidth = 0x1001
+    RelatedImageLength = 0x1002
+    Rating = 0x4746
+    RatingPercent = 0x4749
+    ImageID = 0x800D
+    CFARepeatPatternDim = 0x828D
+    BatteryLevel = 0x828F
+    Copyright = 0x8298
+    ExposureTime = 0x829A
+    FNumber = 0x829D
+    IPTCNAA = 0x83BB
+    ImageResources = 0x8649
+    ExifOffset = 0x8769
+    InterColorProfile = 0x8773
+    ExposureProgram = 0x8822
+    SpectralSensitivity = 0x8824
+    GPSInfo = 0x8825
+    ISOSpeedRatings = 0x8827
+    OECF = 0x8828
+    Interlace = 0x8829
+    TimeZoneOffset = 0x882A
+    SelfTimerMode = 0x882B
+    SensitivityType = 0x8830
+    StandardOutputSensitivity = 0x8831
+    RecommendedExposureIndex = 0x8832
+    ISOSpeed = 0x8833
+    ISOSpeedLatitudeyyy = 0x8834
+    ISOSpeedLatitudezzz = 0x8835
+    ExifVersion = 0x9000
+    DateTimeOriginal = 0x9003
+    DateTimeDigitized = 0x9004
+    OffsetTime = 0x9010
+    OffsetTimeOriginal = 0x9011
+    OffsetTimeDigitized = 0x9012
+    ComponentsConfiguration = 0x9101
+    CompressedBitsPerPixel = 0x9102
+    ShutterSpeedValue = 0x9201
+    ApertureValue = 0x9202
+    BrightnessValue = 0x9203
+    ExposureBiasValue = 0x9204
+    MaxApertureValue = 0x9205
+    SubjectDistance = 0x9206
+    MeteringMode = 0x9207
+    LightSource = 0x9208
+    Flash = 0x9209
+    FocalLength = 0x920A
+    Noise = 0x920D
+    ImageNumber = 0x9211
+    SecurityClassification = 0x9212
+    ImageHistory = 0x9213
+    TIFFEPStandardID = 0x9216
+    MakerNote = 0x927C
+    UserComment = 0x9286
+    SubsecTime = 0x9290
+    SubsecTimeOriginal = 0x9291
+    SubsecTimeDigitized = 0x9292
+    AmbientTemperature = 0x9400
+    Humidity = 0x9401
+    Pressure = 0x9402
+    WaterDepth = 0x9403
+    Acceleration = 0x9404
+    CameraElevationAngle = 0x9405
+    XPTitle = 0x9C9B
+    XPComment = 0x9C9C
+    XPAuthor = 0x9C9D
+    XPKeywords = 0x9C9E
+    XPSubject = 0x9C9F
+    FlashPixVersion = 0xA000
+    ColorSpace = 0xA001
+    ExifImageWidth = 0xA002
+    ExifImageHeight = 0xA003
+    RelatedSoundFile = 0xA004
+    ExifInteroperabilityOffset = 0xA005
+    FlashEnergy = 0xA20B
+    SpatialFrequencyResponse = 0xA20C
+    FocalPlaneXResolution = 0xA20E
+    FocalPlaneYResolution = 0xA20F
+    FocalPlaneResolutionUnit = 0xA210
+    SubjectLocation = 0xA214
+    ExposureIndex = 0xA215
+    SensingMethod = 0xA217
+    FileSource = 0xA300
+    SceneType = 0xA301
+    CFAPattern = 0xA302
+    CustomRendered = 0xA401
+    ExposureMode = 0xA402
+    WhiteBalance = 0xA403
+    DigitalZoomRatio = 0xA404
+    FocalLengthIn35mmFilm = 0xA405
+    SceneCaptureType = 0xA406
+    GainControl = 0xA407
+    Contrast = 0xA408
+    Saturation = 0xA409
+    Sharpness = 0xA40A
+    DeviceSettingDescription = 0xA40B
+    SubjectDistanceRange = 0xA40C
+    ImageUniqueID = 0xA420
+    CameraOwnerName = 0xA430
+    BodySerialNumber = 0xA431
+    LensSpecification = 0xA432
+    LensMake = 0xA433
+    LensModel = 0xA434
+    LensSerialNumber = 0xA435
+    CompositeImage = 0xA460
+    CompositeImageCount = 0xA461
+    CompositeImageExposureTimes = 0xA462
+    Gamma = 0xA500
+    PrintImageMatching = 0xC4A5
+    DNGVersion = 0xC612
+    DNGBackwardVersion = 0xC613
+    UniqueCameraModel = 0xC614
+    LocalizedCameraModel = 0xC615
+    CFAPlaneColor = 0xC616
+    CFALayout = 0xC617
+    LinearizationTable = 0xC618
+    BlackLevelRepeatDim = 0xC619
+    BlackLevel = 0xC61A
+    BlackLevelDeltaH = 0xC61B
+    BlackLevelDeltaV = 0xC61C
+    WhiteLevel = 0xC61D
+    DefaultScale = 0xC61E
+    DefaultCropOrigin = 0xC61F
+    DefaultCropSize = 0xC620
+    ColorMatrix1 = 0xC621
+    ColorMatrix2 = 0xC622
+    CameraCalibration1 = 0xC623
+    CameraCalibration2 = 0xC624
+    ReductionMatrix1 = 0xC625
+    ReductionMatrix2 = 0xC626
+    AnalogBalance = 0xC627
+    AsShotNeutral = 0xC628
+    AsShotWhiteXY = 0xC629
+    BaselineExposure = 0xC62A
+    BaselineNoise = 0xC62B
+    BaselineSharpness = 0xC62C
+    BayerGreenSplit = 0xC62D
+    LinearResponseLimit = 0xC62E
+    CameraSerialNumber = 0xC62F
+    LensInfo = 0xC630
+    ChromaBlurRadius = 0xC631
+    AntiAliasStrength = 0xC632
+    ShadowScale = 0xC633
+    DNGPrivateData = 0xC634
+    MakerNoteSafety = 0xC635
+    CalibrationIlluminant1 = 0xC65A
+    CalibrationIlluminant2 = 0xC65B
+    BestQualityScale = 0xC65C
+    RawDataUniqueID = 0xC65D
+    OriginalRawFileName = 0xC68B
+    OriginalRawFileData = 0xC68C
+    ActiveArea = 0xC68D
+    MaskedAreas = 0xC68E
+    AsShotICCProfile = 0xC68F
+    AsShotPreProfileMatrix = 0xC690
+    CurrentICCProfile = 0xC691
+    CurrentPreProfileMatrix = 0xC692
+    ColorimetricReference = 0xC6BF
+    CameraCalibrationSignature = 0xC6F3
+    ProfileCalibrationSignature = 0xC6F4
+    AsShotProfileName = 0xC6F6
+    NoiseReductionApplied = 0xC6F7
+    ProfileName = 0xC6F8
+    ProfileHueSatMapDims = 0xC6F9
+    ProfileHueSatMapData1 = 0xC6FA
+    ProfileHueSatMapData2 = 0xC6FB
+    ProfileToneCurve = 0xC6FC
+    ProfileEmbedPolicy = 0xC6FD
+    ProfileCopyright = 0xC6FE
+    ForwardMatrix1 = 0xC714
+    ForwardMatrix2 = 0xC715
+    PreviewApplicationName = 0xC716
+    PreviewApplicationVersion = 0xC717
+    PreviewSettingsName = 0xC718
+    PreviewSettingsDigest = 0xC719
+    PreviewColorSpace = 0xC71A
+    PreviewDateTime = 0xC71B
+    RawImageDigest = 0xC71C
+    OriginalRawFileDigest = 0xC71D
+    SubTileBlockSize = 0xC71E
+    RowInterleaveFactor = 0xC71F
+    ProfileLookTableDims = 0xC725
+    ProfileLookTableData = 0xC726
+    OpcodeList1 = 0xC740
+    OpcodeList2 = 0xC741
+    OpcodeList3 = 0xC74E
+    NoiseProfile = 0xC761
+
+
+"""Maps EXIF tags to tag names."""
+TAGS = {
+    **{i.value: i.name for i in Base},
+    0x920C: "SpatialFrequencyResponse",
+    0x9214: "SubjectLocation",
+    0x9215: "ExposureIndex",
+    0x828E: "CFAPattern",
+    0x920B: "FlashEnergy",
+    0x9216: "TIFF/EPStandardID",
+}
+
+
+class GPS(IntEnum):
+    GPSVersionID = 0
+    GPSLatitudeRef = 1
+    GPSLatitude = 2
+    GPSLongitudeRef = 3
+    GPSLongitude = 4
+    GPSAltitudeRef = 5
+    GPSAltitude = 6
+    GPSTimeStamp = 7
+    GPSSatellites = 8
+    GPSStatus = 9
+    GPSMeasureMode = 10
+    GPSDOP = 11
+    GPSSpeedRef = 12
+    GPSSpeed = 13
+    GPSTrackRef = 14
+    GPSTrack = 15
+    GPSImgDirectionRef = 16
+    GPSImgDirection = 17
+    GPSMapDatum = 18
+    GPSDestLatitudeRef = 19
+    GPSDestLatitude = 20
+    GPSDestLongitudeRef = 21
+    GPSDestLongitude = 22
+    GPSDestBearingRef = 23
+    GPSDestBearing = 24
+    GPSDestDistanceRef = 25
+    GPSDestDistance = 26
+    GPSProcessingMethod = 27
+    GPSAreaInformation = 28
+    GPSDateStamp = 29
+    GPSDifferential = 30
+    GPSHPositioningError = 31
+
+
+"""Maps EXIF GPS tags to tag names."""
+GPSTAGS = {i.value: i.name for i in GPS}
+
+
+class Interop(IntEnum):
+    InteropIndex = 1
+    InteropVersion = 2
+    RelatedImageFileFormat = 4096
+    RelatedImageWidth = 4097
+    RleatedImageHeight = 4098
+
+
+class IFD(IntEnum):
+    Exif = 34665
+    GPSInfo = 34853
+    Makernote = 37500
+    Interop = 40965
+    IFD1 = -1
+
+
+class LightSource(IntEnum):
+    Unknown = 0
+    Daylight = 1
+    Fluorescent = 2
+    Tungsten = 3
+    Flash = 4
+    Fine = 9
+    Cloudy = 10
+    Shade = 11
+    DaylightFluorescent = 12
+    DayWhiteFluorescent = 13
+    CoolWhiteFluorescent = 14
+    WhiteFluorescent = 15
+    StandardLightA = 17
+    StandardLightB = 18
+    StandardLightC = 19
+    D55 = 20
+    D65 = 21
+    D75 = 22
+    D50 = 23
+    ISO = 24
+    Other = 255

venv/Lib/site-packages/PIL/FitsImagePlugin.py

@@ -0,0 +1,148 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# FITS file handling
+#
+# Copyright (c) 1998-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import gzip
+import math
+
+from . import Image, ImageFile
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix[:6] == b"SIMPLE"
+
+
+class FitsImageFile(ImageFile.ImageFile):
+    format = "FITS"
+    format_description = "FITS"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+
+        headers: dict[bytes, bytes] = {}
+        header_in_progress = False
+        decoder_name = ""
+        while True:
+            header = self.fp.read(80)
+            if not header:
+                msg = "Truncated FITS file"
+                raise OSError(msg)
+            keyword = header[:8].strip()
+            if keyword in (b"SIMPLE", b"XTENSION"):
+                header_in_progress = True
+            elif headers and not header_in_progress:
+                # This is now a data unit
+                break
+            elif keyword == b"END":
+                # Seek to the end of the header unit
+                self.fp.seek(math.ceil(self.fp.tell() / 2880) * 2880)
+                if not decoder_name:
+                    decoder_name, offset, args = self._parse_headers(headers)
+
+                header_in_progress = False
+                continue
+
+            if decoder_name:
+                # Keep going to read past the headers
+                continue
+
+            value = header[8:].split(b"/")[0].strip()
+            if value.startswith(b"="):
+                value = value[1:].strip()
+            if not headers and (not _accept(keyword) or value != b"T"):
+                msg = "Not a FITS file"
+                raise SyntaxError(msg)
+            headers[keyword] = value
+
+        if not decoder_name:
+            msg = "No image data"
+            raise ValueError(msg)
+
+        offset += self.fp.tell() - 80
+        self.tile = [(decoder_name, (0, 0) + self.size, offset, args)]
+
+    def _get_size(
+        self, headers: dict[bytes, bytes], prefix: bytes
+    ) -> tuple[int, int] | None:
+        naxis = int(headers[prefix + b"NAXIS"])
+        if naxis == 0:
+            return None
+
+        if naxis == 1:
+            return 1, int(headers[prefix + b"NAXIS1"])
+        else:
+            return int(headers[prefix + b"NAXIS1"]), int(headers[prefix + b"NAXIS2"])
+
+    def _parse_headers(
+        self, headers: dict[bytes, bytes]
+    ) -> tuple[str, int, tuple[str | int, ...]]:
+        prefix = b""
+        decoder_name = "raw"
+        offset = 0
+        if (
+            headers.get(b"XTENSION") == b"'BINTABLE'"
+            and headers.get(b"ZIMAGE") == b"T"
+            and headers[b"ZCMPTYPE"] == b"'GZIP_1  '"
+        ):
+            no_prefix_size = self._get_size(headers, prefix) or (0, 0)
+            number_of_bits = int(headers[b"BITPIX"])
+            offset = no_prefix_size[0] * no_prefix_size[1] * (number_of_bits // 8)
+
+            prefix = b"Z"
+            decoder_name = "fits_gzip"
+
+        size = self._get_size(headers, prefix)
+        if not size:
+            return "", 0, ()
+
+        self._size = size
+
+        number_of_bits = int(headers[prefix + b"BITPIX"])
+        if number_of_bits == 8:
+            self._mode = "L"
+        elif number_of_bits == 16:
+            self._mode = "I;16"
+        elif number_of_bits == 32:
+            self._mode = "I"
+        elif number_of_bits in (-32, -64):
+            self._mode = "F"
+
+        args = (self.mode, 0, -1) if decoder_name == "raw" else (number_of_bits,)
+        return decoder_name, offset, args
+
+
+class FitsGzipDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer):
+        assert self.fd is not None
+        value = gzip.decompress(self.fd.read())
+
+        rows = []
+        offset = 0
+        number_of_bits = min(self.args[0] // 8, 4)
+        for y in range(self.state.ysize):
+            row = bytearray()
+            for x in range(self.state.xsize):
+                row += value[offset + (4 - number_of_bits) : offset + 4]
+                offset += 4
+            rows.append(row)
+        self.set_as_raw(bytes([pixel for row in rows[::-1] for pixel in row]))
+        return -1, 0
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(FitsImageFile.format, FitsImageFile, _accept)
+Image.register_decoder("fits_gzip", FitsGzipDecoder)
+
+Image.register_extensions(FitsImageFile.format, [".fit", ".fits"])

venv/Lib/site-packages/PIL/FliImagePlugin.py

@@ -0,0 +1,174 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FLI/FLC file handling.
+#
+# History:
+#       95-09-01 fl     Created
+#       97-01-03 fl     Fixed parser, setup decoder tile
+#       98-07-15 fl     Renamed offset attribute to avoid name clash
+#
+# Copyright (c) Secret Labs AB 1997-98.
+# Copyright (c) Fredrik Lundh 1995-97.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import i32le as i32
+from ._binary import o8
+
+#
+# decoder
+
+
+def _accept(prefix):
+    return (
+        len(prefix) >= 6
+        and i16(prefix, 4) in [0xAF11, 0xAF12]
+        and i16(prefix, 14) in [0, 3]  # flags
+    )
+
+
+##
+# Image plugin for the FLI/FLC animation format.  Use the <b>seek</b>
+# method to load individual frames.
+
+
+class FliImageFile(ImageFile.ImageFile):
+    format = "FLI"
+    format_description = "Autodesk FLI/FLC Animation"
+    _close_exclusive_fp_after_loading = False
+
+    def _open(self):
+        # HEAD
+        s = self.fp.read(128)
+        if not (_accept(s) and s[20:22] == b"\x00\x00"):
+            msg = "not an FLI/FLC file"
+            raise SyntaxError(msg)
+
+        # frames
+        self.n_frames = i16(s, 6)
+        self.is_animated = self.n_frames > 1
+
+        # image characteristics
+        self._mode = "P"
+        self._size = i16(s, 8), i16(s, 10)
+
+        # animation speed
+        duration = i32(s, 16)
+        magic = i16(s, 4)
+        if magic == 0xAF11:
+            duration = (duration * 1000) // 70
+        self.info["duration"] = duration
+
+        # look for palette
+        palette = [(a, a, a) for a in range(256)]
+
+        s = self.fp.read(16)
+
+        self.__offset = 128
+
+        if i16(s, 4) == 0xF100:
+            # prefix chunk; ignore it
+            self.__offset = self.__offset + i32(s)
+            self.fp.seek(self.__offset)
+            s = self.fp.read(16)
+
+        if i16(s, 4) == 0xF1FA:
+            # look for palette chunk
+            number_of_subchunks = i16(s, 6)
+            chunk_size = None
+            for _ in range(number_of_subchunks):
+                if chunk_size is not None:
+                    self.fp.seek(chunk_size - 6, os.SEEK_CUR)
+                s = self.fp.read(6)
+                chunk_type = i16(s, 4)
+                if chunk_type in (4, 11):
+                    self._palette(palette, 2 if chunk_type == 11 else 0)
+                    break
+                chunk_size = i32(s)
+                if not chunk_size:
+                    break
+
+        palette = [o8(r) + o8(g) + o8(b) for (r, g, b) in palette]
+        self.palette = ImagePalette.raw("RGB", b"".join(palette))
+
+        # set things up to decode first frame
+        self.__frame = -1
+        self._fp = self.fp
+        self.__rewind = self.fp.tell()
+        self.seek(0)
+
+    def _palette(self, palette, shift):
+        # load palette
+
+        i = 0
+        for e in range(i16(self.fp.read(2))):
+            s = self.fp.read(2)
+            i = i + s[0]
+            n = s[1]
+            if n == 0:
+                n = 256
+            s = self.fp.read(n * 3)
+            for n in range(0, len(s), 3):
+                r = s[n] << shift
+                g = s[n + 1] << shift
+                b = s[n + 2] << shift
+                palette[i] = (r, g, b)
+                i += 1
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self._seek(0)
+
+        for f in range(self.__frame + 1, frame + 1):
+            self._seek(f)
+
+    def _seek(self, frame):
+        if frame == 0:
+            self.__frame = -1
+            self._fp.seek(self.__rewind)
+            self.__offset = 128
+        else:
+            # ensure that the previous frame was loaded
+            self.load()
+
+        if frame != self.__frame + 1:
+            msg = f"cannot seek to frame {frame}"
+            raise ValueError(msg)
+        self.__frame = frame
+
+        # move to next frame
+        self.fp = self._fp
+        self.fp.seek(self.__offset)
+
+        s = self.fp.read(4)
+        if not s:
+            msg = "missing frame size"
+            raise EOFError(msg)
+
+        framesize = i32(s)
+
+        self.decodermaxblock = framesize
+        self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
+
+        self.__offset += framesize
+
+    def tell(self):
+        return self.__frame
+
+
+#
+# registry
+
+Image.register_open(FliImageFile.format, FliImageFile, _accept)
+
+Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

venv/Lib/site-packages/PIL/FontFile.py

@@ -0,0 +1,134 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# base class for raster font file parsers
+#
+# history:
+# 1997-06-05 fl   created
+# 1997-08-19 fl   restrict image width
+#
+# Copyright (c) 1997-1998 by Secret Labs AB
+# Copyright (c) 1997-1998 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import BinaryIO
+
+from . import Image, _binary
+
+WIDTH = 800
+
+
+def puti16(
+    fp: BinaryIO, values: tuple[int, int, int, int, int, int, int, int, int, int]
+) -> None:
+    """Write network order (big-endian) 16-bit sequence"""
+    for v in values:
+        if v < 0:
+            v += 65536
+        fp.write(_binary.o16be(v))
+
+
+class FontFile:
+    """Base class for raster font file handlers."""
+
+    bitmap: Image.Image | None = None
+
+    def __init__(self) -> None:
+        self.info: dict[bytes, bytes | int] = {}
+        self.glyph: list[
+            tuple[
+                tuple[int, int],
+                tuple[int, int, int, int],
+                tuple[int, int, int, int],
+                Image.Image,
+            ]
+            | None
+        ] = [None] * 256
+
+    def __getitem__(self, ix: int) -> (
+        tuple[
+            tuple[int, int],
+            tuple[int, int, int, int],
+            tuple[int, int, int, int],
+            Image.Image,
+        ]
+        | None
+    ):
+        return self.glyph[ix]
+
+    def compile(self) -> None:
+        """Create metrics and bitmap"""
+
+        if self.bitmap:
+            return
+
+        # create bitmap large enough to hold all data
+        h = w = maxwidth = 0
+        lines = 1
+        for glyph in self.glyph:
+            if glyph:
+                d, dst, src, im = glyph
+                h = max(h, src[3] - src[1])
+                w = w + (src[2] - src[0])
+                if w > WIDTH:
+                    lines += 1
+                    w = src[2] - src[0]
+                maxwidth = max(maxwidth, w)
+
+        xsize = maxwidth
+        ysize = lines * h
+
+        if xsize == 0 and ysize == 0:
+            return
+
+        self.ysize = h
+
+        # paste glyphs into bitmap
+        self.bitmap = Image.new("1", (xsize, ysize))
+        self.metrics: list[
+            tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]]
+            | None
+        ] = [None] * 256
+        x = y = 0
+        for i in range(256):
+            glyph = self[i]
+            if glyph:
+                d, dst, src, im = glyph
+                xx = src[2] - src[0]
+                x0, y0 = x, y
+                x = x + xx
+                if x > WIDTH:
+                    x, y = 0, y + h
+                    x0, y0 = x, y
+                    x = xx
+                s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
+                self.bitmap.paste(im.crop(src), s)
+                self.metrics[i] = d, dst, s
+
+    def save(self, filename: str) -> None:
+        """Save font"""
+
+        self.compile()
+
+        # font data
+        if not self.bitmap:
+            msg = "No bitmap created"
+            raise ValueError(msg)
+        self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
+
+        # font metrics
+        with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
+            fp.write(b"PILfont\n")
+            fp.write(f";;;;;;{self.ysize};\n".encode("ascii"))  # HACK!!!
+            fp.write(b"DATA\n")
+            for id in range(256):
+                m = self.metrics[id]
+                if not m:
+                    puti16(fp, (0,) * 10)
+                else:
+                    puti16(fp, m[0] + m[1] + m[2])

venv/Lib/site-packages/PIL/FpxImagePlugin.py

@@ -0,0 +1,255 @@
+#
+# THIS IS WORK IN PROGRESS
+#
+# The Python Imaging Library.
+# $Id$
+#
+# FlashPix support for PIL
+#
+# History:
+# 97-01-25 fl   Created (reads uncompressed RGB images only)
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import olefile
+
+from . import Image, ImageFile
+from ._binary import i32le as i32
+
+# we map from colour field tuples to (mode, rawmode) descriptors
+MODES = {
+    # opacity
+    (0x00007FFE,): ("A", "L"),
+    # monochrome
+    (0x00010000,): ("L", "L"),
+    (0x00018000, 0x00017FFE): ("RGBA", "LA"),
+    # photo YCC
+    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
+    (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
+    # standard RGB (NIFRGB)
+    (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
+    (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
+}
+
+
+#
+# --------------------------------------------------------------------
+
+
+def _accept(prefix):
+    return prefix[:8] == olefile.MAGIC
+
+
+##
+# Image plugin for the FlashPix images.
+
+
+class FpxImageFile(ImageFile.ImageFile):
+    format = "FPX"
+    format_description = "FlashPix"
+
+    def _open(self):
+        #
+        # read the OLE directory and see if this is a likely
+        # to be a FlashPix file
+
+        try:
+            self.ole = olefile.OleFileIO(self.fp)
+        except OSError as e:
+            msg = "not an FPX file; invalid OLE file"
+            raise SyntaxError(msg) from e
+
+        if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
+            msg = "not an FPX file; bad root CLSID"
+            raise SyntaxError(msg)
+
+        self._open_index(1)
+
+    def _open_index(self, index=1):
+        #
+        # get the Image Contents Property Set
+
+        prop = self.ole.getproperties(
+            [f"Data Object Store {index:06d}", "\005Image Contents"]
+        )
+
+        # size (highest resolution)
+
+        self._size = prop[0x1000002], prop[0x1000003]
+
+        size = max(self.size)
+        i = 1
+        while size > 64:
+            size = size / 2
+            i += 1
+        self.maxid = i - 1
+
+        # mode.  instead of using a single field for this, flashpix
+        # requires you to specify the mode for each channel in each
+        # resolution subimage, and leaves it to the decoder to make
+        # sure that they all match.  for now, we'll cheat and assume
+        # that this is always the case.
+
+        id = self.maxid << 16
+
+        s = prop[0x2000002 | id]
+
+        bands = i32(s, 4)
+        if bands > 4:
+            msg = "Invalid number of bands"
+            raise OSError(msg)
+
+        # note: for now, we ignore the "uncalibrated" flag
+        colors = tuple(i32(s, 8 + i * 4) & 0x7FFFFFFF for i in range(bands))
+
+        self._mode, self.rawmode = MODES[colors]
+
+        # load JPEG tables, if any
+        self.jpeg = {}
+        for i in range(256):
+            id = 0x3000001 | (i << 16)
+            if id in prop:
+                self.jpeg[i] = prop[id]
+
+        self._open_subimage(1, self.maxid)
+
+    def _open_subimage(self, index=1, subimage=0):
+        #
+        # setup tile descriptors for a given subimage
+
+        stream = [
+            f"Data Object Store {index:06d}",
+            f"Resolution {subimage:04d}",
+            "Subimage 0000 Header",
+        ]
+
+        fp = self.ole.openstream(stream)
+
+        # skip prefix
+        fp.read(28)
+
+        # header stream
+        s = fp.read(36)
+
+        size = i32(s, 4), i32(s, 8)
+        # tilecount = i32(s, 12)
+        tilesize = i32(s, 16), i32(s, 20)
+        # channels = i32(s, 24)
+        offset = i32(s, 28)
+        length = i32(s, 32)
+
+        if size != self.size:
+            msg = "subimage mismatch"
+            raise OSError(msg)
+
+        # get tile descriptors
+        fp.seek(28 + offset)
+        s = fp.read(i32(s, 12) * length)
+
+        x = y = 0
+        xsize, ysize = size
+        xtile, ytile = tilesize
+        self.tile = []
+
+        for i in range(0, len(s), length):
+            x1 = min(xsize, x + xtile)
+            y1 = min(ysize, y + ytile)
+
+            compression = i32(s, i + 8)
+
+            if compression == 0:
+                self.tile.append(
+                    (
+                        "raw",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (self.rawmode,),
+                    )
+                )
+
+            elif compression == 1:
+                # FIXME: the fill decoder is not implemented
+                self.tile.append(
+                    (
+                        "fill",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (self.rawmode, s[12:16]),
+                    )
+                )
+
+            elif compression == 2:
+                internal_color_conversion = s[14]
+                jpeg_tables = s[15]
+                rawmode = self.rawmode
+
+                if internal_color_conversion:
+                    # The image is stored as usual (usually YCbCr).
+                    if rawmode == "RGBA":
+                        # For "RGBA", data is stored as YCbCrA based on
+                        # negative RGB. The following trick works around
+                        # this problem :
+                        jpegmode, rawmode = "YCbCrK", "CMYK"
+                    else:
+                        jpegmode = None  # let the decoder decide
+
+                else:
+                    # The image is stored as defined by rawmode
+                    jpegmode = rawmode
+
+                self.tile.append(
+                    (
+                        "jpeg",
+                        (x, y, x1, y1),
+                        i32(s, i) + 28,
+                        (rawmode, jpegmode),
+                    )
+                )
+
+                # FIXME: jpeg tables are tile dependent; the prefix
+                # data must be placed in the tile descriptor itself!
+
+                if jpeg_tables:
+                    self.tile_prefix = self.jpeg[jpeg_tables]
+
+            else:
+                msg = "unknown/invalid compression"
+                raise OSError(msg)
+
+            x = x + xtile
+            if x >= xsize:
+                x, y = 0, y + ytile
+                if y >= ysize:
+                    break  # isn't really required
+
+        self.stream = stream
+        self._fp = self.fp
+        self.fp = None
+
+    def load(self):
+        if not self.fp:
+            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
+
+        return ImageFile.ImageFile.load(self)
+
+    def close(self):
+        self.ole.close()
+        super().close()
+
+    def __exit__(self, *args):
+        self.ole.close()
+        super().__exit__()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
+
+Image.register_extension(FpxImageFile.format, ".fpx")

venv/Lib/site-packages/PIL/FtexImagePlugin.py

@@ -0,0 +1,115 @@
+"""
+A Pillow loader for .ftc and .ftu files (FTEX)
+Jerome Leclanche <[email protected]>
+
+The contents of this file are hereby released in the public domain (CC0)
+Full text of the CC0 license:
+  https://creativecommons.org/publicdomain/zero/1.0/
+
+Independence War 2: Edge Of Chaos - Texture File Format - 16 October 2001
+
+The textures used for 3D objects in Independence War 2: Edge Of Chaos are in a
+packed custom format called FTEX. This file format uses file extensions FTC
+and FTU.
+* FTC files are compressed textures (using standard texture compression).
+* FTU files are not compressed.
+Texture File Format
+The FTC and FTU texture files both use the same format. This
+has the following structure:
+{header}
+{format_directory}
+{data}
+Where:
+{header} = {
+    u32:magic,
+    u32:version,
+    u32:width,
+    u32:height,
+    u32:mipmap_count,
+    u32:format_count
+}
+
+* The "magic" number is "FTEX".
+* "width" and "height" are the dimensions of the texture.
+* "mipmap_count" is the number of mipmaps in the texture.
+* "format_count" is the number of texture formats (different versions of the
+same texture) in this file.
+
+{format_directory} = format_count * { u32:format, u32:where }
+
+The format value is 0 for DXT1 compressed textures and 1 for 24-bit RGB
+uncompressed textures.
+The texture data for a format starts at the position "where" in the file.
+
+Each set of texture data in the file has the following structure:
+{data} = format_count * { u32:mipmap_size, mipmap_size * { u8 } }
+* "mipmap_size" is the number of bytes in that mip level. For compressed
+textures this is the size of the texture data compressed with DXT1. For 24 bit
+uncompressed textures, this is 3 * width * height. Following this are the image
+bytes for that mipmap level.
+
+Note: All data is stored in little-Endian (Intel) byte order.
+"""
+
+from __future__ import annotations
+
+import struct
+from enum import IntEnum
+from io import BytesIO
+
+from . import Image, ImageFile
+
+MAGIC = b"FTEX"
+
+
+class Format(IntEnum):
+    DXT1 = 0
+    UNCOMPRESSED = 1
+
+
+class FtexImageFile(ImageFile.ImageFile):
+    format = "FTEX"
+    format_description = "Texture File Format (IW2:EOC)"
+
+    def _open(self):
+        if not _accept(self.fp.read(4)):
+            msg = "not an FTEX file"
+            raise SyntaxError(msg)
+        struct.unpack("<i", self.fp.read(4))  # version
+        self._size = struct.unpack("<2i", self.fp.read(8))
+        mipmap_count, format_count = struct.unpack("<2i", self.fp.read(8))
+
+        self._mode = "RGB"
+
+        # Only support single-format files.
+        # I don't know of any multi-format file.
+        assert format_count == 1
+
+        format, where = struct.unpack("<2i", self.fp.read(8))
+        self.fp.seek(where)
+        (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
+
+        data = self.fp.read(mipmap_size)
+
+        if format == Format.DXT1:
+            self._mode = "RGBA"
+            self.tile = [("bcn", (0, 0) + self.size, 0, 1)]
+        elif format == Format.UNCOMPRESSED:
+            self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
+        else:
+            msg = f"Invalid texture compression format: {repr(format)}"
+            raise ValueError(msg)
+
+        self.fp.close()
+        self.fp = BytesIO(data)
+
+    def load_seek(self, pos):
+        pass
+
+
+def _accept(prefix):
+    return prefix[:4] == MAGIC
+
+
+Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
+Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])

venv/Lib/site-packages/PIL/GbrImagePlugin.py

@@ -0,0 +1,103 @@
+#
+# The Python Imaging Library
+#
+# load a GIMP brush file
+#
+# History:
+#       96-03-14 fl     Created
+#       16-01-08 es     Version 2
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1996.
+# Copyright (c) Eric Soroos 2016.
+#
+# See the README file for information on usage and redistribution.
+#
+#
+# See https://github.com/GNOME/gimp/blob/mainline/devel-docs/gbr.txt for
+# format documentation.
+#
+# This code Interprets version 1 and 2 .gbr files.
+# Version 1 files are obsolete, and should not be used for new
+#   brushes.
+# Version 2 files are saved by GIMP v2.8 (at least)
+# Version 3 files have a format specifier of 18 for 16bit floats in
+#   the color depth field. This is currently unsupported by Pillow.
+from __future__ import annotations
+
+from . import Image, ImageFile
+from ._binary import i32be as i32
+
+
+def _accept(prefix):
+    return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
+
+
+##
+# Image plugin for the GIMP brush format.
+
+
+class GbrImageFile(ImageFile.ImageFile):
+    format = "GBR"
+    format_description = "GIMP brush file"
+
+    def _open(self):
+        header_size = i32(self.fp.read(4))
+        if header_size < 20:
+            msg = "not a GIMP brush"
+            raise SyntaxError(msg)
+        version = i32(self.fp.read(4))
+        if version not in (1, 2):
+            msg = f"Unsupported GIMP brush version: {version}"
+            raise SyntaxError(msg)
+
+        width = i32(self.fp.read(4))
+        height = i32(self.fp.read(4))
+        color_depth = i32(self.fp.read(4))
+        if width <= 0 or height <= 0:
+            msg = "not a GIMP brush"
+            raise SyntaxError(msg)
+        if color_depth not in (1, 4):
+            msg = f"Unsupported GIMP brush color depth: {color_depth}"
+            raise SyntaxError(msg)
+
+        if version == 1:
+            comment_length = header_size - 20
+        else:
+            comment_length = header_size - 28
+            magic_number = self.fp.read(4)
+            if magic_number != b"GIMP":
+                msg = "not a GIMP brush, bad magic number"
+                raise SyntaxError(msg)
+            self.info["spacing"] = i32(self.fp.read(4))
+
+        comment = self.fp.read(comment_length)[:-1]
+
+        if color_depth == 1:
+            self._mode = "L"
+        else:
+            self._mode = "RGBA"
+
+        self._size = width, height
+
+        self.info["comment"] = comment
+
+        # Image might not be small
+        Image._decompression_bomb_check(self.size)
+
+        # Data is an uncompressed block of w * h * bytes/pixel
+        self._data_size = width * height * color_depth
+
+    def load(self):
+        if not self.im:
+            self.im = Image.core.new(self.mode, self.size)
+            self.frombytes(self.fp.read(self._data_size))
+        return Image.Image.load(self)
+
+
+#
+# registry
+
+
+Image.register_open(GbrImageFile.format, GbrImageFile, _accept)
+Image.register_extension(GbrImageFile.format, ".gbr")

venv/Lib/site-packages/PIL/GdImageFile.py

@@ -0,0 +1,102 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# GD file handling
+#
+# History:
+# 1996-04-12 fl   Created
+#
+# Copyright (c) 1997 by Secret Labs AB.
+# Copyright (c) 1996 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+"""
+.. note::
+    This format cannot be automatically recognized, so the
+    class is not registered for use with :py:func:`PIL.Image.open()`.  To open a
+    gd file, use the :py:func:`PIL.GdImageFile.open()` function instead.
+
+.. warning::
+    THE GD FORMAT IS NOT DESIGNED FOR DATA INTERCHANGE.  This
+    implementation is provided for convenience and demonstrational
+    purposes only.
+"""
+from __future__ import annotations
+
+from typing import IO
+
+from . import ImageFile, ImagePalette, UnidentifiedImageError
+from ._binary import i16be as i16
+from ._binary import i32be as i32
+from ._typing import StrOrBytesPath
+
+
+class GdImageFile(ImageFile.ImageFile):
+    """
+    Image plugin for the GD uncompressed format.  Note that this format
+    is not supported by the standard :py:func:`PIL.Image.open()` function.  To use
+    this plugin, you have to import the :py:mod:`PIL.GdImageFile` module and
+    use the :py:func:`PIL.GdImageFile.open()` function.
+    """
+
+    format = "GD"
+    format_description = "GD uncompressed images"
+
+    def _open(self) -> None:
+        # Header
+        assert self.fp is not None
+
+        s = self.fp.read(1037)
+
+        if i16(s) not in [65534, 65535]:
+            msg = "Not a valid GD 2.x .gd file"
+            raise SyntaxError(msg)
+
+        self._mode = "L"  # FIXME: "P"
+        self._size = i16(s, 2), i16(s, 4)
+
+        true_color = s[6]
+        true_color_offset = 2 if true_color else 0
+
+        # transparency index
+        tindex = i32(s, 7 + true_color_offset)
+        if tindex < 256:
+            self.info["transparency"] = tindex
+
+        self.palette = ImagePalette.raw(
+            "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4]
+        )
+
+        self.tile = [
+            (
+                "raw",
+                (0, 0) + self.size,
+                7 + true_color_offset + 4 + 256 * 4,
+                ("L", 0, 1),
+            )
+        ]
+
+
+def open(fp: StrOrBytesPath | IO[bytes], mode: str = "r") -> GdImageFile:
+    """
+    Load texture from a GD image file.
+
+    :param fp: GD file name, or an opened file handle.
+    :param mode: Optional mode.  In this version, if the mode argument
+        is given, it must be "r".
+    :returns: An image instance.
+    :raises OSError: If the image could not be read.
+    """
+    if mode != "r":
+        msg = "bad mode"
+        raise ValueError(msg)
+
+    try:
+        return GdImageFile(fp)
+    except SyntaxError as e:
+        msg = "cannot identify this image file"
+        raise UnidentifiedImageError(msg) from e

venv/Lib/site-packages/PIL/GifImagePlugin.py

@@ -0,0 +1,1107 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# GIF file handling
+#
+# History:
+# 1995-09-01 fl   Created
+# 1996-12-14 fl   Added interlace support
+# 1996-12-30 fl   Added animation support
+# 1997-01-05 fl   Added write support, fixed local colour map bug
+# 1997-02-23 fl   Make sure to load raster data in getdata()
+# 1997-07-05 fl   Support external decoder (0.4)
+# 1998-07-09 fl   Handle all modes when saving (0.5)
+# 1998-07-15 fl   Renamed offset attribute to avoid name clash
+# 2001-04-16 fl   Added rewind support (seek to frame 0) (0.6)
+# 2001-04-17 fl   Added palette optimization (0.7)
+# 2002-06-06 fl   Added transparency support for save (0.8)
+# 2004-02-24 fl   Disable interlacing for small images
+#
+# Copyright (c) 1997-2004 by Secret Labs AB
+# Copyright (c) 1995-2004 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import itertools
+import math
+import os
+import subprocess
+from enum import IntEnum
+
+from . import (
+    Image,
+    ImageChops,
+    ImageFile,
+    ImageMath,
+    ImageOps,
+    ImagePalette,
+    ImageSequence,
+)
+from ._binary import i16le as i16
+from ._binary import o8
+from ._binary import o16le as o16
+
+
+class LoadingStrategy(IntEnum):
+    """.. versionadded:: 9.1.0"""
+
+    RGB_AFTER_FIRST = 0
+    RGB_AFTER_DIFFERENT_PALETTE_ONLY = 1
+    RGB_ALWAYS = 2
+
+
+#: .. versionadded:: 9.1.0
+LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST
+
+# --------------------------------------------------------------------
+# Identify/read GIF files
+
+
+def _accept(prefix):
+    return prefix[:6] in [b"GIF87a", b"GIF89a"]
+
+
+##
+# Image plugin for GIF images.  This plugin supports both GIF87 and
+# GIF89 images.
+
+
+class GifImageFile(ImageFile.ImageFile):
+    format = "GIF"
+    format_description = "Compuserve GIF"
+    _close_exclusive_fp_after_loading = False
+
+    global_palette = None
+
+    def data(self):
+        s = self.fp.read(1)
+        if s and s[0]:
+            return self.fp.read(s[0])
+        return None
+
+    def _is_palette_needed(self, p):
+        for i in range(0, len(p), 3):
+            if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
+                return True
+        return False
+
+    def _open(self):
+        # Screen
+        s = self.fp.read(13)
+        if not _accept(s):
+            msg = "not a GIF file"
+            raise SyntaxError(msg)
+
+        self.info["version"] = s[:6]
+        self._size = i16(s, 6), i16(s, 8)
+        self.tile = []
+        flags = s[10]
+        bits = (flags & 7) + 1
+
+        if flags & 128:
+            # get global palette
+            self.info["background"] = s[11]
+            # check if palette contains colour indices
+            p = self.fp.read(3 << bits)
+            if self._is_palette_needed(p):
+                p = ImagePalette.raw("RGB", p)
+                self.global_palette = self.palette = p
+
+        self._fp = self.fp  # FIXME: hack
+        self.__rewind = self.fp.tell()
+        self._n_frames = None
+        self._is_animated = None
+        self._seek(0)  # get ready to read first frame
+
+    @property
+    def n_frames(self):
+        if self._n_frames is None:
+            current = self.tell()
+            try:
+                while True:
+                    self._seek(self.tell() + 1, False)
+            except EOFError:
+                self._n_frames = self.tell() + 1
+            self.seek(current)
+        return self._n_frames
+
+    @property
+    def is_animated(self):
+        if self._is_animated is None:
+            if self._n_frames is not None:
+                self._is_animated = self._n_frames != 1
+            else:
+                current = self.tell()
+                if current:
+                    self._is_animated = True
+                else:
+                    try:
+                        self._seek(1, False)
+                        self._is_animated = True
+                    except EOFError:
+                        self._is_animated = False
+
+                    self.seek(current)
+        return self._is_animated
+
+    def seek(self, frame):
+        if not self._seek_check(frame):
+            return
+        if frame < self.__frame:
+            self.im = None
+            self._seek(0)
+
+        last_frame = self.__frame
+        for f in range(self.__frame + 1, frame + 1):
+            try:
+                self._seek(f)
+            except EOFError as e:
+                self.seek(last_frame)
+                msg = "no more images in GIF file"
+                raise EOFError(msg) from e
+
+    def _seek(self, frame, update_image=True):
+        if frame == 0:
+            # rewind
+            self.__offset = 0
+            self.dispose = None
+            self.__frame = -1
+            self._fp.seek(self.__rewind)
+            self.disposal_method = 0
+            if "comment" in self.info:
+                del self.info["comment"]
+        else:
+            # ensure that the previous frame was loaded
+            if self.tile and update_image:
+                self.load()
+
+        if frame != self.__frame + 1:
+            msg = f"cannot seek to frame {frame}"
+            raise ValueError(msg)
+
+        self.fp = self._fp
+        if self.__offset:
+            # backup to last frame
+            self.fp.seek(self.__offset)
+            while self.data():
+                pass
+            self.__offset = 0
+
+        s = self.fp.read(1)
+        if not s or s == b";":
+            msg = "no more images in GIF file"
+            raise EOFError(msg)
+
+        palette = None
+
+        info = {}
+        frame_transparency = None
+        interlace = None
+        frame_dispose_extent = None
+        while True:
+            if not s:
+                s = self.fp.read(1)
+            if not s or s == b";":
+                break
+
+            elif s == b"!":
+                #
+                # extensions
+                #
+                s = self.fp.read(1)
+                block = self.data()
+                if s[0] == 249:
+                    #
+                    # graphic control extension
+                    #
+                    flags = block[0]
+                    if flags & 1:
+                        frame_transparency = block[3]
+                    info["duration"] = i16(block, 1) * 10
+
+                    # disposal method - find the value of bits 4 - 6
+                    dispose_bits = 0b00011100 & flags
+                    dispose_bits = dispose_bits >> 2
+                    if dispose_bits:
+                        # only set the dispose if it is not
+                        # unspecified. I'm not sure if this is
+                        # correct, but it seems to prevent the last
+                        # frame from looking odd for some animations
+                        self.disposal_method = dispose_bits
+                elif s[0] == 254:
+                    #
+                    # comment extension
+                    #
+                    comment = b""
+
+                    # Read this comment block
+                    while block:
+                        comment += block
+                        block = self.data()
+
+                    if "comment" in info:
+                        # If multiple comment blocks in frame, separate with \n
+                        info["comment"] += b"\n" + comment
+                    else:
+                        info["comment"] = comment
+                    s = None
+                    continue
+                elif s[0] == 255 and frame == 0:
+                    #
+                    # application extension
+                    #
+                    info["extension"] = block, self.fp.tell()
+                    if block[:11] == b"NETSCAPE2.0":
+                        block = self.data()
+                        if len(block) >= 3 and block[0] == 1:
+                            self.info["loop"] = i16(block, 1)
+                while self.data():
+                    pass
+
+            elif s == b",":
+                #
+                # local image
+                #
+                s = self.fp.read(9)
+
+                # extent
+                x0, y0 = i16(s, 0), i16(s, 2)
+                x1, y1 = x0 + i16(s, 4), y0 + i16(s, 6)
+                if (x1 > self.size[0] or y1 > self.size[1]) and update_image:
+                    self._size = max(x1, self.size[0]), max(y1, self.size[1])
+                    Image._decompression_bomb_check(self._size)
+                frame_dispose_extent = x0, y0, x1, y1
+                flags = s[8]
+
+                interlace = (flags & 64) != 0
+
+                if flags & 128:
+                    bits = (flags & 7) + 1
+                    p = self.fp.read(3 << bits)
+                    if self._is_palette_needed(p):
+                        palette = ImagePalette.raw("RGB", p)
+                    else:
+                        palette = False
+
+                # image data
+                bits = self.fp.read(1)[0]
+                self.__offset = self.fp.tell()
+                break
+            s = None
+
+        if interlace is None:
+            msg = "image not found in GIF frame"
+            raise EOFError(msg)
+
+        self.__frame = frame
+        if not update_image:
+            return
+
+        self.tile = []
+
+        if self.dispose:
+            self.im.paste(self.dispose, self.dispose_extent)
+
+        self._frame_palette = palette if palette is not None else self.global_palette
+        self._frame_transparency = frame_transparency
+        if frame == 0:
+            if self._frame_palette:
+                if LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
+                    self._mode = "RGBA" if frame_transparency is not None else "RGB"
+                else:
+                    self._mode = "P"
+            else:
+                self._mode = "L"
+
+            if not palette and self.global_palette:
+                from copy import copy
+
+                palette = copy(self.global_palette)
+            self.palette = palette
+        else:
+            if self.mode == "P":
+                if (
+                    LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
+                    or palette
+                ):
+                    self.pyaccess = None
+                    if "transparency" in self.info:
+                        self.im.putpalettealpha(self.info["transparency"], 0)
+                        self.im = self.im.convert("RGBA", Image.Dither.FLOYDSTEINBERG)
+                        self._mode = "RGBA"
+                        del self.info["transparency"]
+                    else:
+                        self._mode = "RGB"
+                        self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG)
+
+        def _rgb(color):
+            if self._frame_palette:
+                if color * 3 + 3 > len(self._frame_palette.palette):
+                    color = 0
+                color = tuple(self._frame_palette.palette[color * 3 : color * 3 + 3])
+            else:
+                color = (color, color, color)
+            return color
+
+        self.dispose_extent = frame_dispose_extent
+        try:
+            if self.disposal_method < 2:
+                # do not dispose or none specified
+                self.dispose = None
+            elif self.disposal_method == 2:
+                # replace with background colour
+
+                # only dispose the extent in this frame
+                x0, y0, x1, y1 = self.dispose_extent
+                dispose_size = (x1 - x0, y1 - y0)
+
+                Image._decompression_bomb_check(dispose_size)
+
+                # by convention, attempt to use transparency first
+                dispose_mode = "P"
+                color = self.info.get("transparency", frame_transparency)
+                if color is not None:
+                    if self.mode in ("RGB", "RGBA"):
+                        dispose_mode = "RGBA"
+                        color = _rgb(color) + (0,)
+                else:
+                    color = self.info.get("background", 0)
+                    if self.mode in ("RGB", "RGBA"):
+                        dispose_mode = "RGB"
+                        color = _rgb(color)
+                self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
+            else:
+                # replace with previous contents
+                if self.im is not None:
+                    # only dispose the extent in this frame
+                    self.dispose = self._crop(self.im, self.dispose_extent)
+                elif frame_transparency is not None:
+                    x0, y0, x1, y1 = self.dispose_extent
+                    dispose_size = (x1 - x0, y1 - y0)
+
+                    Image._decompression_bomb_check(dispose_size)
+                    dispose_mode = "P"
+                    color = frame_transparency
+                    if self.mode in ("RGB", "RGBA"):
+                        dispose_mode = "RGBA"
+                        color = _rgb(frame_transparency) + (0,)
+                    self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
+        except AttributeError:
+            pass
+
+        if interlace is not None:
+            transparency = -1
+            if frame_transparency is not None:
+                if frame == 0:
+                    if LOADING_STRATEGY != LoadingStrategy.RGB_ALWAYS:
+                        self.info["transparency"] = frame_transparency
+                elif self.mode not in ("RGB", "RGBA"):
+                    transparency = frame_transparency
+            self.tile = [
+                (
+                    "gif",
+                    (x0, y0, x1, y1),
+                    self.__offset,
+                    (bits, interlace, transparency),
+                )
+            ]
+
+        if info.get("comment"):
+            self.info["comment"] = info["comment"]
+        for k in ["duration", "extension"]:
+            if k in info:
+                self.info[k] = info[k]
+            elif k in self.info:
+                del self.info[k]
+
+    def load_prepare(self):
+        temp_mode = "P" if self._frame_palette else "L"
+        self._prev_im = None
+        if self.__frame == 0:
+            if self._frame_transparency is not None:
+                self.im = Image.core.fill(
+                    temp_mode, self.size, self._frame_transparency
+                )
+        elif self.mode in ("RGB", "RGBA"):
+            self._prev_im = self.im
+            if self._frame_palette:
+                self.im = Image.core.fill("P", self.size, self._frame_transparency or 0)
+                self.im.putpalette(*self._frame_palette.getdata())
+            else:
+                self.im = None
+        self._mode = temp_mode
+        self._frame_palette = None
+
+        super().load_prepare()
+
+    def load_end(self):
+        if self.__frame == 0:
+            if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
+                if self._frame_transparency is not None:
+                    self.im.putpalettealpha(self._frame_transparency, 0)
+                    self._mode = "RGBA"
+                else:
+                    self._mode = "RGB"
+                self.im = self.im.convert(self.mode, Image.Dither.FLOYDSTEINBERG)
+            return
+        if not self._prev_im:
+            return
+        if self._frame_transparency is not None:
+            self.im.putpalettealpha(self._frame_transparency, 0)
+            frame_im = self.im.convert("RGBA")
+        else:
+            frame_im = self.im.convert("RGB")
+        frame_im = self._crop(frame_im, self.dispose_extent)
+
+        self.im = self._prev_im
+        self._mode = self.im.mode
+        if frame_im.mode == "RGBA":
+            self.im.paste(frame_im, self.dispose_extent, frame_im)
+        else:
+            self.im.paste(frame_im, self.dispose_extent)
+
+    def tell(self):
+        return self.__frame
+
+
+# --------------------------------------------------------------------
+# Write GIF files
+
+
+RAWMODE = {"1": "L", "L": "L", "P": "P"}
+
+
+def _normalize_mode(im):
+    """
+    Takes an image (or frame), returns an image in a mode that is appropriate
+    for saving in a Gif.
+
+    It may return the original image, or it may return an image converted to
+    palette or 'L' mode.
+
+    :param im: Image object
+    :returns: Image object
+    """
+    if im.mode in RAWMODE:
+        im.load()
+        return im
+    if Image.getmodebase(im.mode) == "RGB":
+        im = im.convert("P", palette=Image.Palette.ADAPTIVE)
+        if im.palette.mode == "RGBA":
+            for rgba in im.palette.colors:
+                if rgba[3] == 0:
+                    im.info["transparency"] = im.palette.colors[rgba]
+                    break
+        return im
+    return im.convert("L")
+
+
+def _normalize_palette(im, palette, info):
+    """
+    Normalizes the palette for image.
+      - Sets the palette to the incoming palette, if provided.
+      - Ensures that there's a palette for L mode images
+      - Optimizes the palette if necessary/desired.
+
+    :param im: Image object
+    :param palette: bytes object containing the source palette, or ....
+    :param info: encoderinfo
+    :returns: Image object
+    """
+    source_palette = None
+    if palette:
+        # a bytes palette
+        if isinstance(palette, (bytes, bytearray, list)):
+            source_palette = bytearray(palette[:768])
+        if isinstance(palette, ImagePalette.ImagePalette):
+            source_palette = bytearray(palette.palette)
+
+    if im.mode == "P":
+        if not source_palette:
+            source_palette = im.im.getpalette("RGB")[:768]
+    else:  # L-mode
+        if not source_palette:
+            source_palette = bytearray(i // 3 for i in range(768))
+        im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette)
+
+    if palette:
+        used_palette_colors = []
+        for i in range(0, len(source_palette), 3):
+            source_color = tuple(source_palette[i : i + 3])
+            index = im.palette.colors.get(source_color)
+            if index in used_palette_colors:
+                index = None
+            used_palette_colors.append(index)
+        for i, index in enumerate(used_palette_colors):
+            if index is None:
+                for j in range(len(used_palette_colors)):
+                    if j not in used_palette_colors:
+                        used_palette_colors[i] = j
+                        break
+        im = im.remap_palette(used_palette_colors)
+    else:
+        used_palette_colors = _get_optimize(im, info)
+        if used_palette_colors is not None:
+            im = im.remap_palette(used_palette_colors, source_palette)
+            if "transparency" in info:
+                try:
+                    info["transparency"] = used_palette_colors.index(
+                        info["transparency"]
+                    )
+                except ValueError:
+                    del info["transparency"]
+            return im
+
+    im.palette.palette = source_palette
+    return im
+
+
+def _write_single_frame(im, fp, palette):
+    im_out = _normalize_mode(im)
+    for k, v in im_out.info.items():
+        im.encoderinfo.setdefault(k, v)
+    im_out = _normalize_palette(im_out, palette, im.encoderinfo)
+
+    for s in _get_global_header(im_out, im.encoderinfo):
+        fp.write(s)
+
+    # local image header
+    flags = 0
+    if get_interlace(im):
+        flags = flags | 64
+    _write_local_header(fp, im, (0, 0), flags)
+
+    im_out.encoderconfig = (8, get_interlace(im))
+    ImageFile._save(im_out, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])])
+
+    fp.write(b"\0")  # end of image data
+
+
+def _getbbox(base_im, im_frame):
+    if _get_palette_bytes(im_frame) != _get_palette_bytes(base_im):
+        im_frame = im_frame.convert("RGBA")
+        base_im = base_im.convert("RGBA")
+    delta = ImageChops.subtract_modulo(im_frame, base_im)
+    return delta, delta.getbbox(alpha_only=False)
+
+
+def _write_multiple_frames(im, fp, palette):
+    duration = im.encoderinfo.get("duration")
+    disposal = im.encoderinfo.get("disposal", im.info.get("disposal"))
+
+    im_frames = []
+    previous_im = None
+    frame_count = 0
+    background_im = None
+    for imSequence in itertools.chain([im], im.encoderinfo.get("append_images", [])):
+        for im_frame in ImageSequence.Iterator(imSequence):
+            # a copy is required here since seek can still mutate the image
+            im_frame = _normalize_mode(im_frame.copy())
+            if frame_count == 0:
+                for k, v in im_frame.info.items():
+                    if k == "transparency":
+                        continue
+                    im.encoderinfo.setdefault(k, v)
+
+            encoderinfo = im.encoderinfo.copy()
+            if "transparency" in im_frame.info:
+                encoderinfo.setdefault("transparency", im_frame.info["transparency"])
+            im_frame = _normalize_palette(im_frame, palette, encoderinfo)
+            if isinstance(duration, (list, tuple)):
+                encoderinfo["duration"] = duration[frame_count]
+            elif duration is None and "duration" in im_frame.info:
+                encoderinfo["duration"] = im_frame.info["duration"]
+            if isinstance(disposal, (list, tuple)):
+                encoderinfo["disposal"] = disposal[frame_count]
+            frame_count += 1
+
+            diff_frame = None
+            if im_frames:
+                # delta frame
+                delta, bbox = _getbbox(previous_im, im_frame)
+                if not bbox:
+                    # This frame is identical to the previous frame
+                    if encoderinfo.get("duration"):
+                        im_frames[-1]["encoderinfo"]["duration"] += encoderinfo[
+                            "duration"
+                        ]
+                    continue
+                if im_frames[-1]["encoderinfo"].get("disposal") == 2:
+                    if background_im is None:
+                        color = im.encoderinfo.get(
+                            "transparency", im.info.get("transparency", (0, 0, 0))
+                        )
+                        background = _get_background(im_frame, color)
+                        background_im = Image.new("P", im_frame.size, background)
+                        background_im.putpalette(im_frames[0]["im"].palette)
+                    bbox = _getbbox(background_im, im_frame)[1]
+                elif encoderinfo.get("optimize") and im_frame.mode != "1":
+                    if "transparency" not in encoderinfo:
+                        try:
+                            encoderinfo["transparency"] = (
+                                im_frame.palette._new_color_index(im_frame)
+                            )
+                        except ValueError:
+                            pass
+                    if "transparency" in encoderinfo:
+                        # When the delta is zero, fill the image with transparency
+                        diff_frame = im_frame.copy()
+                        fill = Image.new("P", delta.size, encoderinfo["transparency"])
+                        if delta.mode == "RGBA":
+                            r, g, b, a = delta.split()
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](
+                                    args["max"](
+                                        args["max"](
+                                            args["max"](args["r"], args["g"]), args["b"]
+                                        ),
+                                        args["a"],
+                                    )
+                                    * 255,
+                                    "1",
+                                ),
+                                r=r,
+                                g=g,
+                                b=b,
+                                a=a,
+                            )
+                        else:
+                            if delta.mode == "P":
+                                # Convert to L without considering palette
+                                delta_l = Image.new("L", delta.size)
+                                delta_l.putdata(delta.getdata())
+                                delta = delta_l
+                            mask = ImageMath.lambda_eval(
+                                lambda args: args["convert"](args["im"] * 255, "1"),
+                                im=delta,
+                            )
+                        diff_frame.paste(fill, mask=ImageOps.invert(mask))
+            else:
+                bbox = None
+            previous_im = im_frame
+            im_frames.append(
+                {"im": diff_frame or im_frame, "bbox": bbox, "encoderinfo": encoderinfo}
+            )
+
+    if len(im_frames) == 1:
+        if "duration" in im.encoderinfo:
+            # Since multiple frames will not be written, use the combined duration
+            im.encoderinfo["duration"] = im_frames[0]["encoderinfo"]["duration"]
+        return
+
+    for frame_data in im_frames:
+        im_frame = frame_data["im"]
+        if not frame_data["bbox"]:
+            # global header
+            for s in _get_global_header(im_frame, frame_data["encoderinfo"]):
+                fp.write(s)
+            offset = (0, 0)
+        else:
+            # compress difference
+            if not palette:
+                frame_data["encoderinfo"]["include_color_table"] = True
+
+            im_frame = im_frame.crop(frame_data["bbox"])
+            offset = frame_data["bbox"][:2]
+        _write_frame_data(fp, im_frame, offset, frame_data["encoderinfo"])
+    return True
+
+
+def _save_all(im, fp, filename):
+    _save(im, fp, filename, save_all=True)
+
+
+def _save(im, fp, filename, save_all=False):
+    # header
+    if "palette" in im.encoderinfo or "palette" in im.info:
+        palette = im.encoderinfo.get("palette", im.info.get("palette"))
+    else:
+        palette = None
+        im.encoderinfo.setdefault("optimize", True)
+
+    if not save_all or not _write_multiple_frames(im, fp, palette):
+        _write_single_frame(im, fp, palette)
+
+    fp.write(b";")  # end of file
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def get_interlace(im):
+    interlace = im.encoderinfo.get("interlace", 1)
+
+    # workaround for @PIL153
+    if min(im.size) < 16:
+        interlace = 0
+
+    return interlace
+
+
+def _write_local_header(fp, im, offset, flags):
+    try:
+        transparency = im.encoderinfo["transparency"]
+    except KeyError:
+        transparency = None
+
+    if "duration" in im.encoderinfo:
+        duration = int(im.encoderinfo["duration"] / 10)
+    else:
+        duration = 0
+
+    disposal = int(im.encoderinfo.get("disposal", 0))
+
+    if transparency is not None or duration != 0 or disposal:
+        packed_flag = 1 if transparency is not None else 0
+        packed_flag |= disposal << 2
+
+        fp.write(
+            b"!"
+            + o8(249)  # extension intro
+            + o8(4)  # length
+            + o8(packed_flag)  # packed fields
+            + o16(duration)  # duration
+            + o8(transparency or 0)  # transparency index
+            + o8(0)
+        )
+
+    include_color_table = im.encoderinfo.get("include_color_table")
+    if include_color_table:
+        palette_bytes = _get_palette_bytes(im)
+        color_table_size = _get_color_table_size(palette_bytes)
+        if color_table_size:
+            flags = flags | 128  # local color table flag
+            flags = flags | color_table_size
+
+    fp.write(
+        b","
+        + o16(offset[0])  # offset
+        + o16(offset[1])
+        + o16(im.size[0])  # size
+        + o16(im.size[1])
+        + o8(flags)  # flags
+    )
+    if include_color_table and color_table_size:
+        fp.write(_get_header_palette(palette_bytes))
+    fp.write(o8(8))  # bits
+
+
+def _save_netpbm(im, fp, filename):
+    # Unused by default.
+    # To use, uncomment the register_save call at the end of the file.
+    #
+    # If you need real GIF compression and/or RGB quantization, you
+    # can use the external NETPBM/PBMPLUS utilities.  See comments
+    # below for information on how to enable this.
+    tempfile = im._dump()
+
+    try:
+        with open(filename, "wb") as f:
+            if im.mode != "RGB":
+                subprocess.check_call(
+                    ["ppmtogif", tempfile], stdout=f, stderr=subprocess.DEVNULL
+                )
+            else:
+                # Pipe ppmquant output into ppmtogif
+                # "ppmquant 256 %s | ppmtogif > %s" % (tempfile, filename)
+                quant_cmd = ["ppmquant", "256", tempfile]
+                togif_cmd = ["ppmtogif"]
+                quant_proc = subprocess.Popen(
+                    quant_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
+                )
+                togif_proc = subprocess.Popen(
+                    togif_cmd,
+                    stdin=quant_proc.stdout,
+                    stdout=f,
+                    stderr=subprocess.DEVNULL,
+                )
+
+                # Allow ppmquant to receive SIGPIPE if ppmtogif exits
+                quant_proc.stdout.close()
+
+                retcode = quant_proc.wait()
+                if retcode:
+                    raise subprocess.CalledProcessError(retcode, quant_cmd)
+
+                retcode = togif_proc.wait()
+                if retcode:
+                    raise subprocess.CalledProcessError(retcode, togif_cmd)
+    finally:
+        try:
+            os.unlink(tempfile)
+        except OSError:
+            pass
+
+
+# Force optimization so that we can test performance against
+# cases where it took lots of memory and time previously.
+_FORCE_OPTIMIZE = False
+
+
+def _get_optimize(im, info):
+    """
+    Palette optimization is a potentially expensive operation.
+
+    This function determines if the palette should be optimized using
+    some heuristics, then returns the list of palette entries in use.
+
+    :param im: Image object
+    :param info: encoderinfo
+    :returns: list of indexes of palette entries in use, or None
+    """
+    if im.mode in ("P", "L") and info and info.get("optimize"):
+        # Potentially expensive operation.
+
+        # The palette saves 3 bytes per color not used, but palette
+        # lengths are restricted to 3*(2**N) bytes. Max saving would
+        # be 768 -> 6 bytes if we went all the way down to 2 colors.
+        # * If we're over 128 colors, we can't save any space.
+        # * If there aren't any holes, it's not worth collapsing.
+        # * If we have a 'large' image, the palette is in the noise.
+
+        # create the new palette if not every color is used
+        optimise = _FORCE_OPTIMIZE or im.mode == "L"
+        if optimise or im.width * im.height < 512 * 512:
+            # check which colors are used
+            used_palette_colors = []
+            for i, count in enumerate(im.histogram()):
+                if count:
+                    used_palette_colors.append(i)
+
+            if optimise or max(used_palette_colors) >= len(used_palette_colors):
+                return used_palette_colors
+
+            num_palette_colors = len(im.palette.palette) // Image.getmodebands(
+                im.palette.mode
+            )
+            current_palette_size = 1 << (num_palette_colors - 1).bit_length()
+            if (
+                # check that the palette would become smaller when saved
+                len(used_palette_colors) <= current_palette_size // 2
+                # check that the palette is not already the smallest possible size
+                and current_palette_size > 2
+            ):
+                return used_palette_colors
+
+
+def _get_color_table_size(palette_bytes):
+    # calculate the palette size for the header
+    if not palette_bytes:
+        return 0
+    elif len(palette_bytes) < 9:
+        return 1
+    else:
+        return math.ceil(math.log(len(palette_bytes) // 3, 2)) - 1
+
+
+def _get_header_palette(palette_bytes):
+    """
+    Returns the palette, null padded to the next power of 2 (*3) bytes
+    suitable for direct inclusion in the GIF header
+
+    :param palette_bytes: Unpadded palette bytes, in RGBRGB form
+    :returns: Null padded palette
+    """
+    color_table_size = _get_color_table_size(palette_bytes)
+
+    # add the missing amount of bytes
+    # the palette has to be 2<<n in size
+    actual_target_size_diff = (2 << color_table_size) - len(palette_bytes) // 3
+    if actual_target_size_diff > 0:
+        palette_bytes += o8(0) * 3 * actual_target_size_diff
+    return palette_bytes
+
+
+def _get_palette_bytes(im):
+    """
+    Gets the palette for inclusion in the gif header
+
+    :param im: Image object
+    :returns: Bytes, len<=768 suitable for inclusion in gif header
+    """
+    return im.palette.palette if im.palette else b""
+
+
+def _get_background(im, info_background):
+    background = 0
+    if info_background:
+        if isinstance(info_background, tuple):
+            # WebPImagePlugin stores an RGBA value in info["background"]
+            # So it must be converted to the same format as GifImagePlugin's
+            # info["background"] - a global color table index
+            try:
+                background = im.palette.getcolor(info_background, im)
+            except ValueError as e:
+                if str(e) not in (
+                    # If all 256 colors are in use,
+                    # then there is no need for the background color
+                    "cannot allocate more than 256 colors",
+                    # Ignore non-opaque WebP background
+                    "cannot add non-opaque RGBA color to RGB palette",
+                ):
+                    raise
+        else:
+            background = info_background
+    return background
+
+
+def _get_global_header(im, info):
+    """Return a list of strings representing a GIF header"""
+
+    # Header Block
+    # https://www.matthewflickinger.com/lab/whatsinagif/bits_and_bytes.asp
+
+    version = b"87a"
+    if im.info.get("version") == b"89a" or (
+        info
+        and (
+            "transparency" in info
+            or info.get("loop") is not None
+            or info.get("duration")
+            or info.get("comment")
+        )
+    ):
+        version = b"89a"
+
+    background = _get_background(im, info.get("background"))
+
+    palette_bytes = _get_palette_bytes(im)
+    color_table_size = _get_color_table_size(palette_bytes)
+
+    header = [
+        b"GIF"  # signature
+        + version  # version
+        + o16(im.size[0])  # canvas width
+        + o16(im.size[1]),  # canvas height
+        # Logical Screen Descriptor
+        # size of global color table + global color table flag
+        o8(color_table_size + 128),  # packed fields
+        # background + reserved/aspect
+        o8(background) + o8(0),
+        # Global Color Table
+        _get_header_palette(palette_bytes),
+    ]
+    if info.get("loop") is not None:
+        header.append(
+            b"!"
+            + o8(255)  # extension intro
+            + o8(11)
+            + b"NETSCAPE2.0"
+            + o8(3)
+            + o8(1)
+            + o16(info["loop"])  # number of loops
+            + o8(0)
+        )
+    if info.get("comment"):
+        comment_block = b"!" + o8(254)  # extension intro
+
+        comment = info["comment"]
+        if isinstance(comment, str):
+            comment = comment.encode()
+        for i in range(0, len(comment), 255):
+            subblock = comment[i : i + 255]
+            comment_block += o8(len(subblock)) + subblock
+
+        comment_block += o8(0)
+        header.append(comment_block)
+    return header
+
+
+def _write_frame_data(fp, im_frame, offset, params):
+    try:
+        im_frame.encoderinfo = params
+
+        # local image header
+        _write_local_header(fp, im_frame, offset, 0)
+
+        ImageFile._save(
+            im_frame, fp, [("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])]
+        )
+
+        fp.write(b"\0")  # end of image data
+    finally:
+        del im_frame.encoderinfo
+
+
+# --------------------------------------------------------------------
+# Legacy GIF utilities
+
+
+def getheader(im, palette=None, info=None):
+    """
+    Legacy Method to get Gif data from image.
+
+    Warning:: May modify image data.
+
+    :param im: Image object
+    :param palette: bytes object containing the source palette, or ....
+    :param info: encoderinfo
+    :returns: tuple of(list of header items, optimized palette)
+
+    """
+    used_palette_colors = _get_optimize(im, info)
+
+    if info is None:
+        info = {}
+
+    if "background" not in info and "background" in im.info:
+        info["background"] = im.info["background"]
+
+    im_mod = _normalize_palette(im, palette, info)
+    im.palette = im_mod.palette
+    im.im = im_mod.im
+    header = _get_global_header(im, info)
+
+    return header, used_palette_colors
+
+
+def getdata(im, offset=(0, 0), **params):
+    """
+    Legacy Method
+
+    Return a list of strings representing this image.
+    The first string is a local image header, the rest contains
+    encoded image data.
+
+    To specify duration, add the time in milliseconds,
+    e.g. ``getdata(im_frame, duration=1000)``
+
+    :param im: Image object
+    :param offset: Tuple of (x, y) pixels. Defaults to (0, 0)
+    :param \\**params: e.g. duration or other encoder info parameters
+    :returns: List of bytes containing GIF encoded frame data
+
+    """
+
+    class Collector:
+        data = []
+
+        def write(self, data):
+            self.data.append(data)
+
+    im.load()  # make sure raster data is available
+
+    fp = Collector()
+
+    _write_frame_data(fp, im, offset, params)
+
+    return fp.data
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(GifImageFile.format, GifImageFile, _accept)
+Image.register_save(GifImageFile.format, _save)
+Image.register_save_all(GifImageFile.format, _save_all)
+Image.register_extension(GifImageFile.format, ".gif")
+Image.register_mime(GifImageFile.format, "image/gif")
+
+#
+# Uncomment the following line if you wish to use NETPBM/PBMPLUS
+# instead of the built-in "uncompressed" GIF encoder
+
+# Image.register_save(GifImageFile.format, _save_netpbm)

venv/Lib/site-packages/PIL/GimpGradientFile.py

@@ -0,0 +1,137 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read (and render) GIMP gradient files
+#
+# History:
+#       97-08-23 fl     Created
+#
+# Copyright (c) Secret Labs AB 1997.
+# Copyright (c) Fredrik Lundh 1997.
+#
+# See the README file for information on usage and redistribution.
+#
+
+"""
+Stuff to translate curve segments to palette values (derived from
+the corresponding code in GIMP, written by Federico Mena Quintero.
+See the GIMP distribution for more information.)
+"""
+from __future__ import annotations
+
+from math import log, pi, sin, sqrt
+
+from ._binary import o8
+
+EPSILON = 1e-10
+""""""  # Enable auto-doc for data member
+
+
+def linear(middle, pos):
+    if pos <= middle:
+        if middle < EPSILON:
+            return 0.0
+        else:
+            return 0.5 * pos / middle
+    else:
+        pos = pos - middle
+        middle = 1.0 - middle
+        if middle < EPSILON:
+            return 1.0
+        else:
+            return 0.5 + 0.5 * pos / middle
+
+
+def curved(middle, pos):
+    return pos ** (log(0.5) / log(max(middle, EPSILON)))
+
+
+def sine(middle, pos):
+    return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
+
+
+def sphere_increasing(middle, pos):
+    return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
+
+
+def sphere_decreasing(middle, pos):
+    return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
+
+
+SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
+""""""  # Enable auto-doc for data member
+
+
+class GradientFile:
+    gradient = None
+
+    def getpalette(self, entries=256):
+        palette = []
+
+        ix = 0
+        x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
+
+        for i in range(entries):
+            x = i / (entries - 1)
+
+            while x1 < x:
+                ix += 1
+                x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
+
+            w = x1 - x0
+
+            if w < EPSILON:
+                scale = segment(0.5, 0.5)
+            else:
+                scale = segment((xm - x0) / w, (x - x0) / w)
+
+            # expand to RGBA
+            r = o8(int(255 * ((rgb1[0] - rgb0[0]) * scale + rgb0[0]) + 0.5))
+            g = o8(int(255 * ((rgb1[1] - rgb0[1]) * scale + rgb0[1]) + 0.5))
+            b = o8(int(255 * ((rgb1[2] - rgb0[2]) * scale + rgb0[2]) + 0.5))
+            a = o8(int(255 * ((rgb1[3] - rgb0[3]) * scale + rgb0[3]) + 0.5))
+
+            # add to palette
+            palette.append(r + g + b + a)
+
+        return b"".join(palette), "RGBA"
+
+
+class GimpGradientFile(GradientFile):
+    """File handler for GIMP's gradient format."""
+
+    def __init__(self, fp):
+        if fp.readline()[:13] != b"GIMP Gradient":
+            msg = "not a GIMP gradient file"
+            raise SyntaxError(msg)
+
+        line = fp.readline()
+
+        # GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
+        if line.startswith(b"Name: "):
+            line = fp.readline().strip()
+
+        count = int(line)
+
+        gradient = []
+
+        for i in range(count):
+            s = fp.readline().split()
+            w = [float(x) for x in s[:11]]
+
+            x0, x1 = w[0], w[2]
+            xm = w[1]
+            rgb0 = w[3:7]
+            rgb1 = w[7:11]
+
+            segment = SEGMENTS[int(s[11])]
+            cspace = int(s[12])
+
+            if cspace != 0:
+                msg = "cannot handle HSV colour space"
+                raise OSError(msg)
+
+            gradient.append((x0, x1, xm, rgb0, rgb1, segment))
+
+        self.gradient = gradient

venv/Lib/site-packages/PIL/GimpPaletteFile.py

@@ -0,0 +1,57 @@
+#
+# Python Imaging Library
+# $Id$
+#
+# stuff to read GIMP palette files
+#
+# History:
+# 1997-08-23 fl     Created
+# 2004-09-07 fl     Support GIMP 2.0 palette files.
+#
+# Copyright (c) Secret Labs AB 1997-2004.  All rights reserved.
+# Copyright (c) Fredrik Lundh 1997-2004.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import re
+
+from ._binary import o8
+
+
+class GimpPaletteFile:
+    """File handler for GIMP's palette format."""
+
+    rawmode = "RGB"
+
+    def __init__(self, fp):
+        self.palette = [o8(i) * 3 for i in range(256)]
+
+        if fp.readline()[:12] != b"GIMP Palette":
+            msg = "not a GIMP palette file"
+            raise SyntaxError(msg)
+
+        for i in range(256):
+            s = fp.readline()
+            if not s:
+                break
+
+            # skip fields and comment lines
+            if re.match(rb"\w+:|#", s):
+                continue
+            if len(s) > 100:
+                msg = "bad palette file"
+                raise SyntaxError(msg)
+
+            v = tuple(map(int, s.split()[:3]))
+            if len(v) != 3:
+                msg = "bad palette entry"
+                raise ValueError(msg)
+
+            self.palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
+
+        self.palette = b"".join(self.palette)
+
+    def getpalette(self):
+        return self.palette, self.rawmode

venv/Lib/site-packages/PIL/GribStubImagePlugin.py

@@ -0,0 +1,74 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# GRIB stub adapter
+#
+# Copyright (c) 1996-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler):
+    """
+    Install application-specific GRIB image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix):
+    return prefix[:4] == b"GRIB" and prefix[7] == 1
+
+
+class GribStubImageFile(ImageFile.StubImageFile):
+    format = "GRIB"
+    format_description = "GRIB"
+
+    def _open(self):
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(8)):
+            msg = "Not a GRIB file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(offset)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self):
+        return _handler
+
+
+def _save(im, fp, filename):
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "GRIB save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(GribStubImageFile.format, GribStubImageFile, _accept)
+Image.register_save(GribStubImageFile.format, _save)
+
+Image.register_extension(GribStubImageFile.format, ".grib")

venv/Lib/site-packages/PIL/Hdf5StubImagePlugin.py

@@ -0,0 +1,74 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# HDF5 stub adapter
+#
+# Copyright (c) 2000-2003 by Fredrik Lundh
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+from . import Image, ImageFile
+
+_handler = None
+
+
+def register_handler(handler):
+    """
+    Install application-specific HDF5 image handler.
+
+    :param handler: Handler object.
+    """
+    global _handler
+    _handler = handler
+
+
+# --------------------------------------------------------------------
+# Image adapter
+
+
+def _accept(prefix):
+    return prefix[:8] == b"\x89HDF\r\n\x1a\n"
+
+
+class HDF5StubImageFile(ImageFile.StubImageFile):
+    format = "HDF5"
+    format_description = "HDF5"
+
+    def _open(self):
+        offset = self.fp.tell()
+
+        if not _accept(self.fp.read(8)):
+            msg = "Not an HDF file"
+            raise SyntaxError(msg)
+
+        self.fp.seek(offset)
+
+        # make something up
+        self._mode = "F"
+        self._size = 1, 1
+
+        loader = self._load()
+        if loader:
+            loader.open(self)
+
+    def _load(self):
+        return _handler
+
+
+def _save(im, fp, filename):
+    if _handler is None or not hasattr(_handler, "save"):
+        msg = "HDF5 save handler not installed"
+        raise OSError(msg)
+    _handler.save(im, fp, filename)
+
+
+# --------------------------------------------------------------------
+# Registry
+
+Image.register_open(HDF5StubImageFile.format, HDF5StubImageFile, _accept)
+Image.register_save(HDF5StubImageFile.format, _save)
+
+Image.register_extensions(HDF5StubImageFile.format, [".h5", ".hdf"])

venv/Lib/site-packages/PIL/IcnsImagePlugin.py

@@ -0,0 +1,400 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# macOS icns file decoder, based on icns.py by Bob Ippolito.
+#
+# history:
+# 2004-10-09 fl   Turned into a PIL plugin; removed 2.3 dependencies.
+# 2020-04-04      Allow saving on all operating systems.
+#
+# Copyright (c) 2004 by Bob Ippolito.
+# Copyright (c) 2004 by Secret Labs.
+# Copyright (c) 2004 by Fredrik Lundh.
+# Copyright (c) 2014 by Alastair Houghton.
+# Copyright (c) 2020 by Pan Jing.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import struct
+import sys
+
+from . import Image, ImageFile, PngImagePlugin, features
+
+enable_jpeg2k = features.check_codec("jpg_2000")
+if enable_jpeg2k:
+    from . import Jpeg2KImagePlugin
+
+MAGIC = b"icns"
+HEADERSIZE = 8
+
+
+def nextheader(fobj):
+    return struct.unpack(">4sI", fobj.read(HEADERSIZE))
+
+
+def read_32t(fobj, start_length, size):
+    # The 128x128 icon seems to have an extra header for some reason.
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(4)
+    if sig != b"\x00\x00\x00\x00":
+        msg = "Unknown signature, expecting 0x00000000"
+        raise SyntaxError(msg)
+    return read_32(fobj, (start + 4, length - 4), size)
+
+
+def read_32(fobj, start_length, size):
+    """
+    Read a 32bit RGB icon resource.  Seems to be either uncompressed or
+    an RLE packbits-like scheme.
+    """
+    (start, length) = start_length
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    if length == sizesq * 3:
+        # uncompressed ("RGBRGBGB")
+        indata = fobj.read(length)
+        im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
+    else:
+        # decode image
+        im = Image.new("RGB", pixel_size, None)
+        for band_ix in range(3):
+            data = []
+            bytesleft = sizesq
+            while bytesleft > 0:
+                byte = fobj.read(1)
+                if not byte:
+                    break
+                byte = byte[0]
+                if byte & 0x80:
+                    blocksize = byte - 125
+                    byte = fobj.read(1)
+                    for i in range(blocksize):
+                        data.append(byte)
+                else:
+                    blocksize = byte + 1
+                    data.append(fobj.read(blocksize))
+                bytesleft -= blocksize
+                if bytesleft <= 0:
+                    break
+            if bytesleft != 0:
+                msg = f"Error reading channel [{repr(bytesleft)} left]"
+                raise SyntaxError(msg)
+            band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
+            im.im.putband(band.im, band_ix)
+    return {"RGB": im}
+
+
+def read_mk(fobj, start_length, size):
+    # Alpha masks seem to be uncompressed
+    start = start_length[0]
+    fobj.seek(start)
+    pixel_size = (size[0] * size[2], size[1] * size[2])
+    sizesq = pixel_size[0] * pixel_size[1]
+    band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
+    return {"A": band}
+
+
+def read_png_or_jpeg2000(fobj, start_length, size):
+    (start, length) = start_length
+    fobj.seek(start)
+    sig = fobj.read(12)
+    if sig[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
+        fobj.seek(start)
+        im = PngImagePlugin.PngImageFile(fobj)
+        Image._decompression_bomb_check(im.size)
+        return {"RGBA": im}
+    elif (
+        sig[:4] == b"\xff\x4f\xff\x51"
+        or sig[:4] == b"\x0d\x0a\x87\x0a"
+        or sig == b"\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a"
+    ):
+        if not enable_jpeg2k:
+            msg = (
+                "Unsupported icon subimage format (rebuild PIL "
+                "with JPEG 2000 support to fix this)"
+            )
+            raise ValueError(msg)
+        # j2k, jpc or j2c
+        fobj.seek(start)
+        jp2kstream = fobj.read(length)
+        f = io.BytesIO(jp2kstream)
+        im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
+        Image._decompression_bomb_check(im.size)
+        if im.mode != "RGBA":
+            im = im.convert("RGBA")
+        return {"RGBA": im}
+    else:
+        msg = "Unsupported icon subimage format"
+        raise ValueError(msg)
+
+
+class IcnsFile:
+    SIZES = {
+        (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
+        (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
+        (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
+        (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
+        (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
+        (128, 128, 1): [
+            (b"ic07", read_png_or_jpeg2000),
+            (b"it32", read_32t),
+            (b"t8mk", read_mk),
+        ],
+        (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
+        (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
+        (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
+        (32, 32, 1): [
+            (b"icp5", read_png_or_jpeg2000),
+            (b"il32", read_32),
+            (b"l8mk", read_mk),
+        ],
+        (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
+        (16, 16, 1): [
+            (b"icp4", read_png_or_jpeg2000),
+            (b"is32", read_32),
+            (b"s8mk", read_mk),
+        ],
+    }
+
+    def __init__(self, fobj):
+        """
+        fobj is a file-like object as an icns resource
+        """
+        # signature : (start, length)
+        self.dct = dct = {}
+        self.fobj = fobj
+        sig, filesize = nextheader(fobj)
+        if not _accept(sig):
+            msg = "not an icns file"
+            raise SyntaxError(msg)
+        i = HEADERSIZE
+        while i < filesize:
+            sig, blocksize = nextheader(fobj)
+            if blocksize <= 0:
+                msg = "invalid block header"
+                raise SyntaxError(msg)
+            i += HEADERSIZE
+            blocksize -= HEADERSIZE
+            dct[sig] = (i, blocksize)
+            fobj.seek(blocksize, io.SEEK_CUR)
+            i += blocksize
+
+    def itersizes(self):
+        sizes = []
+        for size, fmts in self.SIZES.items():
+            for fmt, reader in fmts:
+                if fmt in self.dct:
+                    sizes.append(size)
+                    break
+        return sizes
+
+    def bestsize(self):
+        sizes = self.itersizes()
+        if not sizes:
+            msg = "No 32bit icon resources found"
+            raise SyntaxError(msg)
+        return max(sizes)
+
+    def dataforsize(self, size):
+        """
+        Get an icon resource as {channel: array}.  Note that
+        the arrays are bottom-up like windows bitmaps and will likely
+        need to be flipped or transposed in some way.
+        """
+        dct = {}
+        for code, reader in self.SIZES[size]:
+            desc = self.dct.get(code)
+            if desc is not None:
+                dct.update(reader(self.fobj, desc, size))
+        return dct
+
+    def getimage(self, size=None):
+        if size is None:
+            size = self.bestsize()
+        if len(size) == 2:
+            size = (size[0], size[1], 1)
+        channels = self.dataforsize(size)
+
+        im = channels.get("RGBA", None)
+        if im:
+            return im
+
+        im = channels.get("RGB").copy()
+        try:
+            im.putalpha(channels["A"])
+        except KeyError:
+            pass
+        return im
+
+
+##
+# Image plugin for Mac OS icons.
+
+
+class IcnsImageFile(ImageFile.ImageFile):
+    """
+    PIL image support for Mac OS .icns files.
+    Chooses the best resolution, but will possibly load
+    a different size image if you mutate the size attribute
+    before calling 'load'.
+
+    The info dictionary has a key 'sizes' that is a list
+    of sizes that the icns file has.
+    """
+
+    format = "ICNS"
+    format_description = "Mac OS icns resource"
+
+    def _open(self):
+        self.icns = IcnsFile(self.fp)
+        self._mode = "RGBA"
+        self.info["sizes"] = self.icns.itersizes()
+        self.best_size = self.icns.bestsize()
+        self.size = (
+            self.best_size[0] * self.best_size[2],
+            self.best_size[1] * self.best_size[2],
+        )
+
+    @property
+    def size(self):
+        return self._size
+
+    @size.setter
+    def size(self, value):
+        info_size = value
+        if info_size not in self.info["sizes"] and len(info_size) == 2:
+            info_size = (info_size[0], info_size[1], 1)
+        if (
+            info_size not in self.info["sizes"]
+            and len(info_size) == 3
+            and info_size[2] == 1
+        ):
+            simple_sizes = [
+                (size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
+            ]
+            if value in simple_sizes:
+                info_size = self.info["sizes"][simple_sizes.index(value)]
+        if info_size not in self.info["sizes"]:
+            msg = "This is not one of the allowed sizes of this image"
+            raise ValueError(msg)
+        self._size = value
+
+    def load(self):
+        if len(self.size) == 3:
+            self.best_size = self.size
+            self.size = (
+                self.best_size[0] * self.best_size[2],
+                self.best_size[1] * self.best_size[2],
+            )
+
+        px = Image.Image.load(self)
+        if self.im is not None and self.im.size == self.size:
+            # Already loaded
+            return px
+        self.load_prepare()
+        # This is likely NOT the best way to do it, but whatever.
+        im = self.icns.getimage(self.best_size)
+
+        # If this is a PNG or JPEG 2000, it won't be loaded yet
+        px = im.load()
+
+        self.im = im.im
+        self._mode = im.mode
+        self.size = im.size
+
+        return px
+
+
+def _save(im, fp, filename):
+    """
+    Saves the image as a series of PNG files,
+    that are then combined into a .icns file.
+    """
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+    sizes = {
+        b"ic07": 128,
+        b"ic08": 256,
+        b"ic09": 512,
+        b"ic10": 1024,
+        b"ic11": 32,
+        b"ic12": 64,
+        b"ic13": 256,
+        b"ic14": 512,
+    }
+    provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
+    size_streams = {}
+    for size in set(sizes.values()):
+        image = (
+            provided_images[size]
+            if size in provided_images
+            else im.resize((size, size))
+        )
+
+        temp = io.BytesIO()
+        image.save(temp, "png")
+        size_streams[size] = temp.getvalue()
+
+    entries = []
+    for type, size in sizes.items():
+        stream = size_streams[size]
+        entries.append(
+            {"type": type, "size": HEADERSIZE + len(stream), "stream": stream}
+        )
+
+    # Header
+    fp.write(MAGIC)
+    file_length = HEADERSIZE  # Header
+    file_length += HEADERSIZE + 8 * len(entries)  # TOC
+    file_length += sum(entry["size"] for entry in entries)
+    fp.write(struct.pack(">i", file_length))
+
+    # TOC
+    fp.write(b"TOC ")
+    fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
+    for entry in entries:
+        fp.write(entry["type"])
+        fp.write(struct.pack(">i", entry["size"]))
+
+    # Data
+    for entry in entries:
+        fp.write(entry["type"])
+        fp.write(struct.pack(">i", entry["size"]))
+        fp.write(entry["stream"])
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+def _accept(prefix):
+    return prefix[:4] == MAGIC
+
+
+Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
+Image.register_extension(IcnsImageFile.format, ".icns")
+
+Image.register_save(IcnsImageFile.format, _save)
+Image.register_mime(IcnsImageFile.format, "image/icns")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Syntax: python3 IcnsImagePlugin.py [file]")
+        sys.exit()
+
+    with open(sys.argv[1], "rb") as fp:
+        imf = IcnsImageFile(fp)
+        for size in imf.info["sizes"]:
+            width, height, scale = imf.size = size
+            imf.save(f"out-{width}-{height}-{scale}.png")
+        with Image.open(sys.argv[1]) as im:
+            im.save("out.png")
+        if sys.platform == "windows":
+            os.startfile("out.png")