Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,22 @@ 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-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/CDK_pywrapper/CDKdesc.jar filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy/core/_multiarray_umath.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy/core/_simd.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/numpy.libs/libopenblas64__v0.3.23-293-gc2f4bdbb-gcc_10_3_0-2bde3a66a51006b2b53eb373ff767a3f.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/algos.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/groupby.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/hashtable.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/interval.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pandas/_libs/join.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/PIL/_imaging.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/PIL/_imagingft.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pydantic_core/_pydantic_core.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/rdkit/Chem/rdchem.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/rdkit.libs/RDKitFileParsers-5d3f62f7babfcb6bcade84980d20cb24.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/rdkit.libs/RDKitGraphMol-a0f7618b9e75a0a84b3f1cb34f92b554.dll filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/rdkit.libs/RDKitInchi-2adc093eac85469d4a9f373d5583b2d1.dll filter=lfs diff=lfs merge=lfs -text
+venv/Scripts/ruff.exe filter=lfs diff=lfs merge=lfs -text

LICENSE

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

README.md

@@ -1,12 +1,45 @@
----
-title: CDK Library
-emoji: 🔥
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 4.37.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: CDK_library
+app_file: app.py
+sdk: gradio
+sdk_version: 4.36.1
+---
+# Molecular Descriptor Analysis and Chemical Reaction Visualization
+
+This repository provides a web-based interface using Gradio for performing various molecular descriptor calculations, geometric analyses, substructure checks, similarity calculations, and chemical reaction visualizations. It integrates functionalities from RDKit and CDK libraries, enabling users to interactively analyze chemical data without needing extensive programming knowledge.
+
+## Features
+
+- **Calculate Descriptors:** Input SMILES strings and optionally include 3D coordinates to generate MolFile outputs and download descriptors as Excel.
+- **Geometric Values:** Compute molecular weight, centroid, mean distance to centroid, and max distance to centroid for a given molecule and display its structure.
+- **Check Substructure:** Check if a specified substructure is present within a molecule and visualize both structures.
+- **Calculate Similarity:** Compute Tanimoto similarity coefficient between two molecules based on their SMILES strings.
+- **Chemical Reaction:** Define chemical reactions using SMARTS notation, input reactant SMILES strings, and visualize the resulting reaction products interactively.
+
+## Usage
+
+1. **Setup Environment:**
+   - Ensure Python 3.7+ is installed.
+   - Install required packages using `pip install -r requirements.txt`.
+
+2. **Run the Application:**
+   - Execute `python app.py` to start the Gradio interface locally.
+   - Access the interface at `http://localhost:7860`.
+
+3. **Interface Navigation:**
+   - Use the tabs provided to input SMILES strings and parameters for the desired chemical analysis or reaction.
+   - Click buttons to perform calculations or reactions and view results interactively.
+
+4. **Contribute:**
+   - Fork the repository, make your changes, and submit a pull request.
+   - Report any issues or suggest improvements through GitHub issues.
+
+## Dependencies
+
+- RDKit: Open-source cheminformatics software.
+- CDK: Chemistry Development Kit for molecular descriptor calculation.
+- Gradio: User-friendly Python library for creating UIs around ML models.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

app.py

@@ -0,0 +1,216 @@
+import gradio as gr
+from CDK_pywrapper import CDK
+from rdkit import Chem
+from rdkit.Chem import Descriptors, Draw, AllChem, rdMolDescriptors
+from rdkit.Chem.Fingerprints import FingerprintMols
+from rdkit.DataStructs import TanimotoSimilarity
+import pandas as pd
+import numpy as np
+import tempfile
+
+
+# Function to convert SMILES to MolFile
+def convert_smiles_to_mol(smiles_list, checkbox):
+
+    if checkbox == True:
+        cdk = CDK(ignore_3D=False)
+    else:
+        cdk = CDK()
+    smiles_list = list(smiles_list.split(','))
+    try:
+        mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list]
+
+        molfile = cdk.calculate(mols)
+
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
+                file_path = tmp.name
+            molfile.to_excel(file_path, index=False)
+            return molfile,file_path
+        except Exception as e:
+            return molfile,str(e)
+
+    except Exception as e:
+        return str(e), str(e)
+
+
+# Function to calculate Molecular Weight
+def calculate_molecular_weight(smiles):
+    if smiles is None:
+        return "SMILES string is None"
+    try:
+        molecule = Chem.MolFromSmiles(smiles)
+        if molecule is None:
+            return "Invalid SMILES"
+        mol_weight = Descriptors.MolWt(molecule)
+        img = Draw.MolToImage(molecule)
+        return mol_weight, img
+    except Exception as e:
+        return str(e)
+    
+def get_geometric_descriptors(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return "Invalid SMILES string"
+        
+        # Add hydrogens and compute 3D coordinates
+        mol = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol, AllChem.ETKDG())
+        AllChem.UFFOptimizeMolecule(mol)
+
+        # Calculate geometric descriptors
+        conformer = mol.GetConformer()
+        coords = conformer.GetPositions()
+        
+        centroid = np.mean(coords, axis=0)
+        centroid = np.round(centroid, 12)
+        distances = np.linalg.norm(coords - centroid, axis=1)
+        mol_weight = Descriptors.MolWt(mol)
+
+        geometric_descriptors = {
+            'Molecular Weight': mol_weight,
+            'Centroid': centroid.tolist(),
+            'Mean Distance To Centroid': np.mean(distances),
+            'Max Distance To Centroid': np.max(distances)
+        }
+        img = Draw.MolToImage(mol)
+        df = pd.DataFrame([geometric_descriptors])
+        return df.T,img
+    except Exception as e:
+        return str(e), str(e)
+
+# Function to check if a substructure is present
+def check_substructure(smiles, substructure_smiles):
+    # Convert the SMILES strings to RDKit molecule objects
+    molecule = Chem.MolFromSmiles(smiles)
+    substructure = Chem.MolFromSmiles(substructure_smiles)
+    
+    # Check if the molecule is None (invalid SMILES)
+    if molecule is None or substructure is None:
+        return "Error","Error","Invalid SMILES string provided."
+    
+    # Use RDKit's HasSubstructMatch to check for the substructure
+    val = molecule.HasSubstructMatch(substructure)
+    img1 = Draw.MolToImage(molecule)
+
+    if val:
+        try:
+            molecule = Chem.MolFromSmiles(smiles)
+            sub_molecule = Chem.MolFromSmiles(substructure_smiles)
+            img1 = Draw.MolToImage(molecule)
+            img2 = Draw.MolToImage(sub_molecule)
+            return img1, img2, "Substructure is present."
+        except Exception as e:
+            return str(e), str(e), "Substructure is present."        
+    else:
+        return img1,"NO Image","Substructure is not present."
+
+def calculate_similarity(smiles1, smiles2):
+    try:
+        mol1 = Chem.MolFromSmiles(smiles1)
+        mol2 = Chem.MolFromSmiles(smiles2)
+        
+        if mol1 is None or mol2 is None:
+            return "Invalid SMILES string"
+        
+        fp1 = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol1, radius=2, nBits=2048)
+        fp2 = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol2, radius=2, nBits=2048)
+        
+        similarity = TanimotoSimilarity(fp1, fp2)
+        return similarity
+    except Exception as e:
+        return str(e)
+    
+def perform_reaction(reactant1_smiles, reactant2_smiles, reaction_smarts):
+    try:
+        # Define the reaction using SMARTS provided by the user
+        reaction = AllChem.ReactionFromSmarts(reaction_smarts)
+        
+        # Convert SMILES to RDKit molecules
+        reactant1 = Chem.MolFromSmiles(reactant1_smiles)
+        reactant2 = Chem.MolFromSmiles(reactant2_smiles)
+        
+        if reactant1 is None or reactant2 is None:
+            return "Invalid SMILES string(s)", None
+        
+        # Run the reaction
+        products = reaction.RunReactants((reactant1, reactant2))
+        
+        # Create a grid image of reactants and products
+        all_mols = [reactant1, reactant2]
+        legends = ["Reactant 1", "Reactant 2"]
+        for i, product_set in enumerate(products):
+            for j, product in enumerate(product_set):
+                all_mols.append(product)
+                legends.append(f'Product {i+1}.{j+1}')
+        
+        img = Draw.MolsToGridImage(all_mols, molsPerRow=4, subImgSize=(300, 300), legends=legends)
+        return "Reaction Successful", img
+    
+    except Exception as e:
+        return str(e), None
+
+# Gradio Interface
+def generate_reaction_image(reaction_smarts,reactant1_smiles, reactant2_smiles):
+    result, img = perform_reaction(reactant1_smiles, reactant2_smiles, reaction_smarts)
+    return result, img
+
+
+
+
+# Gradio Interface
+with gr.Blocks(theme='earneleh/paris') as demo:
+     gr.Markdown("### CDK Functionality with Gradio Interface")
+    
+     with gr.Tab("Calculate Descriptors"):
+        smiles_input = gr.Textbox(label="SMILES", info="Enter SMILES separated by comma")
+        checkbox = gr.Checkbox(label="Include 3D Coordinates")
+        molfile_output = gr.Textbox(label="MolFile", lines=10)
+        convert_button = gr.Button("Calculate")
+        download_link = gr.File(label="Download Descriptors as Excel")
+        convert_button.click(fn=convert_smiles_to_mol, inputs=[smiles_input, checkbox], outputs=[molfile_output,download_link])
+
+     with gr.Tab("Geometric Values"):
+        with gr.Row():
+            with gr.Column(min_width=800):
+                smiles_input_mw = gr.Textbox(label="SMILE")
+                weight_output = gr.TextArea(label="Geometric Values", lines=8, show_copy_button=True)
+                calculate_button = gr.Button("Calculate")
+            with gr.Column():
+                image_output = gr.Image(label="Molecular Structure", height=400, width=500)
+                calculate_button.click(fn=get_geometric_descriptors, inputs=smiles_input_mw,outputs=[weight_output, image_output])
+            
+     with gr.Tab("Check Substructure"):
+        with gr.Row():
+            with gr.Column():
+                smiles_input_sub = gr.Textbox(label="SMILES")
+                substructure_input = gr.Textbox(label="Substructure SMILES")
+                substructure_output = gr.Label(label="Is Substructure Present?")
+                check_button = gr.Button("Check")
+            with gr.Column():
+                image_output1 = gr.Image(label="Molecular Structure", height=350, width=500)
+                image_output2 = gr.Image(label="Sub_Molecular Structure", height=350, width=500)
+                check_button.click(fn=check_substructure, inputs=[smiles_input_sub, substructure_input], outputs=[image_output1, image_output2, substructure_output])
+
+    
+     with gr.Tab("Calculate Similarity"):
+        smiles_input1 = gr.Textbox(label="SMILES 1")
+        smiles_input2 = gr.Textbox(label="SMILES 2")
+        similarity_output = gr.Number(label="Similarity (Tanimoto)")
+        calculate_button_sim = gr.Button("Calculate Similarity")
+        calculate_button_sim.click(fn=calculate_similarity, inputs=[smiles_input1, smiles_input2], outputs=similarity_output)
+
+     with gr.Tab("Chemical Reaction"):
+        reaction_smarts_input = gr.Textbox(label="Reaction SMARTS",value="[O:2]=[C:1][OH].[N:3]>>[O:2]=[C:1][N:3]")
+        smiles_input1 = gr.Textbox(label="Reactant 1 SMILES", value="OC=O")
+        smiles_input2 = gr.Textbox(label="Reactant 2 SMILES", value= "NCC")
+        calculate_button = gr.Button("Perform Reaction")
+
+        result_output = gr.Label(label="Result")
+        image_output = gr.Image(label="Reaction Image", interactive=True)
+        calculate_button.click(fn=generate_reaction_image, inputs=[reaction_smarts_input, smiles_input1, smiles_input2], outputs=[result_output, image_output])
+
+
+# Launch Gradio Interface
+demo.launch(share=True)

readme.txt

@@ -0,0 +1,46 @@
+CDK Functionality with Gradio Interface
+Calculate Descriptors Tab
+Input:
+
+SMILES: Enter SMILES strings separated by commas.
+Include 3D Coordinates Checkbox: Optional checkbox to include 3D coordinates in output.
+Outputs:
+
+MolFile: Textbox displaying MolFile data for the input SMILES.
+Download Descriptors as Excel: File download link for the descriptors in Excel format.
+Geometric Values Tab
+Input:
+
+SMILES: Enter a single SMILES string.
+Outputs:
+
+Geometric Values: Text area displaying molecular weight, centroid, mean distance to centroid, and max distance to centroid.
+Molecular Structure: Image display of the input molecule.
+Check Substructure Tab
+Inputs:
+
+SMILES: Input SMILES for the molecule.
+Substructure SMILES: SMILES for the substructure to check.
+Outputs:
+
+Molecular Structure: Image of the molecule with the substructure highlighted.
+Substructure Molecular Structure: Image of the substructure.
+Is Substructure Present?: Text label indicating presence or absence of the substructure.
+Calculate Similarity Tab
+Inputs:
+
+SMILES 1: First SMILES string.
+SMILES 2: Second SMILES string.
+Output:
+
+Similarity (Tanimoto): Numeric value indicating similarity between the two molecules.
+Chemical Reaction Tab
+Inputs:
+
+Reaction SMARTS: SMARTS string defining the chemical reaction.
+Reactant 1 SMILES: SMILES string for the first reactant.
+Reactant 2 SMILES: SMILES string for the second reactant.
+Outputs:
+
+Result: Text label indicating the success or failure of the reaction.
+Reaction Image: Interactive image showing reactants and products.

requirements.txt

@@ -0,0 +1,6 @@
+CDK-pywrapper
+gradio
+rdkit
+pandas
+numpy
+tempfile

venv/Lib/site-packages/CDK_pywrapper-0.1.0.dist-info/INSTALLER

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

venv/Lib/site-packages/CDK_pywrapper-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Olivier J. M. Béquignon
+
+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/CDK_pywrapper-0.1.0.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: CDK_pywrapper
+Version: 0.1.0
+Summary: Python wrapper for CDK molecular descriptors and fingerprints
+Home-page: https://github.com/OlivierBeq/CDK_pywrapper
+Author: Olivier J. M. Béquignon
+Author-email: "olivier.bequignon.maintainer@gmail.com"
+Maintainer: Olivier J. M. Béquignon
+Maintainer-email: "olivier.bequignon.maintainer@gmail.com"
+Keywords: Chemistry Development Kit,molecular descriptors,molecular fingerprints,cheminformatics,QSAR
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: more-itertools
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rdkit
+Requires-Dist: install-jdk ==0.3.0
+Requires-Dist: bounded-pool-executor ==0.0.3
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints ; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: pytest ; extra == 'testing'
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# CDK Python wrapper
+
+Python wrapper to ease the calculation of [CDK](https://cdk.github.io/) molecular descriptors and fingerprints.
+
+## Installation
+
+From source:
+
+    git clone https://github.com/OlivierBeq/CDK_pywrapper.git
+    pip install ./CDK_pywrapper
+
+with pip:
+
+```bash
+pip install CDK-pywrapper
+```
+
+### Get started
+
+```python
+from CDK_pywrapper import CDK
+from rdkit import Chem
+
+smiles_list = [
+  # erlotinib
+  "n1cnc(c2cc(c(cc12)OCCOC)OCCOC)Nc1cc(ccc1)C#C",
+  # midecamycin
+  "CCC(=O)O[C@@H]1CC(=O)O[C@@H](C/C=C/C=C/[C@@H]([C@@H](C[C@@H]([C@@H]([C@H]1OC)O[C@H]2[C@@H]([C@H]([C@@H]([C@H](O2)C)O[C@H]3C[C@@]([C@H]([C@@H](O3)C)OC(=O)CC)(C)O)N(C)C)O)CC=O)C)O)C",
+  # selenofolate
+  "C1=CC(=CC=C1C(=O)NC(CCC(=O)OCC[Se]C#N)C(=O)O)NCC2=CN=C3C(=N2)C(=O)NC(=N3)N",
+  # cisplatin
+  "N.N.Cl[Pt]Cl"
+]
+mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list]
+
+cdk = CDK()
+print(cdk.calculate(mols))
+```
+
+The above calculates 222 molecular descriptors (23 1D and 200 2D).<br/>
+
+The additional 65 three-dimensional (3D) descriptors may be obtained with the following:
+:warning: Molecules are required to have conformers for 3D descriptors to be calculated.<br/>
+
+```python
+from rdkit.Chem import AllChem
+
+for mol in mols:
+    _ = AllChem.EmbedMolecule(mol)
+
+cdk = CDK(ignore_3D=False)
+print(cdk.calculate(mols))
+```
+
+
+To obtain molecular fingerprint, one can used the following:
+
+```python
+from CDK_pywrapper import CDK, FPType
+cdk = CDK(fingerprint=.PubchemFP)
+print(cdk.calculate(mols))
+```
+
+The following fingerprints can be calculated:
+
+| FPType    | Fingerprint name                                                                   |
+|-----------|------------------------------------------------------------------------------------|
+| FP        | CDK fingerprint                                                                    |
+| ExtFP     | Extended CDK fingerprint (includes 25 bits for ring features and isotopic masses)  |
+| EStateFP  | Electrotopological state fingerprint (79 bits)                                     |
+| GraphFP   | CDK fingerprinter ignoring bond orders                                             |
+| MACCSFP   | Public MACCS fingerprint                                                           |
+| PubchemFP | PubChem substructure fingerprint                                                   |
+| SubFP     | Fingerprint describing 307 substructures                                           |
+| KRFP      | Klekota-Roth fingerprint                                                           |
+| AP2DFP    | Atom pair 2D fingerprint as implemented in PaDEL                                   |
+| HybridFP  | CDK fingerprint ignoring aromaticity                                               |
+| LingoFP   | LINGO fingerprint                                                                  |
+| SPFP      | Fingerprint based on the shortest paths between two atoms                          |
+| SigFP     | Signature fingerprint                                                              |
+| CircFP    | Circular fingerprint                                                               |
+
+## Documentation
+
+```python
+class CDK(ignore_3D=True, fingerprint=None, nbits=1024, depth=6):
+```
+
+Constructor of a CDK calculator for molecular descriptors or fingerprints
+
+Parameters:
+
+- ***ignore_3D  : bool***
+  Should 3D molecular descriptors be calculated (default: False). Ignored if a fingerprint is set.
+- ***fingerprint  : FPType***  
+  Type of fingerprint to calculate (default: None). If None, calculate descriptors.
+- ***nbits  : int***  
+  Number of bits in the fingerprint.
+- ***depth  : int***  
+  Depth of the fingerprint.
+<br/>
+<br/>
+```python
+def calculate(mols, show_banner=True, njobs=1, chunksize=1000):
+```
+
+Default method to calculate CDK molecular descriptors and fingerprints.
+
+Parameters:
+
+- ***mols  : Iterable[Chem.Mol]***  
+  RDKit molecule objects for which to obtain CDK descriptors.
+- ***show_banner  : bool***  
+  Displays default notice about CDK.
+- ***njobs  : int***  
+  Maximum number of simultaneous processes.
+- ***chunksize  : int***  
+  Maximum number of molecules each process is charged of.

venv/Lib/site-packages/CDK_pywrapper-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+CDK_pywrapper-0.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+CDK_pywrapper-0.1.0.dist-info/LICENSE,sha256=8XfEdB_CgNewtZLb9xPkJpIMb_iRCGFbnM2B86ynvgg,1100
+CDK_pywrapper-0.1.0.dist-info/METADATA,sha256=84SFhHtsKNoBEp1cqd-l-f7CF4GuKH3NFttjwQIUi6E,5737
+CDK_pywrapper-0.1.0.dist-info/RECORD,,
+CDK_pywrapper-0.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CDK_pywrapper-0.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+CDK_pywrapper-0.1.0.dist-info/top_level.txt,sha256=LrqN34bTqsjyx5SUadb3ONALge1zi4QhZAcuanHUiMA,14
+CDK_pywrapper/CDKdesc.jar,sha256=e4JY7QJJB1C8yI5bsuwyGGtZXcvUz750DBuWUX1TF9k,47157078
+CDK_pywrapper/__init__.py,sha256=P5gmu31aXYXpzpOqVW-L-wa43uxWT72QxYoiEDlsZaU,152
+CDK_pywrapper/__pycache__/__init__.cpython-311.pyc,,
+CDK_pywrapper/__pycache__/cdk_pywrapper.cpython-311.pyc,,
+CDK_pywrapper/__pycache__/utils.cpython-311.pyc,,
+CDK_pywrapper/cdk_pywrapper.py,sha256=e8Fi2_A0G50l_QTLy9dFnefkmW2HapmmZVSJQY2rObg,16483
+CDK_pywrapper/descs.json,sha256=azoT6OdJZelocf-qxjLwscMmSOBYTytLRWhVSXeEXUE,68538
+CDK_pywrapper/utils.py,sha256=w1dLTNlK4cu1QFeYuWo57hIuD0r-e2A2cz-pe2n4CKc,3224

venv/Lib/site-packages/CDK_pywrapper-0.1.0.dist-info/WHEEL

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

venv/Lib/site-packages/CDK_pywrapper-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+CDK_pywrapper

venv/Lib/site-packages/CDK_pywrapper/CDKdesc.jar

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

venv/Lib/site-packages/CDK_pywrapper/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8
+
+"""Wrapper for CDK molecular descriptors and fingerprints"""
+
+from .cdk_pywrapper import CDK, FPType
+
+__version__ = "0.1.0"

venv/Lib/site-packages/CDK_pywrapper/cdk_pywrapper.py

@@ -0,0 +1,308 @@
+# -*- coding: utf-8
+
+"""Python wrapper for CDK descriptors and fingerprints"""
+
+from __future__ import annotations
+
+import io
+import multiprocessing
+import os
+import subprocess
+import warnings
+from copy import deepcopy
+from enum import Enum, auto
+from subprocess import Popen, PIPE
+from typing import Iterable, List, Optional
+
+import more_itertools
+import numpy as np
+import pandas as pd
+from bounded_pool_executor import BoundedProcessPoolExecutor
+from rdkit import Chem
+from rdkit.rdBase import BlockLogs
+
+from .utils import install_java, mktempfile, needsHs
+
+
+class FPType(Enum):
+    FP = auto()
+    ExtFP = auto()
+    EStateFP = auto()
+    GraphFP = auto()
+    MACCSFP = auto()
+    PubchemFP = auto()
+    SubFP = auto()
+    KRFP = auto()
+    AP2DFP = auto()
+    HybridFP = auto()
+    LingoFP = auto()
+    SPFP = auto()
+    SigFP = auto()
+    CircFP = auto()
+
+
+class CDK:
+    """Wrapper to obtain molecular descriptor from CDK."""
+
+    lock = multiprocessing.RLock()  # Ensure installation of JRE is thread safe
+    # Path to the JAR file
+    _jarfile = os.path.abspath(os.path.join(__file__, os.pardir, 'CDKdesc.jar'))
+
+    def __init__(self, ignore_3D: bool = True, fingerprint: FPType = None, nbits: int = 1024, depth: int = 6,
+                 backend_smiles: bool = False):
+        """Instantiate a wrapper to calculate CDK molecular descriptors or a fingerprint.
+
+        :param ignore_3D: whether to include 3D molecular descriptors
+        :param fingerprint: a fingerprint type to be calculated (default: None, calculates descriptors)
+        :param nbits: number of bits (default: 1024 unless the fingerprint has a fixed size)
+        :param depth: depth of the fingerprint (default: 6 unless the fingerprint does not depend on depth)
+        :param backend_smiles: use SMILES as the interchange format to discuss with the CDKdesc backend;
+        the default (i.e. backend_smiles=False) makes use of the V2000 SD format; is ignored if ignore_3D=True.
+        """
+        # Ensure the jar file exists
+        if not os.path.isfile(self._jarfile):
+            raise IOError('The required CDKdesc JAR file is not present. Reinstall CDK-pywrapper.')
+        if fingerprint is not None:
+            if not isinstance(fingerprint, FPType):
+                raise TypeError(f'Fingerprint type not supported: {fingerprint}')
+        self.include_3D = not ignore_3D
+        self.fingerprint = None if fingerprint is None else fingerprint.name
+        self.nbits = nbits
+        self.depth = depth
+        self.backend_smiles = backend_smiles and ignore_3D  # if include_3D, then always False
+
+    def calculate(self, mols: List[Chem.Mol], show_banner: bool = True, cdk_smiles: bool = False,
+                  njobs: int = 1, chunksize: Optional[int] = 1000) -> pd.DataFrame:
+        """Calculate molecular fingerprints.
+
+        :param mols: RDKit molecules for which descriptors/fingerprints should be calculated
+        (must have 3D conformers if calculating descriptors)
+        :param show_banner: If True, show notice on this package usage
+        :param cdk_smiles: If True, generate the canonical SMILES (generated by CDK) of molecules parsed by CDK
+        :param njobs: number of concurrent processes
+        :param chunksize: number of molecules to be processed by a process; ignored if njobs is 1
+        :return: a pandas DataFrame containing all CDK descriptor/fingerprint values
+        """
+        if show_banner:
+            self._show_banner()
+        if njobs < 0:
+            njobs = os.cpu_count() - njobs + 1
+        # Parallelize should need be
+        if njobs > 1:
+            with BoundedProcessPoolExecutor(max_workers=njobs) as worker:
+                futures = [worker.submit(self._multiproc_calculate, list(chunk), cdk_smiles)
+                           for chunk in more_itertools.batched(mols, chunksize)
+                           ]
+            return (pd.concat([future.result() for future in futures]).
+                    reset_index(drop=True)
+                    )
+        # Single process
+        return self._calculate(list(mols), cdk_smiles)
+
+    def _show_banner(self):
+        """Print info message for citing."""
+        print("""The Chemistry Development Kit (CDK) is a collection of modular Java libraries
+for processing chemical information (Cheminformatics). It can compute 14 different fingerprint
+types and 287 molecular descriptors (it requires 3D molecular structures for the latter).
+
+###################################
+
+Should you publish results based on the PaDEL descriptors,
+please cite:
+
+Willighagen et al., (2017)  J. Cheminf. 9(3), doi:10.1186/s13321-017-0220-4,
+May and Steinbeck., (2014) J. Cheminf., doi:10.1186/1758-2946-6-3,
+Steinbeck et al., (2006) Curr. Pharm. Des. 12(17):2111-2120, doi:10.2174/138161206777585274,
+Steinbeck et al., (2003) J. Chem. Inf. Comput. Sci. 43(2):493-500, doi:10.1021/ci025584y.
+
+###################################
+
+""")
+
+    def _prepare_command(self, mols: List[Chem.Mol], cdk_smiles: bool = False) -> str:
+        """Create the CDK command to be run to obtain molecular descriptors.
+
+        :param mols: molecules to obtained molecular descriptors of
+        :param cdk_smiles: If True, generate the canonical SMILES (generated by CDK) of molecules parsed by CDK
+        :return: The command to run.
+        """
+        # 1) Ensure JRE is accessible
+        with self.lock:
+            self._java_path = install_java(19)
+        # 2) Create temp SD v2k or SMILES file
+        self._tmp_input = mktempfile('molecules_.smi') if self.backend_smiles else mktempfile('molecules_v2k.sd')
+        self._n_mols = 0
+        self._skipped = []
+        self.n = 0
+        try:
+            block = BlockLogs()
+            if self.backend_smiles:
+                writer = Chem.SmilesWriter(self._tmp_input, includeHeader=False, isomericSmiles=True, kekuleSmiles=True)
+            else:
+                writer = Chem.SDWriter(self._tmp_input)
+                # Ensure V2000 as CDK cannot properly process v3000
+                writer.SetForceV3000(False)
+            for i, mol in enumerate(mols):
+                if mol is not None and isinstance(mol, Chem.Mol):
+                    if not self.backend_smiles and mol.GetNumAtoms() > 999:
+                        raise ValueError('Cannot calculate descriptors for molecules with more than 999 atoms.')
+                    # Does molecule lack hydrogen atoms?
+                    if needsHs(mol):
+                        warnings.warn('Molecule lacks hydrogen atoms: this might affect the value of calculated descriptors')
+                    # Are molecules 3D
+                    if self.include_3D:
+                        confs = list(mol.GetConformers())
+                        if self.fingerprint is None and not (len(confs) > 0 and confs[-1].Is3D()):
+                            raise ValueError('Cannot calculate the 3D descriptors of a conformer-less molecule')
+                    writer.write(mol)
+                    self._n_mols += 1
+                else:
+                    self._skipped.append(i)
+                self.n += 1
+            writer.close()
+            del block
+        except ValueError as e:
+            # Free resources and raise error
+            writer.close()
+            del block
+            os.remove(self._tmp_input)
+            raise e from None
+        # 3) Create command
+        java_path = install_java(19)
+        command_parameters = (f"-f {self.fingerprint} -nBits {self.nbits} "
+                              f"-depth {self.depth}") if self.fingerprint is not None else ""
+        command_file = f"-{'s' if self.backend_smiles else 'i'} {self._tmp_input}"
+        command_out_smiles = "-S" if cdk_smiles else ""
+        command = f"{java_path} -jar {self._jarfile} {command_file} {command_parameters} {command_out_smiles}"
+        return command
+
+    def _cleanup(self) -> None:
+        """Cleanup resources used for calculation."""
+        # Remove temporary files
+        os.remove(self._tmp_input)
+
+    def _run_command(self, command: str) -> pd.DataFrame:
+        """Run the CDK command.
+
+        :param command: The command to be run.
+        """
+        with Popen(command.split(), stdout=PIPE, stderr=subprocess.DEVNULL) as process:
+            values = process.stdout.read().decode()
+        # CDK barf preventing correct parsing
+        if 'not found' in values:
+            # Omit error
+            values = '\n'.join(line for line in values.split('\n') if 'not found' not in line)
+        # Empty result file
+        if len(values) == 0:
+            details = self.get_details()
+            values = pd.DataFrame(np.full((self._n_mols, details.shape[0]), np.nan),
+                                  columns=details.Name)
+        elif '{' not in values:
+            if self.fingerprint is None:
+                values = values.split('\n')
+                # Ensure all columns are present in the header
+                values[0] = (f'{"SMILES " if values[0].startswith("SMILES") else ""}'
+                             'Fsp3 nSmallRings nAromRings nRingBlocks nAromBlocks nRings3 nRings4 nRings5 nRings6 '
+                             'nRings7 nRings8 nRings9 tpsaEfficiency Zagreb XLogP WPATH WPOL Wlambda1.unity Wlambda2.unity '
+                             'Wlambda3.unity Wnu1.unity Wnu2.unity Wgamma1.unity Wgamma2.unity Wgamma3.unity Weta1.unity '
+                             'Weta2.unity Weta3.unity WT.unity WA.unity WV.unity WK.unity WG.unity WD.unity WTPT-1 WTPT-2 '
+                             'WTPT-3 WTPT-4 WTPT-5 MW VAdjMat VABC TopoPSA LipinskiFailures nRotB topoShape geomShape '
+                             'PetitjeanNumber MOMI-X MOMI-Y MOMI-Z MOMI-XY MOMI-XZ MOMI-YZ MOMI-R MDEC-11 MDEC-12 MDEC-13 '
+                             'MDEC-14 MDEC-22 MDEC-23 MDEC-24 MDEC-33 MDEC-34 MDEC-44 MDEO-11 MDEO-12 MDEO-22 MDEN-11 '
+                             'MDEN-12 MDEN-13 MDEN-22 MDEN-23 MDEN-33 MLogP nAtomLAC LOBMAX LOBMIN nAtomP nAtomLC khs.sLi '
+                             'khs.ssBe khs.ssssBe khs.ssBH khs.sssB khs.ssssB khs.sCH3 khs.dCH2 khs.ssCH2 khs.tCH khs.dsCH '
+                             'khs.aaCH khs.sssCH khs.ddC khs.tsC khs.dssC khs.aasC khs.aaaC khs.ssssC khs.sNH3 khs.sNH2 '
+                             'khs.ssNH2 khs.dNH khs.ssNH khs.aaNH khs.tN khs.sssNH khs.dsN khs.aaN khs.sssN khs.ddsN '
+                             'khs.aasN khs.ssssN khs.sOH khs.dO khs.ssO khs.aaO khs.sF khs.sSiH3 khs.ssSiH2 khs.sssSiH '
+                             'khs.ssssSi khs.sPH2 khs.ssPH khs.sssP khs.dsssP khs.sssssP khs.sSH khs.dS khs.ssS khs.aaS '
+                             'khs.dssS khs.ddssS khs.sCl khs.sGeH3 khs.ssGeH2 khs.sssGeH khs.ssssGe khs.sAsH2 khs.ssAsH '
+                             'khs.sssAs khs.sssdAs khs.sssssAs khs.sSeH khs.dSe khs.ssSe khs.aaSe khs.dssSe khs.ddssSe '
+                             'khs.sBr khs.sSnH3 khs.ssSnH2 khs.sssSnH khs.ssssSn khs.sI khs.sPbH3 khs.ssPbH2 khs.sssPbH '
+                             'khs.ssssPb Kier1 Kier2 Kier3 HybRatio nHBDon nHBAcc GRAV-1 GRAV-2 GRAV-3 GRAVH-1 GRAVH-2 '
+                             'GRAVH-3 GRAV-4 GRAV-5 GRAV-6 fragC FMF ECCEN PPSA-1 PPSA-2 PPSA-3 PNSA-1 PNSA-2 PNSA-3 '
+                             'DPSA-1 DPSA-2 DPSA-3 FPSA-1 FPSA-2 FPSA-3 FNSA-1 FNSA-2 FNSA-3 WPSA-1 WPSA-2 WPSA-3 WNSA-1 '
+                             'WNSA-2 WNSA-3 RPCG RNCG RPCS RNCS THSA TPSA RHSA RPSA SP-0 SP-1 SP-2 SP-3 SP-4 SP-5 SP-6 '
+                             'SP-7 VP-0 VP-1 VP-2 VP-3 VP-4 VP-5 VP-6 VP-7 SPC-4 SPC-5 SPC-6 VPC-4 VPC-5 VPC-6 SC-3 SC-4 '
+                             'SC-5 SC-6 VC-3 VC-4 VC-5 VC-6 SCH-3 SCH-4 SCH-5 SCH-6 SCH-7 VCH-3 VCH-4 VCH-5 VCH-6 VCH-7 '
+                             'C1SP1 C2SP1 C1SP2 C2SP2 C3SP2 C1SP3 C2SP3 C3SP3 C4SP3 bpol nB BCUTw-1l BCUTw-1h BCUTc-1l '
+                             'BCUTc-1h BCUTp-1l BCUTp-1h nBase ATSp1 ATSp2 ATSp3 ATSp4 ATSp5 ATSm1 ATSm2 ATSm3 ATSm4 '
+                             'ATSm5 ATSc1 ATSc2 ATSc3 ATSc4 ATSc5 nAtom nAromBond naAromAtom apol ALogP ALogp2 AMR nAcid '
+                             'JPLogP')
+                # CDK uses uppercase exponents but pandas needs a lowercase
+                values = '\n'.join([values[0]] + [line.replace('E', 'e') for line in values[1:]])
+            # Parse with pandas
+            values = pd.read_csv(io.StringIO(values), sep=' ')
+        else:
+            try:
+                values = pd.DataFrame.from_dict(eval('{%s}' % values), orient='index').fillna(0)
+                # Separate SMILES when calculated
+                if isinstance(values.index[0], str) and values.index.str.contains('|').any():
+                    smiles = pd.Series(values.index.str.split('|').str[1], name='SMILES').reset_index(drop=True)
+                    values = (pd.concat([smiles, values.reset_index(drop=True)], axis=1)
+                              .reset_index(drop=True))
+            except pd.errors.EmptyDataError:
+                raise RuntimeError('CDK could not obtain molecular descriptors, maybe due to a faulty molecule')
+        # If only 2D, remove 3D descriptors
+        if not self.include_3D and self.fingerprint is None:
+            # Get 3D descriptor names to remove
+            descs_3D = self.get_details()
+            descs_3D = descs_3D[descs_3D.Dimensions == '3D']
+            values = values[[col for col in values.columns if col not in descs_3D.Name.tolist()]]
+        return values
+
+    def _calculate(self, mols: List[Chem.Mol], cdk_smiles: bool = False) -> pd.DataFrame:
+        """Calculate CDK molecular descriptors on one process.
+
+        :param mols: RDKit molecules for which CDK descriptors and fingerprints should be calculated.
+        :param cdk_smiles: If True, generate the canonical SMILES (generated by CDK) of molecules parsed by CDK
+        :return: a pandas DataFrame containing CDK descriptor values
+        """
+        # Prepare inputs
+        command = self._prepare_command(mols, cdk_smiles)
+        # Run command and obtain results
+        results = self._run_command(command)
+        # Cleanup
+        self._cleanup()
+        # Insert lines of skipped molecules
+        if len(self._skipped):
+            results = pd.DataFrame(np.insert(results.values, self._skipped,
+                                              values=[np.NaN] * len(results.columns),
+                                              axis=0),
+                                    columns=results.columns)
+        # Omit SMILES column from casting if in values
+        if cdk_smiles:
+            smiles_col = results['SMILES']
+            results = results.drop(columns=['SMILES'])
+        results = (results.apply(pd.to_numeric, errors='coerce', axis=1)
+                   )
+        # Insert SMILES column back
+        if cdk_smiles:
+            results = pd.concat([smiles_col, results], axis=1)
+        return results
+
+    def _multiproc_calculate(self, mols: List[Chem.Mol], cdk_smiles: bool = False) -> pd.DataFrame:
+        """Calculate CDK descriptors and fingerprints in thread-safe manner.
+
+        :param mols: RDKit molecules for which CDK descriptors and fingerprints should be calculated
+        :param cdk_smiles: If True, generate the canonical SMILES (generated by CDK) of molecules parsed by CDK
+        :return: a pandas DataFrame containing all CDK descriptor values
+        """
+        # Copy self instance to make thread safe
+        cdk = deepcopy(self)
+        # Run copy
+        result = cdk.calculate(mols, show_banner=False, njobs=1, cdk_smiles=cdk_smiles)
+        return result
+
+    @staticmethod
+    def get_details(desc_name: Optional[str] = None):
+        """Obtain details about either one or all descriptors.
+
+        :param desc_name: the name of the descriptor to obtain details about (default: None).
+        If None, returns details about all descriptors.
+        """
+        details = pd.read_json(os.path.abspath(os.path.join(__file__, os.pardir, 'descs.json')), orient='index')
+        if desc_name is not None:
+            if desc_name not in details.Name.tolist():
+                raise ValueError(f'descriptor name {desc_name} is not available')
+            details = details[details.Name == desc_name]
+        return details

venv/Lib/site-packages/CDK_pywrapper/descs.json

@@ -0,0 +1,1730 @@
+{
+    "0":{
+        "Name":"nAcid",
+        "Description":"The number of acidic groups.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "1":{
+        "Name":"naAromAtom",
+        "Description":"The number of aromatic atoms in an atom container.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "2":{
+        "Name":"nAromBond",
+        "Description":"The number of aromatic atoms in an AtomContainer.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "3":{
+        "Name":"nAtom",
+        "Description":"The number of atoms of a certain element type.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "4":{
+        "Name":"nBase",
+        "Description":"The number of basic groups.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "5":{
+        "Name":"nB",
+        "Description":"The number of bonds of a certain bond order.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "6":{
+        "Name":"HybRatio",
+        "Description":"The fraction of sp3 carbons to sp2 carbons.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "7":{
+        "Name":"Fsp3",
+        "Description":"The fraction of sp3 carbons to all carbons.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "8":{
+        "Name":"nAtomLC",
+        "Description":"The number of atoms in the largest chain.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "9":{
+        "Name":"nAtomP",
+        "Description":"?The number of atoms in the largest pi system.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "10":{
+        "Name":"nAtomLAC",
+        "Description":"The number of atoms in the longest aliphatic chain.",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "11":{
+        "Name":"nRotB",
+        "Description":"The number of rotatable bonds is given by the SMARTS specified by Daylight on?SMARTS tutorial",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "12":{
+        "Name":"nSmallRings",
+        "Description":"total number of small rings (of size 3 through 9)",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "13":{
+        "Name":"nAromRings",
+        "Description":"total number of small aromatic rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "14":{
+        "Name":"nRingBlocks",
+        "Description":"total number of distinct ring blocks",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "15":{
+        "Name":"nAromBlocks",
+        "Description":"total number of aromatically connected components",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "16":{
+        "Name":"nRings3",
+        "Description":"total number of 3-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "17":{
+        "Name":"nRings4",
+        "Description":"total number of 4-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "18":{
+        "Name":"nRings5",
+        "Description":"total number of 5-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "19":{
+        "Name":"nRings6",
+        "Description":"total number of 6-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "20":{
+        "Name":"nRings7",
+        "Description":"total number of 7-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "21":{
+        "Name":"nRings8",
+        "Description":"total number of 8-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "22":{
+        "Name":"nRings9",
+        "Description":"total number of 9-membered rings",
+        "Type":"Constitutional descriptors",
+        "Dimensions":"1D"
+    },
+    "23":{
+        "Name":"ALogP",
+        "Description":"This class calculates ALOGP (Ghose-Crippen LogKow) and the Ghose-Crippen molar refractivity [Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional structure-directed quantitative structure-activity relationships. I. Partition coefficients as a measure of hydrophobicity, Journal of Computational Chemistry,?1986, 7:565-577, Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional-structure-directed quantitative structure-activity relationships. 2. Modeling dispersive and hydrophobic interactions, Journal of Chemical Information and Computer Science,?1987, 27:21-35].",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "24":{
+        "Name":"ALogp2",
+        "Description":"This class calculates ALOGP (Ghose-Crippen LogKow) and the Ghose-Crippen molar refractivity [Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional structure-directed quantitative structure-activity relationships. I. Partition coefficients as a measure of hydrophobicity, Journal of Computational Chemistry,?1986, 7:565-577, Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional-structure-directed quantitative structure-activity relationships. 2. Modeling dispersive and hydrophobic interactions, Journal of Chemical Information and Computer Science,?1987, 27:21-35].",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "25":{
+        "Name":"AMR",
+        "Description":"This class calculates ALOGP (Ghose-Crippen LogKow) and the Ghose-Crippen molar refractivity [Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional structure-directed quantitative structure-activity relationships. I. Partition coefficients as a measure of hydrophobicity, Journal of Computational Chemistry,?1986, 7:565-577, Ghose, A.K. and Crippen, G.M. ,?Atomic physicochemical parameters for three-dimensional-structure-directed quantitative structure-activity relationships. 2. Modeling dispersive and hydrophobic interactions, Journal of Chemical Information and Computer Science,?1987, 27:21-35].",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "26":{
+        "Name":"BCUTw-1l",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "27":{
+        "Name":"BCUTw-1h",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "28":{
+        "Name":"BCUTc-1l",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "29":{
+        "Name":"BCUTc-1h",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "30":{
+        "Name":"BCUTp-1l",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "31":{
+        "Name":"BCUTp-1h",
+        "Description":"Eigenvalue based descriptor noted for its utility in chemical diversity.",
+        "Type":"BCUT descriptors",
+        "Dimensions":"2D"
+    },
+    "32":{
+        "Name":"fragC",
+        "Description":"the complexity of a system. The complexity is defined as [Nilakantan, R. and Nunn, D.S. and Greenblatt, L. and Walker, G. and Haraki, K. and Mobilio, D., A family of ring system-based structural fragments for use in structure-activity studies: database mining and recursive partitioning., Journal of chemical information and modeling, 2006, 46:1069-1077]:",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "33":{
+        "Name":"apol",
+        "Description":"Sum of the atomic polarizabilities (including implicit hydrogens).",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "34":{
+        "Name":"ATSc1",
+        "Description":"?ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "35":{
+        "Name":"ATSc2",
+        "Description":"?ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "36":{
+        "Name":"ATSc3",
+        "Description":"?ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "37":{
+        "Name":"ATSc4",
+        "Description":"?ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "38":{
+        "Name":"ATSc5",
+        "Description":"?ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "39":{
+        "Name":"ATSm1",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the scaled atomic mass [Moreau G. and Broto P.,?The autocorrelation of a topological structure: A new molecular descriptor, Nouveau Journal de Chimie,?1980, ?:359-360].",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "40":{
+        "Name":"ATSm2",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the scaled atomic mass [Moreau G. and Broto P.,?The autocorrelation of a topological structure: A new molecular descriptor, Nouveau Journal de Chimie,?1980, ?:359-361].",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "41":{
+        "Name":"ATSm3",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the scaled atomic mass [Moreau G. and Broto P.,?The autocorrelation of a topological structure: A new molecular descriptor, Nouveau Journal de Chimie,?1980, ?:359-362].",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "42":{
+        "Name":"ATSm4",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the scaled atomic mass [Moreau G. and Broto P.,?The autocorrelation of a topological structure: A new molecular descriptor, Nouveau Journal de Chimie,?1980, ?:359-363].",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "43":{
+        "Name":"ATSm5",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the scaled atomic mass [Moreau G. and Broto P.,?The autocorrelation of a topological structure: A new molecular descriptor, Nouveau Journal de Chimie,?1980, ?:359-364].",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "44":{
+        "Name":"ATSp1",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "45":{
+        "Name":"ATSp2",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "46":{
+        "Name":"ATSp3",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "47":{
+        "Name":"ATSp4",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "48":{
+        "Name":"ATSp5",
+        "Description":"ATS autocorrelation descriptor, where the weight equal to the charges.",
+        "Type":"Autocorrelation descriptors",
+        "Dimensions":"2D"
+    },
+    "49":{
+        "Name":"bpol",
+        "Description":"Sum of the absolute value of the difference between atomic polarizabilities of all bonded atoms in the molecule (including implicit hydrogens) with polarizabilities taken from http:\/\/www.sunysccc.edu\/academic\/mst\/ptable\/p-table2.htm This descriptor assumes 2-centered bonds.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "50":{
+        "Name":"C1SP1",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "51":{
+        "Name":"C2SP1",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "52":{
+        "Name":"C1SP2",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "53":{
+        "Name":"C2SP2",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "54":{
+        "Name":"C3SP2",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "55":{
+        "Name":"C1SP3",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "56":{
+        "Name":"C2SP3",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "57":{
+        "Name":"C3SP3",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "58":{
+        "Name":"C4SP3",
+        "Description":"Topological descriptor characterizing the carbon connectivity.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "59":{
+        "Name":"SCH-3",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "60":{
+        "Name":"SCH-4",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "61":{
+        "Name":"SCH-5",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "62":{
+        "Name":"SCH-6",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "63":{
+        "Name":"SCH-7",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "64":{
+        "Name":"VCH-3",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "65":{
+        "Name":"VCH-4",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "66":{
+        "Name":"VCH-5",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "67":{
+        "Name":"VCH-6",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "68":{
+        "Name":"VCH-7",
+        "Description":"Evaluates chi chain descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "69":{
+        "Name":"SC-3",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "70":{
+        "Name":"SC-4",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "71":{
+        "Name":"SC-5",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "72":{
+        "Name":"SC-6",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "73":{
+        "Name":"VC-3",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "74":{
+        "Name":"VC-4",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "75":{
+        "Name":"VC-5",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "76":{
+        "Name":"VC-6",
+        "Description":"Evaluates chi cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "77":{
+        "Name":"SP-0",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "78":{
+        "Name":"SP-1",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "79":{
+        "Name":"SP-2",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "80":{
+        "Name":"SP-3",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "81":{
+        "Name":"SP-4",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "82":{
+        "Name":"SP-5",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "83":{
+        "Name":"SP-6",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "84":{
+        "Name":"SP-7",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "85":{
+        "Name":"VP-0",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "86":{
+        "Name":"VP-1",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "87":{
+        "Name":"VP-2",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "88":{
+        "Name":"VP-3",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "89":{
+        "Name":"VP-4",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "90":{
+        "Name":"VP-5",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "91":{
+        "Name":"VP-6",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "92":{
+        "Name":"VP-7",
+        "Description":"Evaluates chi path descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "93":{
+        "Name":"SPC-4",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "94":{
+        "Name":"SPC-5",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "95":{
+        "Name":"SPC-6",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "96":{
+        "Name":"VPC-4",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "97":{
+        "Name":"VPC-5",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "98":{
+        "Name":"VPC-6",
+        "Description":"Evaluates chi path cluster descriptors.",
+        "Type":"Connectivity descriptors",
+        "Dimensions":"2D"
+    },
+    "99":{
+        "Name":"ECCEN",
+        "Description":"A topological descriptor combining distance and adjacency information.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "100":{
+        "Name":"FMF",
+        "Description":"An implementation of the FMF descriptor characterizing complexity of a molecule.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "101":{
+        "Name":"nHBAcc",
+        "Description":"The number of hydrogen bond donors using a slightly simplified version of the?PHACIR atom types.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "102":{
+        "Name":"nHBDon",
+        "Description":"?The number of hydrogen bond acceptors using a slightly simplified version of the?PHACIR atom types.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "103":{
+        "Name":"khs.sLi",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "104":{
+        "Name":"khs.ssBe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "105":{
+        "Name":"khs.ssssBe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "106":{
+        "Name":"khs.ssBH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "107":{
+        "Name":"khs.sssB",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "108":{
+        "Name":"khs.ssssB",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "109":{
+        "Name":"khs.sCH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "110":{
+        "Name":"khs.dCH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "111":{
+        "Name":"khs.ssCH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "112":{
+        "Name":"khs.tCH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "113":{
+        "Name":"khs.dsCH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "114":{
+        "Name":"khs.aaCH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "115":{
+        "Name":"khs.sssCH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "116":{
+        "Name":"khs.ddC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "117":{
+        "Name":"khs.tsC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "118":{
+        "Name":"khs.dssC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "119":{
+        "Name":"khs.aasC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "120":{
+        "Name":"khs.aaaC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "121":{
+        "Name":"khs.ssssC",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "122":{
+        "Name":"khs.sNH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "123":{
+        "Name":"khs.sNH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "124":{
+        "Name":"khs.ssNH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "125":{
+        "Name":"khs.dNH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "126":{
+        "Name":"khs.ssNH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "127":{
+        "Name":"khs.aaNH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "128":{
+        "Name":"khs.tN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "129":{
+        "Name":"khs.sssNH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "130":{
+        "Name":"khs.dsN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "131":{
+        "Name":"khs.aaN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "132":{
+        "Name":"khs.sssN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "133":{
+        "Name":"khs.ddsN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "134":{
+        "Name":"khs.aasN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "135":{
+        "Name":"khs.ssssN",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "136":{
+        "Name":"khs.sOH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "137":{
+        "Name":"khs.dO",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "138":{
+        "Name":"khs.ssO",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "139":{
+        "Name":"khs.aaO",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "140":{
+        "Name":"khs.sF",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "141":{
+        "Name":"khs.sSiH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "142":{
+        "Name":"khs.ssSiH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "143":{
+        "Name":"khs.sssSiH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "144":{
+        "Name":"khs.ssssSi",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "145":{
+        "Name":"khs.sPH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "146":{
+        "Name":"khs.ssPH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "147":{
+        "Name":"khs.sssP",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "148":{
+        "Name":"khs.dsssP",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "149":{
+        "Name":"khs.sssssP",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "150":{
+        "Name":"khs.sSH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "151":{
+        "Name":"khs.dS",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "152":{
+        "Name":"khs.ssS",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "153":{
+        "Name":"khs.aaS",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "154":{
+        "Name":"khs.dssS",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "155":{
+        "Name":"khs.ddssS",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "156":{
+        "Name":"khs.sCl",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "157":{
+        "Name":"khs.sGeH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "158":{
+        "Name":"khs.ssGeH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "159":{
+        "Name":"khs.sssGeH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "160":{
+        "Name":"khs.ssssGe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "161":{
+        "Name":"khs.sAsH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "162":{
+        "Name":"khs.ssAsH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "163":{
+        "Name":"khs.sssAs",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "164":{
+        "Name":"khs.sssdAs",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "165":{
+        "Name":"khs.sssssAs",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "166":{
+        "Name":"khs.sSeH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "167":{
+        "Name":"khs.dSe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "168":{
+        "Name":"khs.ssSe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "169":{
+        "Name":"khs.aaSe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "170":{
+        "Name":"khs.dssSe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "171":{
+        "Name":"khs.ddssSe",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "172":{
+        "Name":"khs.sBr",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "173":{
+        "Name":"khs.sSnH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "174":{
+        "Name":"khs.ssSnH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "175":{
+        "Name":"khs.sssSnH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "176":{
+        "Name":"khs.ssssSn",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "177":{
+        "Name":"khs.sI",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "178":{
+        "Name":"khs.sPbH3",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "179":{
+        "Name":"khs.ssPbH2",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "180":{
+        "Name":"khs.sssPbH",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "181":{
+        "Name":"khs.ssssPb",
+        "Description":"A fragment count descriptor that uses e-state fragments.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "182":{
+        "Name":"Kier1",
+        "Description":"Kier and Hall kappa molecular shape indices compare the molecular graph with minimal and maximal molecular graphs; a description is given at: http:\/\/www.chemcomp.com\/Journal_of_CCG\/Features\/descr.htm#KH : \"they are intended to capture different aspects of molecular shape.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "183":{
+        "Name":"Kier2",
+        "Description":"Kier and Hall kappa molecular shape indices compare the molecular graph with minimal and maximal molecular graphs; a description is given at: http:\/\/www.chemcomp.com\/Journal_of_CCG\/Features\/descr.htm#KH : \"they are intended to capture different aspects of molecular shape.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "184":{
+        "Name":"Kier3",
+        "Description":"Kier and Hall kappa molecular shape indices compare the molecular graph with minimal and maximal molecular graphs; a description is given at: http:\/\/www.chemcomp.com\/Journal_of_CCG\/Features\/descr.htm#KH : \"they are intended to capture different aspects of molecular shape.",
+        "Type":"Kappa descriptors",
+        "Dimensions":"2D"
+    },
+    "185":{
+        "Name":"LipinskiFailures",
+        "Description":"The number failures of the Lipinski's Rule Of 5.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "186":{
+        "Name":"MLogP",
+        "Description":"Prediction of logP based on the number of carbon and hetero atoms.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "187":{
+        "Name":"MDEC-11",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "188":{
+        "Name":"MDEC-12",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "189":{
+        "Name":"MDEC-13",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "190":{
+        "Name":"MDEC-14",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "191":{
+        "Name":"MDEC-22",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "192":{
+        "Name":"MDEC-23",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "193":{
+        "Name":"MDEC-24",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "194":{
+        "Name":"MDEC-33",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "195":{
+        "Name":"MDEC-34",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "196":{
+        "Name":"MDEC-44",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "197":{
+        "Name":"MDEO-11",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "198":{
+        "Name":"MDEO-12",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "199":{
+        "Name":"MDEO-22",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "200":{
+        "Name":"MDEN-11",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "201":{
+        "Name":"MDEN-12",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "202":{
+        "Name":"MDEN-13",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "203":{
+        "Name":"MDEN-22",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "204":{
+        "Name":"MDEN-23",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "205":{
+        "Name":"MDEN-33",
+        "Description":"?The Molecular Distance Edge descriptor described in [Liu, S. and Cao, C. and Li, Z. ,?Approach to Estimation and Prediction for Normal Boiling Point (NBP) of Alkanes Based on a Novel Molecular Distance Edge (MDE) Vector, lambda, Journal of Chemical Information and Computer Sciences,?1998, 38:387-394].",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "206":{
+        "Name":"PetitjeanNumber",
+        "Description":"According to the Petitjean definition, the eccentricity of a vertex corresponds to the distance from that vertex to the most remote vertex in the graph.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "207":{
+        "Name":"topoShape",
+        "Description":"Evaluates the Petitjean shape indices,These original Petitjean number was described by Petitjean ([?Petitjean, M. ,?Applications of the radius-diameter diagram to the classification of topological and geometrical shapes of chemical compounds, Journal of Chemical Information and Computer Science,?1992, 32:331-337]) and considered the molecular graph.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "208":{
+        "Name":"geomShape",
+        "Description":"Evaluates the Petitjean shape indices,These original Petitjean number was described by Petitjean ([?Petitjean, M. ,?Applications of the radius-diameter diagram to the classification of topological and geometrical shapes of chemical compounds, Journal of Chemical Information and Computer Science,?1992, 32:331-337]) and considered the molecular graph.",
+        "Type":"Topological descriptors",
+        "Dimensions":"3D"
+    },
+    "209":{
+        "Name":"TopoPSA",
+        "Description":"Calculation of topological polar surface area based on fragment contributions (TPSA) [Ertl, P. and Rohde, B. and Selzer, P.,?Fast Calculation of Molecular Polar Surface Area as a Sum of Fragment-Based Contributions and Its Application to the Prediction of Drug Transport Properties, J. Med. Chem.,?2000, 43:3714-3717].",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "210":{
+        "Name":"tpsaEfficiency",
+        "Description":"Polar surface area expressed as a ratio to molecular size.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "211":{
+        "Name":"VAdjMat",
+        "Description":"Vertex adjacency information (magnitude): 1 + log2 m where m is the number of heavy-heavy bonds.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "212":{
+        "Name":"VABC",
+        "Description":"Volume descriptor using the method implemented in the?VABCVolume?class.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "213":{
+        "Name":"MW",
+        "Description":"The weight of atoms of a certain element type.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "214":{
+        "Name":"WTPT-1",
+        "Description":"Evaluates the weighted path descriptors.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "215":{
+        "Name":"WTPT-2",
+        "Description":"Evaluates the weighted path descriptors.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "216":{
+        "Name":"WTPT-3",
+        "Description":"Evaluates the weighted path descriptors.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "217":{
+        "Name":"WTPT-4",
+        "Description":"Evaluates the weighted path descriptors.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "218":{
+        "Name":"WTPT-5",
+        "Description":"Evaluates the weighted path descriptors.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "219":{
+        "Name":"WPATH",
+        "Description":"This descriptor calculates the Wiener numbers.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "220":{
+        "Name":"WPOL",
+        "Description":"This descriptor calculates the Wiener numbers.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "221":{
+        "Name":"XLogP",
+        "Description":"Prediction of logP based on the atom-type method called XLogP.",
+        "Type":"Molecular property descriptors",
+        "Dimensions":"2D"
+    },
+    "222":{
+        "Name":"Zagreb",
+        "Description":"Zagreb index: the sum of the squares of atom degree over all heavy atoms i.",
+        "Type":"Topological descriptors",
+        "Dimensions":"2D"
+    },
+    "223":{
+        "Name":"PPSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "224":{
+        "Name":"PPSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "225":{
+        "Name":"PPSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "226":{
+        "Name":"PNSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "227":{
+        "Name":"PNSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "228":{
+        "Name":"PNSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "229":{
+        "Name":"DPSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "230":{
+        "Name":"DPSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "231":{
+        "Name":"DPSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "232":{
+        "Name":"FPSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "233":{
+        "Name":"FPSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "234":{
+        "Name":"FPSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "235":{
+        "Name":"FNSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "236":{
+        "Name":"FNSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "237":{
+        "Name":"FNSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "238":{
+        "Name":"WPSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "239":{
+        "Name":"WPSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "240":{
+        "Name":"WPSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "241":{
+        "Name":"WNSA-1",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "242":{
+        "Name":"WNSA-2",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "243":{
+        "Name":"WNSA-3",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "244":{
+        "Name":"RPCG",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "245":{
+        "Name":"RNCG",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "246":{
+        "Name":"RPCS",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "247":{
+        "Name":"RNCS",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "248":{
+        "Name":"THSA",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "249":{
+        "Name":"TPSA",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "250":{
+        "Name":"RHSA",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "251":{
+        "Name":"RPSA",
+        "Description":"29 Charged Partial Surface Area (CPSA) descriptors.",
+        "Type":"CPSA descriptors",
+        "Dimensions":"3D"
+    },
+    "252":{
+        "Name":"Wlambda1.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-380].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "253":{
+        "Name":"Wlambda2.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-381].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "254":{
+        "Name":"Wlambda3.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-382].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "255":{
+        "Name":"Wnu1.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-383].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "256":{
+        "Name":"Wnu2.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-384].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "257":{
+        "Name":"Wgamma1.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-385].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "258":{
+        "Name":"Wgamma2.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-386].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "259":{
+        "Name":"Wgamma3.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-387].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "260":{
+        "Name":"Weta1.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-388].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "261":{
+        "Name":"Weta2.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-389].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "262":{
+        "Name":"Weta3.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-390].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "263":{
+        "Name":"WT.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-391].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "264":{
+        "Name":"WA.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-392].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "265":{
+        "Name":"WV.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-393].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "266":{
+        "Name":"WK.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-394].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "267":{
+        "Name":"WG.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-395].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "268":{
+        "Name":"WD.unity",
+        "Description":"Holistic descriptors described by Todeschini et al [Todeschini, R. and Gramatica, P.,?New 3D Molecular Descriptors: The WHIM theory and QAR Applications, Persepectives in Drug Discovery and Design,?1998, ?:355-396].",
+        "Type":"WHIM descriptors",
+        "Dimensions":"3D"
+    },
+    "269":{
+        "Name":"GRAV-1",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "270":{
+        "Name":"GRAV-2",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "271":{
+        "Name":"GRAV-3",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "272":{
+        "Name":"GRAVH-1",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "273":{
+        "Name":"GRAVH-2",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "274":{
+        "Name":"GRAVH-3",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "275":{
+        "Name":"GRAV-4",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "276":{
+        "Name":"GRAV-5",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "277":{
+        "Name":"GRAV-6",
+        "Description":"IDescriptor characterizing the mass distribution of the molecule.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "278":{
+        "Name":"LOBMIN",
+        "Description":"Evaluates length over breadth descriptors.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "279":{
+        "Name":"LOBMAX",
+        "Description":"Evaluates length over breadth descriptors.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "280":{
+        "Name":"MOMI-X",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "281":{
+        "Name":"MOMI-Y",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "282":{
+        "Name":"MOMI-Z",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "283":{
+        "Name":"MOMI-XY",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "284":{
+        "Name":"MOMI-XZ",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "285":{
+        "Name":"MOMI-YZ",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "286":{
+        "Name":"MOMI-R",
+        "Description":"A descriptor that calculates the moment of inertia and radius of gyration.",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"3D"
+    },
+    "287":{
+        "Name":"JPLogP",
+        "Description":"This class calculates JPlogP [Plante, J. and Werner, S. ,JPlogP: an improved logP predictor trained using predicted data, Journal of Cheminformatics, 2018, 10].",
+        "Type":"Geometrical descriptors",
+        "Dimensions":"2D"
+    }
+}

venv/Lib/site-packages/CDK_pywrapper/utils.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8
+
+"""Utility functions."""
+
+import sys
+import os
+import glob
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Tuple
+
+from rdkit import Chem
+from jdk import install as _jre_install, _JRE_DIR
+
+
+def install_jre(version: int = 19):
+    """Install a Java Runtime Environment."""
+    path = get_jre_in_dir(_JRE_DIR, version)
+    if len(path) == 0:
+        # Could not find JRE, install it
+        _ = _jre_install(version, jre=True)
+        path = get_jre_in_dir(_JRE_DIR, version)
+    return path
+
+
+def make_temp_jre() -> Tuple[str, str]:
+    """Copy the installed JRE to a temporary file.
+
+    Allows multiprocessing capacities.
+
+    :return: a tuple of (path to temp dir, path to the JRE)
+    """
+    # Path of JRE installation
+    install_path = [path for path in Path(install_jre()).parents
+                    if path.as_posix().endswith('jre') and not path.as_posix().endswith('.jre')][0]
+    # Path of temp dir
+    outdir = mktempdir()
+    # Make copy into dir
+    shutil.copytree(install_path, os.path.join(outdir, 'jre'))
+    # Find JRE in temp dir
+    path = get_jre_in_dir(outdir)
+    return outdir, path
+
+
+def get_jre_in_dir(dir: str):
+    """Recursively search the directory to find a JRE."""
+    paths = glob.glob(os.path.join(dir, '**', 'server',
+                                   'jvm.dll' if sys.platform == "win32" else 'libjvm.so'
+                                   ), recursive=True)
+    path = [path for path in paths if f'jre-{version}' in path]
+    if len(path):
+        return path[0]
+    return None
+
+
+def install_java(version: int = 19):
+    """Install a Java Runtime Environment."""
+    path = get_java_in_dir(_JRE_DIR, version)
+    if path is None:
+        # Could not find JRE, install it
+        _ = _jre_install(version, jre=True)
+        path = get_java_in_dir(_JRE_DIR, version)
+    return path
+
+
+def get_java_in_dir(dir: str, version: int):
+    """Recursively search the directory to find a JRE."""
+    paths = glob.glob(os.path.join(dir, '**', 'bin',
+                                  'java.exe' if sys.platform == "win32" else 'java'
+                                  ), recursive=True)
+    path = [path for path in paths if f'jdk-{version}' in path]
+    if len(path):
+        return os.path.abspath(path[0])
+    return None
+
+
+def mktempdir(suffix: str = None) -> str:
+    """Return the path to a writeable temporary directory."""
+    dir = tempfile.mkdtemp(suffix=suffix)
+    return dir
+
+
+def mktempfile(suffix: str = None) -> str:
+    """Return the path to a writeable temporary file."""
+    file = tempfile.mkstemp(suffix=suffix)
+    os.close(file[0])
+    return file[1]
+
+
+def needsHs(mol: Chem.Mol) -> bool:
+    """Return if the molecule lacks hydrogen atoms or not.
+
+    :param mol: RDKit Molecule
+    :return: True if the molecule lacks hydrogens.
+    """
+    for atom in mol.GetAtoms():
+        nHNbrs = 0
+        for nbr in atom.GetNeighbors():
+            if nbr.GetAtomicNum() == 1:
+                nHNbrs += 1
+        noNeighbors = False
+        if atom.GetTotalNumHs(noNeighbors) > nHNbrs:
+            return True
+    return False

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: contact@palletsprojects.com
+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=ircjsfhzblqgSzO8ow7-0pXK-RVqDqNRGQ8F650AUNM,102
+MarkupSafe-2.1.5.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=m1ysNeqf55zbEoJtaovca40ivrkEFolPlw5bGoC5Gi4,11290
+markupsafe/__pycache__/__init__.cpython-311.pyc,,
+markupsafe/__pycache__/_native.cpython-311.pyc,,
+markupsafe/_native.py,sha256=_Q7UsXCOvgdonCgqG3l5asANI6eo50EKnDM-mlwEC5M,1776
+markupsafe/_speedups.c,sha256=n3jzzaJwXcoN8nTFyA53f3vSqsWK2vujI-v6QYifjhQ,7403
+markupsafe/_speedups.cp311-win_amd64.pyd,sha256=MEqnkyBOHmstwQr50hKitovHjrHhMJ0gYmya4Fu1DK0,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: cp311-cp311-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 <jerome@leclan.ch>
+
+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 <jerome@leclan.ch>
+
+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 <jerome@leclan.ch>
+
+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"])