Remove stale generated workspace files

.venv/bin/Activate.ps1

@@ -1,247 +0,0 @@
-<#
-.Synopsis
-Activate a Python virtual environment for the current PowerShell session.
-
-.Description
-Pushes the python executable for a virtual environment to the front of the
-$Env:PATH environment variable and sets the prompt to signify that you are
-in a Python virtual environment. Makes use of the command line switches as
-well as the `pyvenv.cfg` file values present in the virtual environment.
-
-.Parameter VenvDir
-Path to the directory that contains the virtual environment to activate. The
-default value for this is the parent of the directory that the Activate.ps1
-script is located within.
-
-.Parameter Prompt
-The prompt prefix to display when this virtual environment is activated. By
-default, this prompt is the name of the virtual environment folder (VenvDir)
-surrounded by parentheses and followed by a single space (ie. '(.venv) ').
-
-.Example
-Activate.ps1
-Activates the Python virtual environment that contains the Activate.ps1 script.
-
-.Example
-Activate.ps1 -Verbose
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and shows extra information about the activation as it executes.
-
-.Example
-Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
-Activates the Python virtual environment located in the specified location.
-
-.Example
-Activate.ps1 -Prompt "MyPython"
-Activates the Python virtual environment that contains the Activate.ps1 script,
-and prefixes the current prompt with the specified string (surrounded in
-parentheses) while the virtual environment is active.
-
-.Notes
-On Windows, it may be required to enable this Activate.ps1 script by setting the
-execution policy for the user. You can do this by issuing the following PowerShell
-command:
-
-PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-
-For more information on Execution Policies: 
-https://go.microsoft.com/fwlink/?LinkID=135170
-
-#>
-Param(
-    [Parameter(Mandatory = $false)]
-    [String]
-    $VenvDir,
-    [Parameter(Mandatory = $false)]
-    [String]
-    $Prompt
-)
-
-<# Function declarations --------------------------------------------------- #>
-
-<#
-.Synopsis
-Remove all shell session elements added by the Activate script, including the
-addition of the virtual environment's Python executable from the beginning of
-the PATH variable.
-
-.Parameter NonDestructive
-If present, do not remove this function from the global namespace for the
-session.
-
-#>
-function global:deactivate ([switch]$NonDestructive) {
-    # Revert to original values
-
-    # The prior prompt:
-    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
-        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
-        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
-    }
-
-    # The prior PYTHONHOME:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
-        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
-    }
-
-    # The prior PATH:
-    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
-        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
-        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
-    }
-
-    # Just remove the VIRTUAL_ENV altogether:
-    if (Test-Path -Path Env:VIRTUAL_ENV) {
-        Remove-Item -Path env:VIRTUAL_ENV
-    }
-
-    # Just remove VIRTUAL_ENV_PROMPT altogether.
-    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
-        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
-    }
-
-    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
-    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
-        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
-    }
-
-    # Leave deactivate function in the global namespace if requested:
-    if (-not $NonDestructive) {
-        Remove-Item -Path function:deactivate
-    }
-}
-
-<#
-.Description
-Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
-given folder, and returns them in a map.
-
-For each line in the pyvenv.cfg file, if that line can be parsed into exactly
-two strings separated by `=` (with any amount of whitespace surrounding the =)
-then it is considered a `key = value` line. The left hand string is the key,
-the right hand is the value.
-
-If the value starts with a `'` or a `"` then the first and last character is
-stripped from the value before being captured.
-
-.Parameter ConfigDir
-Path to the directory that contains the `pyvenv.cfg` file.
-#>
-function Get-PyVenvConfig(
-    [String]
-    $ConfigDir
-) {
-    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
-
-    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
-    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
-
-    # An empty map will be returned if no config file is found.
-    $pyvenvConfig = @{ }
-
-    if ($pyvenvConfigPath) {
-
-        Write-Verbose "File exists, parse `key = value` lines"
-        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
-
-        $pyvenvConfigContent | ForEach-Object {
-            $keyval = $PSItem -split "\s*=\s*", 2
-            if ($keyval[0] -and $keyval[1]) {
-                $val = $keyval[1]
-
-                # Remove extraneous quotations around a string value.
-                if ("'""".Contains($val.Substring(0, 1))) {
-                    $val = $val.Substring(1, $val.Length - 2)
-                }
-
-                $pyvenvConfig[$keyval[0]] = $val
-                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
-            }
-        }
-    }
-    return $pyvenvConfig
-}
-
-
-<# Begin Activate script --------------------------------------------------- #>
-
-# Determine the containing directory of this script
-$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
-$VenvExecDir = Get-Item -Path $VenvExecPath
-
-Write-Verbose "Activation script is located in path: '$VenvExecPath'"
-Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
-Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
-
-# Set values required in priority: CmdLine, ConfigFile, Default
-# First, get the location of the virtual environment, it might not be
-# VenvExecDir if specified on the command line.
-if ($VenvDir) {
-    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
-}
-else {
-    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
-    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
-    Write-Verbose "VenvDir=$VenvDir"
-}
-
-# Next, read the `pyvenv.cfg` file to determine any required value such
-# as `prompt`.
-$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
-
-# Next, set the prompt from the command line, or the config file, or
-# just use the name of the virtual environment folder.
-if ($Prompt) {
-    Write-Verbose "Prompt specified as argument, using '$Prompt'"
-}
-else {
-    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
-    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
-        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
-        $Prompt = $pyvenvCfg['prompt'];
-    }
-    else {
-        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
-        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
-        $Prompt = Split-Path -Path $venvDir -Leaf
-    }
-}
-
-Write-Verbose "Prompt = '$Prompt'"
-Write-Verbose "VenvDir='$VenvDir'"
-
-# Deactivate any currently active virtual environment, but leave the
-# deactivate function in place.
-deactivate -nondestructive
-
-# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
-# that there is an activated venv.
-$env:VIRTUAL_ENV = $VenvDir
-
-if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
-
-    Write-Verbose "Setting prompt to '$Prompt'"
-
-    # Set the prompt to include the env name
-    # Make sure _OLD_VIRTUAL_PROMPT is global
-    function global:_OLD_VIRTUAL_PROMPT { "" }
-    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
-    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
-
-    function global:prompt {
-        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
-        _OLD_VIRTUAL_PROMPT
-    }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
-}
-
-# Clear PYTHONHOME
-if (Test-Path -Path Env:PYTHONHOME) {
-    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
-    Remove-Item -Path Env:PYTHONHOME
-}
-
-# Add the venv to the PATH
-Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
-$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

.venv/bin/activate

@@ -1,63 +0,0 @@
-# This file must be used with "source bin/activate" *from bash*
-# you cannot run it directly
-
-deactivate () {
-    # reset old environment variables
-    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
-        PATH="${_OLD_VIRTUAL_PATH:-}"
-        export PATH
-        unset _OLD_VIRTUAL_PATH
-    fi
-    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
-        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
-        export PYTHONHOME
-        unset _OLD_VIRTUAL_PYTHONHOME
-    fi
-
-    # Call hash to forget past commands. Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    hash -r 2> /dev/null
-
-    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
-        PS1="${_OLD_VIRTUAL_PS1:-}"
-        export PS1
-        unset _OLD_VIRTUAL_PS1
-    fi
-
-    unset VIRTUAL_ENV
-    unset VIRTUAL_ENV_PROMPT
-    if [ ! "${1:-}" = "nondestructive" ] ; then
-    # Self destruct!
-        unset -f deactivate
-    fi
-}
-
-# unset irrelevant variables
-deactivate nondestructive
-
-VIRTUAL_ENV="/workspace/.venv"
-export VIRTUAL_ENV
-
-_OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/bin:$PATH"
-export PATH
-
-# unset PYTHONHOME if set
-# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
-# could use `if (set -u; : $PYTHONHOME) ;` in bash
-if [ -n "${PYTHONHOME:-}" ] ; then
-    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
-    unset PYTHONHOME
-fi
-
-if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
-    _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1="(.venv) ${PS1:-}"
-    export PS1
-    VIRTUAL_ENV_PROMPT="(.venv) "
-    export VIRTUAL_ENV_PROMPT
-fi
-
-# Call hash to forget past commands. Without forgetting
-# past commands the $PATH changes we made may not be respected
-hash -r 2> /dev/null

.venv/bin/activate.csh

@@ -1,26 +0,0 @@
-# This file must be used with "source bin/activate.csh" *from csh*.
-# You cannot run it directly.
-# Created by Davide Di Blasi <davidedb@gmail.com>.
-# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
-
-alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-setenv VIRTUAL_ENV "/workspace/.venv"
-
-set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/bin:$PATH"
-
-
-set _OLD_VIRTUAL_PROMPT="$prompt"
-
-if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = "(.venv) $prompt"
-    setenv VIRTUAL_ENV_PROMPT "(.venv) "
-endif
-
-alias pydoc python -m pydoc
-
-rehash

.venv/bin/activate.fish

@@ -1,69 +0,0 @@
-# This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/); you cannot run it directly.
-
-function deactivate  -d "Exit virtual environment and return to normal shell environment"
-    # reset old environment variables
-    if test -n "$_OLD_VIRTUAL_PATH"
-        set -gx PATH $_OLD_VIRTUAL_PATH
-        set -e _OLD_VIRTUAL_PATH
-    end
-    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
-        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
-        set -e _OLD_VIRTUAL_PYTHONHOME
-    end
-
-    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        set -e _OLD_FISH_PROMPT_OVERRIDE
-        # prevents error when using nested fish instances (Issue #93858)
-        if functions -q _old_fish_prompt
-            functions -e fish_prompt
-            functions -c _old_fish_prompt fish_prompt
-            functions -e _old_fish_prompt
-        end
-    end
-
-    set -e VIRTUAL_ENV
-    set -e VIRTUAL_ENV_PROMPT
-    if test "$argv[1]" != "nondestructive"
-        # Self-destruct!
-        functions -e deactivate
-    end
-end
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-set -gx VIRTUAL_ENV "/workspace/.venv"
-
-set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/bin" $PATH
-
-# Unset PYTHONHOME if set.
-if set -q PYTHONHOME
-    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
-    set -e PYTHONHOME
-end
-
-if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
-    # fish uses a function instead of an env var to generate the prompt.
-
-    # Save the current fish_prompt function as the function _old_fish_prompt.
-    functions -c fish_prompt _old_fish_prompt
-
-    # With the original prompt function renamed, we can override with our own.
-    function fish_prompt
-        # Save the return status of the last command.
-        set -l old_status $status
-
-        # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) "(.venv) " (set_color normal)
-
-        # Restore the return status of the previous command.
-        echo "exit $old_status" | .
-        # Output the original/"old" prompt.
-        _old_fish_prompt
-    end
-
-    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT "(.venv) "
-end

.venv/bin/pip

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

.venv/bin/pip3

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

.venv/bin/pip3.11

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

.venv/bin/pygmentize

@@ -1,6 +0,0 @@
-#!/workspace/.venv/bin/python
-import sys
-from pygments.cmdline import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/bin/pygrun

@@ -1,164 +0,0 @@
-#!/workspace/.venv/bin/python
-__author__ = 'jszheng'
-import optparse
-import sys
-import os
-import importlib
-from antlr4 import *
-
-
-# this is a python version of TestRig
-def beautify_lisp_string(in_string):
-    indent_size = 3
-    add_indent = ' '*indent_size
-    out_string = in_string[0]  # no indent for 1st (
-    indent = ''
-    for i in range(1, len(in_string)):
-        if in_string[i] == '(' and in_string[i+1] != ' ':
-            indent += add_indent
-            out_string += "\n" + indent + '('
-        elif in_string[i] == ')':
-            out_string += ')'
-            if len(indent) > 0:
-                indent = indent.replace(add_indent, '', 1)
-        else:
-            out_string += in_string[i]
-    return out_string
-
-
-if __name__ == '__main__':
-
-    #############################################################
-    # parse options
-    # not support -gui -encoding -ps
-    #############################################################
-    usage = "Usage: %prog [options] Grammar_Name Start_Rule"
-    parser = optparse.OptionParser(usage=usage)
-    # parser.add_option('-t', '--tree',
-    #                   dest="out_file",
-    #                   default="default.out",
-    #                   help='set output file name',
-    #                   )
-    parser.add_option('-t', '--tree',
-                      default=False,
-                      action='store_true',
-                      help='Print AST tree'
-                      )
-    parser.add_option('-k', '--tokens',
-                      dest="token",
-                      default=False,
-                      action='store_true',
-                      help='Show Tokens'
-                      )
-    parser.add_option('-s', '--sll',
-                      dest="sll",
-                      default=False,
-                      action='store_true',
-                      help='Show SLL'
-                      )
-    parser.add_option('-d', '--diagnostics',
-                      dest="diagnostics",
-                      default=False,
-                      action='store_true',
-                      help='Enable diagnostics error listener'
-                      )
-    parser.add_option('-a', '--trace',
-                      dest="trace",
-                      default=False,
-                      action='store_true',
-                      help='Enable Trace'
-                      )
-
-    options, remainder = parser.parse_args()
-    if len(remainder) < 2:
-        print('ERROR: You have to provide at least 2 arguments!')
-        parser.print_help()
-        exit(1)
-    else:
-        grammar = remainder.pop(0)
-        start_rule = remainder.pop(0)
-        file_list = remainder
-
-    #############################################################
-    # check and load antlr generated files
-    #############################################################
-    # dynamic load the module and class
-    lexerName = grammar + 'Lexer'
-    parserName = grammar + 'Parser'
-    # check if the generate file exist
-    lexer_file = lexerName + '.py'
-    parser_file = parserName + '.py'
-    if not os.path.exists(lexer_file):
-        print("[ERROR] Can't find lexer file {}!".format(lexer_file))
-        print(os.path.realpath('.'))
-        exit(1)
-    if not os.path.exists(parser_file):
-        print("[ERROR] Can't find parser file {}!".format(lexer_file))
-        print(os.path.realpath('.'))
-        exit(1)
-
-    # current directory is where the generated file loaded
-    # the script might be in different place.
-    sys.path.append('.')
-    # print(sys.path)
-
-    # print("Load Lexer {}".format(lexerName))
-    module_lexer = __import__(lexerName, globals(), locals(), lexerName)
-    class_lexer = getattr(module_lexer, lexerName)
-    # print(class_lexer)
-
-    # print("Load Parser {}".format(parserName))
-    module_parser = __import__(parserName, globals(), locals(), parserName)
-    class_parser = getattr(module_parser, parserName)
-    # print(class_parser)
-
-    #############################################################
-    # main process steps.
-    #############################################################
-    def process(input_stream, class_lexer, class_parser):
-        lexer = class_lexer(input_stream)
-        token_stream = CommonTokenStream(lexer)
-        token_stream.fill()
-        if options.token:  # need to show token
-            for tok in token_stream.tokens:
-                print(tok)
-        if start_rule == 'tokens':
-            return
-
-        parser = class_parser(token_stream)
-
-        if options.diagnostics:
-            parser.addErrorListener(DiagnosticErrorListener())
-            parser._interp.predictionMode = PredictionMode.LL_EXACT_AMBIG_DETECTION
-        if options.tree:
-            parser.buildParseTrees = True
-        if options.sll:
-            parser._interp.predictionMode = PredictionMode.SLL
-        #parser.setTokenStream(token_stream)
-        parser.setTrace(options.trace)
-        if hasattr(parser, start_rule):
-            func_start_rule = getattr(parser, start_rule)
-            parser_ret = func_start_rule()
-            if options.tree:
-                lisp_tree_str = parser_ret.toStringTree(recog=parser)
-                print(beautify_lisp_string(lisp_tree_str))
-        else:
-            print("[ERROR] Can't find start rule '{}' in parser '{}'".format(start_rule, parserName))
-
-    #############################################################
-    # use stdin if not provide file as input stream
-    #############################################################
-    if len(file_list) == 0:
-        input_stream = InputStream(sys.stdin.read())
-        process(input_stream, class_lexer, class_parser)
-        exit(0)
-
-    #############################################################
-    # iterate all input file
-    #############################################################
-    for file_name in file_list:
-        if os.path.exists(file_name) and os.path.isfile(file_name):
-            input_stream = FileStream(file_name)
-            process(input_stream, class_lexer, class_parser)
-        else:
-            print("[ERROR] file {} not exist".format(os.path.normpath(file_name)))

.venv/bin/python

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:45c68b7ca1e3765a06756734c15af204ca9c0588a3f6d7a6d8bb8ed58e3e2a1a
-size 6724632

.venv/bin/python3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:45c68b7ca1e3765a06756734c15af204ca9c0588a3f6d7a6d8bb8ed58e3e2a1a
-size 6724632

.venv/bin/python3.11

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:45c68b7ca1e3765a06756734c15af204ca9c0588a3f6d7a6d8bb8ed58e3e2a1a
-size 6724632

.venv/bin/ruff

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:64aae5e444938e33121c3b940dff9b3d8ef8fc2a88c477e7f3a4fae2584a8fe8
-size 27832160

.venv/bin/tabulate

@@ -1,6 +0,0 @@
-#!/workspace/.venv/bin/python
-import sys
-from tabulate import _main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(_main())

.venv/bin/tqdm

@@ -1,6 +0,0 @@
-#!/workspace/.venv/bin/python
-import sys
-from tqdm.cli import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

.venv/etc/jupyter/nbconfig/notebook.d/widgetsnbextension.json

@@ -1,5 +0,0 @@
-{
-  "load_extensions": {
-    "jupyter-js-widgets/extension": true
-  }
-}

.venv/lib/python3.11/site-packages/PIL/AvifImagePlugin.py

@@ -1,291 +0,0 @@
-from __future__ import annotations
-
-import os
-from io import BytesIO
-from typing import IO
-
-from . import ExifTags, Image, ImageFile
-
-try:
-    from . import _avif
-
-    SUPPORTED = True
-except ImportError:
-    SUPPORTED = False
-
-# Decoder options as module globals, until there is a way to pass parameters
-# to Image.open (see https://github.com/python-pillow/Pillow/issues/569)
-DECODE_CODEC_CHOICE = "auto"
-DEFAULT_MAX_THREADS = 0
-
-
-def get_codec_version(codec_name: str) -> str | None:
-    versions = _avif.codec_versions()
-    for version in versions.split(", "):
-        if version.split(" [")[0] == codec_name:
-            return version.split(":")[-1].split(" ")[0]
-    return None
-
-
-def _accept(prefix: bytes) -> bool | str:
-    if prefix[4:8] != b"ftyp":
-        return False
-    major_brand = prefix[8:12]
-    if major_brand in (
-        # coding brands
-        b"avif",
-        b"avis",
-        # We accept files with AVIF container brands; we can't yet know if
-        # the ftyp box has the correct compatible brands, but if it doesn't
-        # then the plugin will raise a SyntaxError which Pillow will catch
-        # before moving on to the next plugin that accepts the file.
-        #
-        # Also, because this file might not actually be an AVIF file, we
-        # don't raise an error if AVIF support isn't properly compiled.
-        b"mif1",
-        b"msf1",
-    ):
-        if not SUPPORTED:
-            return (
-                "image file could not be identified because AVIF support not installed"
-            )
-        return True
-    return False
-
-
-def _get_default_max_threads() -> int:
-    if DEFAULT_MAX_THREADS:
-        return DEFAULT_MAX_THREADS
-    if hasattr(os, "sched_getaffinity"):
-        return len(os.sched_getaffinity(0))
-    else:
-        return os.cpu_count() or 1
-
-
-class AvifImageFile(ImageFile.ImageFile):
-    format = "AVIF"
-    format_description = "AVIF image"
-    __frame = -1
-
-    def _open(self) -> None:
-        if not SUPPORTED:
-            msg = "image file could not be opened because AVIF support not installed"
-            raise SyntaxError(msg)
-
-        if DECODE_CODEC_CHOICE != "auto" and not _avif.decoder_codec_available(
-            DECODE_CODEC_CHOICE
-        ):
-            msg = "Invalid opening codec"
-            raise ValueError(msg)
-        self._decoder = _avif.AvifDecoder(
-            self.fp.read(),
-            DECODE_CODEC_CHOICE,
-            _get_default_max_threads(),
-        )
-
-        # Get info from decoder
-        self._size, self.n_frames, self._mode, icc, exif, exif_orientation, xmp = (
-            self._decoder.get_info()
-        )
-        self.is_animated = self.n_frames > 1
-
-        if icc:
-            self.info["icc_profile"] = icc
-        if xmp:
-            self.info["xmp"] = xmp
-
-        if exif_orientation != 1 or exif:
-            exif_data = Image.Exif()
-            if exif:
-                exif_data.load(exif)
-                original_orientation = exif_data.get(ExifTags.Base.Orientation, 1)
-            else:
-                original_orientation = 1
-            if exif_orientation != original_orientation:
-                exif_data[ExifTags.Base.Orientation] = exif_orientation
-                exif = exif_data.tobytes()
-        if exif:
-            self.info["exif"] = exif
-        self.seek(0)
-
-    def seek(self, frame: int) -> None:
-        if not self._seek_check(frame):
-            return
-
-        # Set tile
-        self.__frame = frame
-        self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.mode)]
-
-    def load(self) -> Image.core.PixelAccess | None:
-        if self.tile:
-            # We need to load the image data for this frame
-            data, timescale, pts_in_timescales, duration_in_timescales = (
-                self._decoder.get_frame(self.__frame)
-            )
-            self.info["timestamp"] = round(1000 * (pts_in_timescales / timescale))
-            self.info["duration"] = round(1000 * (duration_in_timescales / timescale))
-
-            if self.fp and self._exclusive_fp:
-                self.fp.close()
-            self.fp = BytesIO(data)
-
-        return super().load()
-
-    def load_seek(self, pos: int) -> None:
-        pass
-
-    def tell(self) -> int:
-        return self.__frame
-
-
-def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    _save(im, fp, filename, save_all=True)
-
-
-def _save(
-    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
-) -> None:
-    info = im.encoderinfo.copy()
-    if save_all:
-        append_images = list(info.get("append_images", []))
-    else:
-        append_images = []
-
-    total = 0
-    for ims in [im] + append_images:
-        total += getattr(ims, "n_frames", 1)
-
-    quality = info.get("quality", 75)
-    if not isinstance(quality, int) or quality < 0 or quality > 100:
-        msg = "Invalid quality setting"
-        raise ValueError(msg)
-
-    duration = info.get("duration", 0)
-    subsampling = info.get("subsampling", "4:2:0")
-    speed = info.get("speed", 6)
-    max_threads = info.get("max_threads", _get_default_max_threads())
-    codec = info.get("codec", "auto")
-    if codec != "auto" and not _avif.encoder_codec_available(codec):
-        msg = "Invalid saving codec"
-        raise ValueError(msg)
-    range_ = info.get("range", "full")
-    tile_rows_log2 = info.get("tile_rows", 0)
-    tile_cols_log2 = info.get("tile_cols", 0)
-    alpha_premultiplied = bool(info.get("alpha_premultiplied", False))
-    autotiling = bool(info.get("autotiling", tile_rows_log2 == tile_cols_log2 == 0))
-
-    icc_profile = info.get("icc_profile", im.info.get("icc_profile"))
-    exif_orientation = 1
-    if exif := info.get("exif"):
-        if isinstance(exif, Image.Exif):
-            exif_data = exif
-        else:
-            exif_data = Image.Exif()
-            exif_data.load(exif)
-        if ExifTags.Base.Orientation in exif_data:
-            exif_orientation = exif_data.pop(ExifTags.Base.Orientation)
-            exif = exif_data.tobytes() if exif_data else b""
-        elif isinstance(exif, Image.Exif):
-            exif = exif_data.tobytes()
-
-    xmp = info.get("xmp")
-
-    if isinstance(xmp, str):
-        xmp = xmp.encode("utf-8")
-
-    advanced = info.get("advanced")
-    if advanced is not None:
-        if isinstance(advanced, dict):
-            advanced = advanced.items()
-        try:
-            advanced = tuple(advanced)
-        except TypeError:
-            invalid = True
-        else:
-            invalid = any(not isinstance(v, tuple) or len(v) != 2 for v in advanced)
-        if invalid:
-            msg = (
-                "advanced codec options must be a dict of key-value string "
-                "pairs or a series of key-value two-tuples"
-            )
-            raise ValueError(msg)
-
-    # Setup the AVIF encoder
-    enc = _avif.AvifEncoder(
-        im.size,
-        subsampling,
-        quality,
-        speed,
-        max_threads,
-        codec,
-        range_,
-        tile_rows_log2,
-        tile_cols_log2,
-        alpha_premultiplied,
-        autotiling,
-        icc_profile or b"",
-        exif or b"",
-        exif_orientation,
-        xmp or b"",
-        advanced,
-    )
-
-    # Add each frame
-    frame_idx = 0
-    frame_duration = 0
-    cur_idx = im.tell()
-    is_single_frame = total == 1
-    try:
-        for ims in [im] + append_images:
-            # Get number of frames in this image
-            nfr = getattr(ims, "n_frames", 1)
-
-            for idx in range(nfr):
-                ims.seek(idx)
-
-                # Make sure image mode is supported
-                frame = ims
-                rawmode = ims.mode
-                if ims.mode not in {"RGB", "RGBA"}:
-                    rawmode = "RGBA" if ims.has_transparency_data else "RGB"
-                    frame = ims.convert(rawmode)
-
-                # Update frame duration
-                if isinstance(duration, (list, tuple)):
-                    frame_duration = duration[frame_idx]
-                else:
-                    frame_duration = duration
-
-                # Append the frame to the animation encoder
-                enc.add(
-                    frame.tobytes("raw", rawmode),
-                    frame_duration,
-                    frame.size,
-                    rawmode,
-                    is_single_frame,
-                )
-
-                # Update frame index
-                frame_idx += 1
-
-                if not save_all:
-                    break
-
-    finally:
-        im.seek(cur_idx)
-
-    # Get the final output from the encoder
-    data = enc.finish()
-    if data is None:
-        msg = "cannot write file as AVIF (encoder returned None)"
-        raise OSError(msg)
-
-    fp.write(data)
-
-
-Image.register_open(AvifImageFile.format, AvifImageFile, _accept)
-if SUPPORTED:
-    Image.register_save(AvifImageFile.format, _save)
-    Image.register_save_all(AvifImageFile.format, _save_all)
-    Image.register_extensions(AvifImageFile.format, [".avif", ".avifs"])
-    Image.register_mime(AvifImageFile.format, "image/avif")

.venv/lib/python3.11/site-packages/PIL/BdfFontFile.py

@@ -1,122 +0,0 @@
-#
-# 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
-
-
-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.startswith(b"STARTCHAR"):
-            break
-    id = s[9:].strip().decode("ascii")
-
-    # load symbol properties
-    props = {}
-    while True:
-        s = f.readline()
-        if not s or s.startswith(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.startswith(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) -> None:
-        super().__init__()
-
-        s = fp.readline()
-        if not s.startswith(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.startswith(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/python3.11/site-packages/PIL/BlpImagePlugin.py

@@ -1,497 +0,0 @@
-"""
-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 abc
-import os
-import struct
-from enum import IntEnum
-from io import BytesIO
-from typing import IO
-
-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: int) -> tuple[int, int, int]:
-    return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
-
-
-def decode_dxt1(
-    data: bytes, alpha: bool = False
-) -> tuple[bytearray, bytearray, bytearray, bytearray]:
-    """
-    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_index in range(blocks):
-        # Decode next 8-byte block.
-        idx = block_index * 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: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
-    """
-    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_index in range(blocks):
-        idx = block_index * 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: bytes) -> tuple[bytearray, bytearray, bytearray, bytearray]:
-    """
-    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_index in range(blocks):
-        idx = block_index * 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: bytes) -> bool:
-    return prefix.startswith((b"BLP1", b"BLP2"))
-
-
-class BlpImageFile(ImageFile.ImageFile):
-    """
-    Blizzard Mipmap Format
-    """
-
-    format = "BLP"
-    format_description = "Blizzard Mipmap Format"
-
-    def _open(self) -> None:
-        self.magic = self.fp.read(4)
-        if not _accept(self.magic):
-            msg = f"Bad BLP magic {repr(self.magic)}"
-            raise BLPFormatError(msg)
-
-        compression = struct.unpack("<i", self.fp.read(4))[0]
-        if self.magic == b"BLP1":
-            alpha = struct.unpack("<I", self.fp.read(4))[0] != 0
-        else:
-            encoding = struct.unpack("<b", self.fp.read(1))[0]
-            alpha = struct.unpack("<b", self.fp.read(1))[0] != 0
-            alpha_encoding = struct.unpack("<b", self.fp.read(1))[0]
-            self.fp.seek(1, os.SEEK_CUR)  # mips
-
-        self._size = struct.unpack("<II", self.fp.read(8))
-
-        args: tuple[int, int, bool] | tuple[int, int, bool, int]
-        if self.magic == b"BLP1":
-            encoding = struct.unpack("<i", self.fp.read(4))[0]
-            self.fp.seek(4, os.SEEK_CUR)  # subtype
-
-            args = (compression, encoding, alpha)
-            offset = 28
-        else:
-            args = (compression, encoding, alpha, alpha_encoding)
-            offset = 20
-
-        decoder = self.magic.decode()
-
-        self._mode = "RGBA" if alpha else "RGB"
-        self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, offset, args)]
-
-
-class _BLPBaseDecoder(abc.ABC, ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        try:
-            self._read_header()
-            self._load()
-        except struct.error as e:
-            msg = "Truncated BLP file"
-            raise OSError(msg) from e
-        return -1, 0
-
-    @abc.abstractmethod
-    def _load(self) -> None:
-        pass
-
-    def _read_header(self) -> None:
-        self._offsets = struct.unpack("<16I", self._safe_read(16 * 4))
-        self._lengths = struct.unpack("<16I", self._safe_read(16 * 4))
-
-    def _safe_read(self, length: int) -> bytes:
-        assert self.fd is not None
-        return ImageFile._safe_read(self.fd, length)
-
-    def _read_palette(self) -> list[tuple[int, int, int, int]]:
-        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: list[tuple[int, int, int, int]], alpha: bool
-    ) -> bytearray:
-        data = bytearray()
-        _data = BytesIO(self._safe_read(self._lengths[0]))
-        while True:
-            try:
-                (offset,) = struct.unpack("<B", _data.read(1))
-            except struct.error:
-                break
-            b, g, r, a = palette[offset]
-            d: tuple[int, ...] = (r, g, b)
-            if alpha:
-                d += (a,)
-            data.extend(d)
-        return data
-
-
-class BLP1Decoder(_BLPBaseDecoder):
-    def _load(self) -> None:
-        self._compression, self._encoding, alpha = self.args
-
-        if self._compression == Format.JPEG:
-            self._decode_jpeg_stream()
-
-        elif self._compression == 1:
-            if self._encoding in (4, 5):
-                palette = self._read_palette()
-                data = self._read_bgra(palette, alpha)
-                self.set_as_raw(data)
-            else:
-                msg = f"Unsupported BLP encoding {repr(self._encoding)}"
-                raise BLPFormatError(msg)
-        else:
-            msg = f"Unsupported BLP compression {repr(self._encoding)}"
-            raise BLPFormatError(msg)
-
-    def _decode_jpeg_stream(self) -> None:
-        from .JpegImagePlugin import JpegImageFile
-
-        (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
-        jpeg_header = self._safe_read(jpeg_header_size)
-        assert self.fd is not None
-        self._safe_read(self._offsets[0] - self.fd.tell())  # What IS this?
-        data = self._safe_read(self._lengths[0])
-        data = jpeg_header + data
-        image = JpegImageFile(BytesIO(data))
-        Image._decompression_bomb_check(image.size)
-        if image.mode == "CMYK":
-            args = image.tile[0].args
-            assert isinstance(args, tuple)
-            image.tile = [image.tile[0]._replace(args=(args[0], "CMYK"))]
-        self.set_as_raw(image.convert("RGB").tobytes(), "BGR")
-
-
-class BLP2Decoder(_BLPBaseDecoder):
-    def _load(self) -> None:
-        self._compression, self._encoding, alpha, self._alpha_encoding = self.args
-
-        palette = self._read_palette()
-
-        assert self.fd is not None
-        self.fd.seek(self._offsets[0])
-
-        if self._compression == 1:
-            # Uncompressed or DirectX compression
-
-            if self._encoding == Encoding.UNCOMPRESSED:
-                data = self._read_bgra(palette, alpha)
-
-            elif self._encoding == Encoding.DXT:
-                data = bytearray()
-                if self._alpha_encoding == AlphaEncoding.DXT1:
-                    linesize = (self.state.xsize + 3) // 4 * 8
-                    for yb in range((self.state.ysize + 3) // 4):
-                        for d in decode_dxt1(self._safe_read(linesize), alpha):
-                            data += d
-
-                elif self._alpha_encoding == AlphaEncoding.DXT3:
-                    linesize = (self.state.xsize + 3) // 4 * 16
-                    for yb in range((self.state.ysize + 3) // 4):
-                        for d in decode_dxt3(self._safe_read(linesize)):
-                            data += d
-
-                elif self._alpha_encoding == AlphaEncoding.DXT5:
-                    linesize = (self.state.xsize + 3) // 4 * 16
-                    for yb in range((self.state.ysize + 3) // 4):
-                        for d in decode_dxt5(self._safe_read(linesize)):
-                            data += d
-                else:
-                    msg = f"Unsupported alpha encoding {repr(self._alpha_encoding)}"
-                    raise BLPFormatError(msg)
-            else:
-                msg = f"Unknown BLP encoding {repr(self._encoding)}"
-                raise BLPFormatError(msg)
-
-        else:
-            msg = f"Unknown BLP compression {repr(self._compression)}"
-            raise BLPFormatError(msg)
-
-        self.set_as_raw(data)
-
-
-class BLPEncoder(ImageFile.PyEncoder):
-    _pushes_fd = True
-
-    def _write_palette(self) -> bytes:
-        data = b""
-        assert self.im is not None
-        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: int) -> tuple[int, int, bytes]:
-        palette_data = self._write_palette()
-
-        offset = 20 + 16 * 4 * 2 + len(palette_data)
-        data = struct.pack("<16I", offset, *((0,) * 15))
-
-        assert self.im is not None
-        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: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    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)
-
-    assert im.palette is not None
-    fp.write(struct.pack("<i", 1))  # Uncompressed or DirectX compression
-
-    alpha_depth = 1 if im.palette.mode == "RGBA" else 0
-    if magic == b"BLP1":
-        fp.write(struct.pack("<L", alpha_depth))
-    else:
-        fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
-        fp.write(struct.pack("<b", alpha_depth))
-        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, [ImageFile._Tile("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/python3.11/site-packages/PIL/BmpImagePlugin.py

@@ -1,515 +0,0 @@
-#
-# 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 typing import IO, Any
-
-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"),
-}
-
-USE_RAW_ALPHA = False
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(b"BM")
-
-
-def _dib_accept(prefix: bytes) -> bool:
-    return i32(prefix) in [12, 40, 52, 56, 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: int = 0, offset: int = 0) -> None:
-        """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: dict[str, bool | int | tuple[int, ...]] = {
-            "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
-        assert isinstance(file_info["header_size"], int)
-        header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
-
-        # ------------------------------- Windows Bitmap v2, IBM OS/2 Bitmap v1
-        # ----- This format has different offsets because of width/height types
-        # 12: BITMAPCOREHEADER/OS21XBITMAPHEADER
-        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.COMPRESSIONS["RAW"]
-            file_info["palette_padding"] = 3
-
-        # --------------------------------------------- Windows Bitmap v3 to v5
-        #  40: BITMAPINFOHEADER
-        #  52: BITMAPV2HEADER
-        #  56: BITMAPV3HEADER
-        #  64: BITMAPCOREHEADER2/OS22XBITMAPHEADER
-        # 108: BITMAPV4HEADER
-        # 124: BITMAPV5HEADER
-        elif file_info["header_size"] in (40, 52, 56, 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
-            assert isinstance(file_info["pixels_per_meter"], tuple)
-            self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
-            if file_info["compression"] == self.COMPRESSIONS["BITFIELDS"]:
-                masks = ["r_mask", "g_mask", "b_mask"]
-                if len(header_data) >= 48:
-                    if len(header_data) >= 52:
-                        masks.append("a_mask")
-                    else:
-                        file_info["a_mask"] = 0x0
-                    for idx, mask in enumerate(masks):
-                        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 masks:
-                        file_info[mask] = i32(read(4))
-                assert isinstance(file_info["r_mask"], int)
-                assert isinstance(file_info["g_mask"], int)
-                assert isinstance(file_info["b_mask"], int)
-                assert isinstance(file_info["a_mask"], int)
-                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
-        assert isinstance(file_info["width"], int)
-        assert isinstance(file_info["height"], int)
-        self._size = file_info["width"], file_info["height"]
-
-        # ------- If color count was not found in the header, compute from bits
-        assert isinstance(file_info["bits"], int)
-        file_info["colors"] = (
-            file_info["colors"]
-            if file_info.get("colors", 0)
-            else (1 << file_info["bits"])
-        )
-        assert isinstance(file_info["colors"], int)
-        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"], ("", ""))
-        if not self.mode:
-            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.COMPRESSIONS["BITFIELDS"]:
-            SUPPORTED: dict[int, list[tuple[int, ...]]] = {
-                32: [
-                    (0xFF0000, 0xFF00, 0xFF, 0x0),
-                    (0xFF000000, 0xFF0000, 0xFF00, 0x0),
-                    (0xFF000000, 0xFF00, 0xFF, 0x0),
-                    (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
-                    (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
-                    (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
-                    (0xFF000000, 0xFF00, 0xFF, 0xFF0000),
-                    (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, 0xFF00, 0xFF, 0x0)): "BGXR",
-                (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
-                (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
-                (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
-                (32, (0xFF000000, 0xFF00, 0xFF, 0xFF0000)): "BGAR",
-                (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"]]
-                ):
-                    assert isinstance(file_info["rgba_mask"], tuple)
-                    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"]]
-                ):
-                    assert isinstance(file_info["rgb_mask"], tuple)
-                    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.COMPRESSIONS["RAW"]:
-            if file_info["bits"] == 32 and (
-                header == 22 or USE_RAW_ALPHA  # 32-bit .cur offset
-            ):
-                raw_mode, self._mode = "BGRA", "RGBA"
-        elif file_info["compression"] in (
-            self.COMPRESSIONS["RLE8"],
-            self.COMPRESSIONS["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:
-                assert isinstance(file_info["palette_padding"], int)
-                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: list[Any] = [raw_mode]
-        if decoder_name == "bmp_rle":
-            args.append(file_info["compression"] == self.COMPRESSIONS["RLE4"])
-        else:
-            assert isinstance(file_info["width"], int)
-            args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
-        args.append(file_info["direction"])
-        self.tile = [
-            ImageFile._Tile(
-                decoder_name,
-                (0, 0, file_info["width"], file_info["height"]),
-                offset or self.fp.tell(),
-                tuple(args),
-            )
-        ]
-
-    def _open(self) -> None:
-        """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: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        assert self.fd is not None
-        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) -> None:
-        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: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    _save(im, fp, filename, False)
-
-
-def _save(
-    im: Image.Image, fp: IO[bytes], filename: str | bytes, bitmap_header: bool = True
-) -> None:
-    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) * 3 + b"\x00" for i in (0, 255))
-    elif im.mode == "L":
-        palette = b"".join(o8(i) * 3 + b"\x00" 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, [ImageFile._Tile("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/python3.11/site-packages/PIL/BufrStubImagePlugin.py

@@ -1,75 +0,0 @@
-#
-# 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
-
-import os
-from typing import IO
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler: ImageFile.StubHandler | None) -> None:
-    """
-    Install application-specific BUFR image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith((b"BUFR", b"ZCZC"))
-
-
-class BufrStubImageFile(ImageFile.StubImageFile):
-    format = "BUFR"
-    format_description = "BUFR"
-
-    def _open(self) -> None:
-        if not _accept(self.fp.read(4)):
-            msg = "Not a BUFR file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(-4, os.SEEK_CUR)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> ImageFile.StubHandler | None:
-        return _handler
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    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/python3.11/site-packages/PIL/ContainerIO.py

@@ -1,173 +0,0 @@
-#
-# 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 collections.abc import Iterable
-from typing import IO, AnyStr, NoReturn
-
-
-class ContainerIO(IO[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 seekable(self) -> bool:
-        return True
-
-    def seek(self, offset: int, mode: int = io.SEEK_SET) -> int:
-        """
-        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.
-        :returns: Offset from start of region, in bytes.
-        """
-        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)
-        return self.pos
-
-    def tell(self) -> int:
-        """
-        Get current file pointer.
-
-        :returns: Offset from start of region, in bytes.
-        """
-        return self.pos
-
-    def readable(self) -> bool:
-        return True
-
-    def read(self, n: int = -1) -> AnyStr:
-        """
-        Read data.
-
-        :param n: Number of bytes to read. If omitted, zero or negative,
-            read until end of region.
-        :returns: An 8-bit string.
-        """
-        if n > 0:
-            n = min(n, self.length - self.pos)
-        else:
-            n = self.length - self.pos
-        if n <= 0:  # 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, n: int = -1) -> AnyStr:
-        """
-        Read a line of text.
-
-        :param n: Number of bytes to read. If omitted, zero or negative,
-            read until end of line.
-        :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 or len(s) == n:
-                break
-        return s
-
-    def readlines(self, n: int | None = -1) -> list[AnyStr]:
-        """
-        Read multiple lines of text.
-
-        :param n: Number of lines to read. If omitted, zero, negative or None,
-            read until end of region.
-        :returns: A list of 8-bit strings.
-        """
-        lines = []
-        while True:
-            s = self.readline()
-            if not s:
-                break
-            lines.append(s)
-            if len(lines) == n:
-                break
-        return lines
-
-    def writable(self) -> bool:
-        return False
-
-    def write(self, b: AnyStr) -> NoReturn:
-        raise NotImplementedError()
-
-    def writelines(self, lines: Iterable[AnyStr]) -> NoReturn:
-        raise NotImplementedError()
-
-    def truncate(self, size: int | None = None) -> int:
-        raise NotImplementedError()
-
-    def __enter__(self) -> ContainerIO[AnyStr]:
-        return self
-
-    def __exit__(self, *args: object) -> None:
-        self.close()
-
-    def __iter__(self) -> ContainerIO[AnyStr]:
-        return self
-
-    def __next__(self) -> AnyStr:
-        line = self.readline()
-        if not line:
-            msg = "end of region"
-            raise StopIteration(msg)
-        return line
-
-    def fileno(self) -> int:
-        return self.fh.fileno()
-
-    def flush(self) -> None:
-        self.fh.flush()
-
-    def close(self) -> None:
-        self.fh.close()

.venv/lib/python3.11/site-packages/PIL/CurImagePlugin.py

@@ -1,75 +0,0 @@
-#
-# 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, ImageFile
-from ._binary import i16le as i16
-from ._binary import i32le as i32
-
-#
-# --------------------------------------------------------------------
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(b"\0\0\2\0")
-
-
-##
-# Image plugin for Windows Cursor files.
-
-
-class CurImageFile(BmpImagePlugin.BmpImageFile):
-    format = "CUR"
-    format_description = "Windows Cursor"
-
-    def _open(self) -> None:
-        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] = ImageFile._Tile(d, (0, 0) + self.size, o, a)
-
-
-#
-# --------------------------------------------------------------------
-
-Image.register_open(CurImageFile.format, CurImageFile, _accept)
-
-Image.register_extension(CurImageFile.format, ".cur")

.venv/lib/python3.11/site-packages/PIL/DcxImagePlugin.py

@@ -1,83 +0,0 @@
-#
-# 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 ._util import DeferredError
-from .PcxImagePlugin import PcxImageFile
-
-MAGIC = 0x3ADE68B1  # QUIZ: what's this value, then?
-
-
-def _accept(prefix: bytes) -> bool:
-    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) -> None:
-        # 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 = -1
-        self.n_frames = len(self._offset)
-        self.is_animated = self.n_frames > 1
-        self.seek(0)
-
-    def seek(self, frame: int) -> None:
-        if not self._seek_check(frame):
-            return
-        if isinstance(self._fp, DeferredError):
-            raise self._fp.ex
-        self.frame = frame
-        self.fp = self._fp
-        self.fp.seek(self._offset[frame])
-        PcxImageFile._open(self)
-
-    def tell(self) -> int:
-        return self.frame
-
-
-Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
-
-Image.register_extension(DcxImageFile.format, ".dcx")

.venv/lib/python3.11/site-packages/PIL/DdsImagePlugin.py

@@ -1,624 +0,0 @@
-"""
-A Pillow plugin 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 typing import IO
-
-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, f"DDSD_{item.name}", item.value)
-for item1 in DDSCAPS:
-    assert item1.name is not None
-    setattr(module, f"DDSCAPS_{item1.name}", item1.value)
-for item2 in DDSCAPS2:
-    assert item2.name is not None
-    setattr(module, f"DDSCAPS2_{item2.name}", item2.value)
-for item3 in DDPF:
-    assert item3.name is not None
-    setattr(module, f"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) -> None:
-        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 = [ImageFile._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))
-            self.palette.mode = "RGBA"
-        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.BC2_TYPELESS, DXGI_FORMAT.BC2_UNORM):
-                    self._mode = "RGBA"
-                    self.pixel_format = "BC2"
-                    n = 2
-                elif dxgi_format in (DXGI_FORMAT.BC3_TYPELESS, DXGI_FORMAT.BC3_UNORM):
-                    self._mode = "RGBA"
-                    self.pixel_format = "BC3"
-                    n = 3
-                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: int) -> None:
-        pass
-
-
-class DdsRgbDecoder(ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        assert self.fd is not None
-        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: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    if im.mode not in ("RGB", "RGBA", "L", "LA"):
-        msg = f"cannot write mode {im.mode} as DDS"
-        raise OSError(msg)
-
-    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PIXELFORMAT
-    bitcount = len(im.getbands()) * 8
-    pixel_format = im.encoderinfo.get("pixel_format")
-    args: tuple[int] | str
-    if pixel_format:
-        codec_name = "bcn"
-        flags |= DDSD.LINEARSIZE
-        pitch = (im.width + 3) * 4
-        rgba_mask = [0, 0, 0, 0]
-        pixel_flags = DDPF.FOURCC
-        if pixel_format == "DXT1":
-            fourcc = D3DFMT.DXT1
-            args = (1,)
-        elif pixel_format == "DXT3":
-            fourcc = D3DFMT.DXT3
-            args = (2,)
-        elif pixel_format == "DXT5":
-            fourcc = D3DFMT.DXT5
-            args = (3,)
-        else:
-            fourcc = D3DFMT.DX10
-            if pixel_format == "BC2":
-                args = (2,)
-                dxgi_format = DXGI_FORMAT.BC2_TYPELESS
-            elif pixel_format == "BC3":
-                args = (3,)
-                dxgi_format = DXGI_FORMAT.BC3_TYPELESS
-            elif pixel_format == "BC5":
-                args = (5,)
-                dxgi_format = DXGI_FORMAT.BC5_TYPELESS
-                if im.mode != "RGB":
-                    msg = "only RGB mode can be written as BC5"
-                    raise OSError(msg)
-            else:
-                msg = f"cannot write pixel format {pixel_format}"
-                raise OSError(msg)
-    else:
-        codec_name = "raw"
-        flags |= DDSD.PITCH
-        pitch = (im.width * bitcount + 7) // 8
-
-        alpha = im.mode[-1] == "A"
-        if im.mode[0] == "L":
-            pixel_flags = DDPF.LUMINANCE
-            args = im.mode
-            if alpha:
-                rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
-            else:
-                rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
-        else:
-            pixel_flags = DDPF.RGB
-            args = 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)
-
-        fourcc = D3DFMT.UNKNOWN
-    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, fourcc, bitcount)
-        + struct.pack("<4I", *rgba_mask)  # dwRGBABitMask
-        + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)
-    )
-    if fourcc == D3DFMT.DX10:
-        fp.write(
-            # dxgi_format, 2D resource, misc, array size, straight alpha
-            struct.pack("<5I", dxgi_format, 3, 0, 0, 1)
-        )
-    ImageFile._save(im, fp, [ImageFile._Tile(codec_name, (0, 0) + im.size, 0, args)])
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(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/python3.11/site-packages/PIL/EpsImagePlugin.py

@@ -1,476 +0,0 @@
-#
-# 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 typing import IO
-
-from . import Image, ImageFile
-from ._binary import i32le as i32
-
-# --------------------------------------------------------------------
-
-
-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() -> bool:
-    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: list[ImageFile._Tile],
-    size: tuple[int, int],
-    fp: IO[bytes],
-    scale: int = 1,
-    transparency: bool = False,
-) -> Image.core.ImagingCore:
-    """Render an image using Ghostscript"""
-    global gs_binary
-    if not has_ghostscript():
-        msg = "Unable to locate Ghostscript on paths"
-        raise OSError(msg)
-    assert isinstance(gs_binary, str)
-
-    # Unpack decoder tile
-    args = tile[0].args
-    assert isinstance(args, tuple)
-    length, bbox = args
-
-    # 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)
-
-    if transparency:
-        # "RGBA"
-        device = "pngalpha"
-    else:
-        # "pnmraw" automatically chooses between
-        # PBM ("1"), PGM ("L"), and PPM ("RGB").
-        device = "pnmraw"
-
-    # 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)
-        with Image.open(outfile) as out_im:
-            out_im.load()
-            return out_im.im.copy()
-    finally:
-        try:
-            os.unlink(outfile)
-            if infile_temp:
-                os.unlink(infile_temp)
-        except OSError:
-            pass
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(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) -> None:
-        (length, offset) = self._find_offset(self.fp)
-
-        # go to offset - start of "%!PS"
-        self.fp.seek(offset)
-
-        self._mode = "RGB"
-
-        # When reading header comments, the first comment is used.
-        # When reading trailer comments, the last comment is used.
-        bounding_box: list[int] | None = None
-        imagedata_size: tuple[int, int] | None = 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() -> None:
-            """
-            The EPS specification requires that some headers exist.
-            This should be checked when the header comments formally end,
-            when image data starts, or when the file ends, whichever comes first.
-            """
-            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: str) -> bool:
-            nonlocal bounding_box, reading_trailer_comments
-            try:
-                m = split.match(s)
-            except re.error as e:
-                msg = "not an EPS file"
-                raise SyntaxError(msg) from e
-
-            if not m:
-                return False
-
-            k, v = m.group(1, 2)
-            self.info[k] = v
-            if k == "BoundingBox":
-                if v == "(atend)":
-                    reading_trailer_comments = True
-                elif not bounding_box 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.
-                        bounding_box = [int(float(i)) for i in v.split()]
-                    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:
-                    if reading_header_comments:
-                        check_required_header_comments()
-                    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.startswith("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
-
-                # If we've already read an "ImageData" descriptor,
-                # don't read another one.
-                if imagedata_size:
-                    bytes_read = 0
-                    continue
-
-                # 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
-
-                # Parse the columns and rows after checking the bit depth and mode
-                # in case the bit depth and/or mode are invalid.
-                imagedata_size = columns, rows
-            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
-
-        # A "BoundingBox" is always required,
-        # even if an "ImageData" descriptor size exists.
-        if not bounding_box:
-            msg = "cannot determine EPS bounding box"
-            raise OSError(msg)
-
-        # An "ImageData" size takes precedence over the "BoundingBox".
-        self._size = imagedata_size or (
-            bounding_box[2] - bounding_box[0],
-            bounding_box[3] - bounding_box[1],
-        )
-
-        self.tile = [
-            ImageFile._Tile("eps", (0, 0) + self.size, offset, (length, bounding_box))
-        ]
-
-    def _find_offset(self, fp: IO[bytes]) -> tuple[int, int]:
-        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: int = 1, transparency: bool = False
-    ) -> Image.core.PixelAccess | None:
-        # 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: int) -> None:
-        # we can't incrementally load, so force ImageFile.parser to
-        # use our custom load method by defining this method.
-        pass
-
-
-# --------------------------------------------------------------------
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes, eps: int = 1) -> None:
-    """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, [ImageFile._Tile("eps", (0, 0) + im.size)])
-
-    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/python3.11/site-packages/PIL/ExifTags.py

@@ -1,382 +0,0 @@
-#
-# 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 = 0x00
-    GPSLatitudeRef = 0x01
-    GPSLatitude = 0x02
-    GPSLongitudeRef = 0x03
-    GPSLongitude = 0x04
-    GPSAltitudeRef = 0x05
-    GPSAltitude = 0x06
-    GPSTimeStamp = 0x07
-    GPSSatellites = 0x08
-    GPSStatus = 0x09
-    GPSMeasureMode = 0x0A
-    GPSDOP = 0x0B
-    GPSSpeedRef = 0x0C
-    GPSSpeed = 0x0D
-    GPSTrackRef = 0x0E
-    GPSTrack = 0x0F
-    GPSImgDirectionRef = 0x10
-    GPSImgDirection = 0x11
-    GPSMapDatum = 0x12
-    GPSDestLatitudeRef = 0x13
-    GPSDestLatitude = 0x14
-    GPSDestLongitudeRef = 0x15
-    GPSDestLongitude = 0x16
-    GPSDestBearingRef = 0x17
-    GPSDestBearing = 0x18
-    GPSDestDistanceRef = 0x19
-    GPSDestDistance = 0x1A
-    GPSProcessingMethod = 0x1B
-    GPSAreaInformation = 0x1C
-    GPSDateStamp = 0x1D
-    GPSDifferential = 0x1E
-    GPSHPositioningError = 0x1F
-
-
-"""Maps EXIF GPS tags to tag names."""
-GPSTAGS = {i.value: i.name for i in GPS}
-
-
-class Interop(IntEnum):
-    InteropIndex = 0x0001
-    InteropVersion = 0x0002
-    RelatedImageFileFormat = 0x1000
-    RelatedImageWidth = 0x1001
-    RelatedImageHeight = 0x1002
-
-
-class IFD(IntEnum):
-    Exif = 0x8769
-    GPSInfo = 0x8825
-    MakerNote = 0x927C
-    Makernote = 0x927C  # Deprecated
-    Interop = 0xA005
-    IFD1 = -1
-
-
-class LightSource(IntEnum):
-    Unknown = 0x00
-    Daylight = 0x01
-    Fluorescent = 0x02
-    Tungsten = 0x03
-    Flash = 0x04
-    Fine = 0x09
-    Cloudy = 0x0A
-    Shade = 0x0B
-    DaylightFluorescent = 0x0C
-    DayWhiteFluorescent = 0x0D
-    CoolWhiteFluorescent = 0x0E
-    WhiteFluorescent = 0x0F
-    StandardLightA = 0x11
-    StandardLightB = 0x12
-    StandardLightC = 0x13
-    D55 = 0x14
-    D65 = 0x15
-    D75 = 0x16
-    D50 = 0x17
-    ISO = 0x18
-    Other = 0xFF

.venv/lib/python3.11/site-packages/PIL/FitsImagePlugin.py

@@ -1,152 +0,0 @@
-#
-# 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.startswith(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 = [ImageFile._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: tuple[str | int, ...]
-        if decoder_name == "raw":
-            args = (self.mode, 0, -1)
-        else:
-            args = (number_of_bits,)
-        return decoder_name, offset, args
-
-
-class FitsGzipDecoder(ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        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/python3.11/site-packages/PIL/FliImagePlugin.py

@@ -1,178 +0,0 @@
-#
-# 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
-from ._util import DeferredError
-
-#
-# decoder
-
-
-def _accept(prefix: bytes) -> bool:
-    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) -> None:
-        # 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: int | None = 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
-
-        self.palette = ImagePalette.raw(
-            "RGB", b"".join(o8(r) + o8(g) + o8(b) for (r, g, b) in 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: list[tuple[int, int, int]], shift: int) -> None:
-        # 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: int) -> None:
-        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: int) -> None:
-        if isinstance(self._fp, DeferredError):
-            raise self._fp.ex
-        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 = [ImageFile._Tile("fli", (0, 0) + self.size, self.__offset)]
-
-        self.__offset += framesize
-
-    def tell(self) -> int:
-        return self.__frame
-
-
-#
-# registry
-
-Image.register_open(FliImageFile.format, FliImageFile, _accept)
-
-Image.register_extensions(FliImageFile.format, [".fli", ".flc"])

.venv/lib/python3.11/site-packages/PIL/FontFile.py

@@ -1,134 +0,0 @@
-#
-# 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/python3.11/site-packages/PIL/FpxImagePlugin.py

@@ -1,257 +0,0 @@
-#
-# 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: bytes) -> bool:
-    return prefix.startswith(olefile.MAGIC)
-
-
-##
-# Image plugin for the FlashPix images.
-
-
-class FpxImageFile(ImageFile.ImageFile):
-    format = "FPX"
-    format_description = "FlashPix"
-
-    def _open(self) -> None:
-        #
-        # 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
-
-        root = self.ole.root
-        if not root or 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: int = 1) -> None:
-        #
-        # get the Image Contents Property Set
-
-        prop = self.ole.getproperties(
-            [f"Data Object Store {index:06d}", "\005Image Contents"]
-        )
-
-        # size (highest resolution)
-
-        assert isinstance(prop[0x1000002], int)
-        assert isinstance(prop[0x1000003], int)
-        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]
-
-        if not isinstance(s, bytes) or (bands := i32(s, 4)) > 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: int = 1, subimage: int = 0) -> None:
-        #
-        # 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(
-                    ImageFile._Tile(
-                        "raw",
-                        (x, y, x1, y1),
-                        i32(s, i) + 28,
-                        self.rawmode,
-                    )
-                )
-
-            elif compression == 1:
-                # FIXME: the fill decoder is not implemented
-                self.tile.append(
-                    ImageFile._Tile(
-                        "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(
-                    ImageFile._Tile(
-                        "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) -> Image.core.PixelAccess | None:
-        if not self.fp:
-            self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
-
-        return ImageFile.ImageFile.load(self)
-
-    def close(self) -> None:
-        self.ole.close()
-        super().close()
-
-    def __exit__(self, *args: object) -> None:
-        self.ole.close()
-        super().__exit__()
-
-
-#
-# --------------------------------------------------------------------
-
-
-Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
-
-Image.register_extension(FpxImageFile.format, ".fpx")

.venv/lib/python3.11/site-packages/PIL/FtexImagePlugin.py

@@ -1,114 +0,0 @@
-"""
-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) -> None:
-        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))
-
-        # 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 = [ImageFile._Tile("bcn", (0, 0) + self.size, 0, (1,))]
-        elif format == Format.UNCOMPRESSED:
-            self._mode = "RGB"
-            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, "RGB")]
-        else:
-            msg = f"Invalid texture compression format: {repr(format)}"
-            raise ValueError(msg)
-
-        self.fp.close()
-        self.fp = BytesIO(data)
-
-    def load_seek(self, pos: int) -> None:
-        pass
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(MAGIC)
-
-
-Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
-Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])

.venv/lib/python3.11/site-packages/PIL/GbrImagePlugin.py

@@ -1,103 +0,0 @@
-#
-# 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: bytes) -> bool:
-    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) -> None:
-        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) -> Image.core.PixelAccess | None:
-        if self._im is None:
-            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/python3.11/site-packages/PIL/GdImageFile.py

@@ -1,102 +0,0 @@
-#
-# 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 = "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(
-            "RGBX", s[7 + true_color_offset + 6 : 7 + true_color_offset + 6 + 256 * 4]
-        )
-
-        self.tile = [
-            ImageFile._Tile(
-                "raw",
-                (0, 0) + self.size,
-                7 + true_color_offset + 6 + 256 * 4,
-                "L",
-            )
-        ]
-
-
-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/python3.11/site-packages/PIL/GifImagePlugin.py

@@ -1,1213 +0,0 @@
-#
-# 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 functools import cached_property
-from typing import IO, Any, Literal, NamedTuple, Union, cast
-
-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
-from ._util import DeferredError
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from . import _imaging
-    from ._typing import Buffer
-
-
-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: bytes) -> bool:
-    return prefix.startswith((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) -> bytes | None:
-        s = self.fp.read(1)
-        if s and s[0]:
-            return self.fp.read(s[0])
-        return None
-
-    def _is_palette_needed(self, p: bytes) -> bool:
-        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) -> None:
-        # 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)
-        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: int | None = None
-        self._seek(0)  # get ready to read first frame
-
-    @property
-    def n_frames(self) -> int:
-        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
-
-    @cached_property
-    def is_animated(self) -> bool:
-        if self._n_frames is not None:
-            return self._n_frames != 1
-
-        current = self.tell()
-        if current:
-            return True
-
-        try:
-            self._seek(1, False)
-            is_animated = True
-        except EOFError:
-            is_animated = False
-
-        self.seek(current)
-        return is_animated
-
-    def seek(self, frame: int) -> None:
-        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: int, update_image: bool = True) -> None:
-        if isinstance(self._fp, DeferredError):
-            raise self._fp.ex
-        if frame == 0:
-            # rewind
-            self.__offset = 0
-            self.dispose: _imaging.ImagingCore | None = 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: ImagePalette.ImagePalette | Literal[False] | None = None
-
-        info: dict[str, Any] = {}
-        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 and block is not None:
-                    #
-                    # 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 and block is not None:
-                    #
-                    # application extension
-                    #
-                    info["extension"] = block, self.fp.tell()
-                    if block.startswith(b"NETSCAPE2.0"):
-                        block = self.data()
-                        if block and 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 palette:
-                self.palette = palette
-            elif self.global_palette:
-                from copy import copy
-
-                self.palette = copy(self.global_palette)
-            else:
-                self.palette = None
-        else:
-            if self.mode == "P":
-                if (
-                    LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
-                    or palette
-                ):
-                    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: int) -> tuple[int, int, int]:
-            if self._frame_palette:
-                if color * 3 + 3 > len(self._frame_palette.palette):
-                    color = 0
-                return cast(
-                    tuple[int, int, int],
-                    tuple(self._frame_palette.palette[color * 3 : color * 3 + 3]),
-                )
-            else:
-                return (color, color, color)
-
-        self.dispose = None
-        self.dispose_extent: tuple[int, int, int, int] | None = frame_dispose_extent
-        if self.dispose_extent and self.disposal_method >= 2:
-            try:
-                if 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 = [
-                ImageFile._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) -> None:
-        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("RGB", *self._frame_palette.getdata())
-            else:
-                self._im = None
-        if not self._prev_im and self._im is not None and self.size != self.im.size:
-            expanded_im = Image.core.fill(self.im.mode, self.size)
-            if self._frame_palette:
-                expanded_im.putpalette("RGB", *self._frame_palette.getdata())
-            expanded_im.paste(self.im, (0, 0) + self.im.size)
-
-            self.im = expanded_im
-        self._mode = temp_mode
-        self._frame_palette = None
-
-        super().load_prepare()
-
-    def load_end(self) -> None:
-        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.size != self._prev_im.size:
-            if self._frame_transparency is not None:
-                expanded_im = Image.core.fill("RGBA", self.size)
-            else:
-                expanded_im = Image.core.fill("P", self.size)
-                expanded_im.putpalette("RGB", "RGB", self.im.getpalette())
-                expanded_im = expanded_im.convert("RGB")
-            expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size)
-
-            self._prev_im = expanded_im
-            assert self._prev_im is not None
-        if self._frame_transparency is not None:
-            if self.mode == "L":
-                frame_im = self.im.convert_transparent("LA", self._frame_transparency)
-            else:
-                self.im.putpalettealpha(self._frame_transparency, 0)
-                frame_im = self.im.convert("RGBA")
-        else:
-            frame_im = self.im.convert("RGB")
-
-        assert self.dispose_extent is not None
-        frame_im = self._crop(frame_im, self.dispose_extent)
-
-        self.im = self._prev_im
-        self._mode = self.im.mode
-        if frame_im.mode in ("LA", "RGBA"):
-            self.im.paste(frame_im, self.dispose_extent, frame_im)
-        else:
-            self.im.paste(frame_im, self.dispose_extent)
-
-    def tell(self) -> int:
-        return self.__frame
-
-
-# --------------------------------------------------------------------
-# Write GIF files
-
-
-RAWMODE = {"1": "L", "L": "L", "P": "P"}
-
-
-def _normalize_mode(im: Image.Image) -> Image.Image:
-    """
-    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)
-        assert im.palette is not None
-        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")
-
-
-_Palette = Union[bytes, bytearray, list[int], ImagePalette.ImagePalette]
-
-
-def _normalize_palette(
-    im: Image.Image, palette: _Palette | None, info: dict[str, Any]
-) -> Image.Image:
-    """
-    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:
-            im_palette = im.getpalette(None)
-            assert im_palette is not None
-            source_palette = bytearray(im_palette)
-    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)
-    assert source_palette is not None
-
-    if palette:
-        used_palette_colors: list[int | None] = []
-        assert im.palette is not None
-        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
-        dest_map: list[int] = []
-        for index in used_palette_colors:
-            assert index is not None
-            dest_map.append(index)
-        im = im.remap_palette(dest_map)
-    else:
-        optimized_palette_colors = _get_optimize(im, info)
-        if optimized_palette_colors is not None:
-            im = im.remap_palette(optimized_palette_colors, source_palette)
-            if "transparency" in info:
-                try:
-                    info["transparency"] = optimized_palette_colors.index(
-                        info["transparency"]
-                    )
-                except ValueError:
-                    del info["transparency"]
-            return im
-
-    assert im.palette is not None
-    im.palette.palette = source_palette
-    return im
-
-
-def _write_single_frame(
-    im: Image.Image,
-    fp: IO[bytes],
-    palette: _Palette | None,
-) -> None:
-    im_out = _normalize_mode(im)
-    for k, v in im_out.info.items():
-        if isinstance(k, str):
-            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, [ImageFile._Tile("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])]
-    )
-
-    fp.write(b"\0")  # end of image data
-
-
-def _getbbox(
-    base_im: Image.Image, im_frame: Image.Image
-) -> tuple[Image.Image, tuple[int, int, int, int] | None]:
-    palette_bytes = [
-        bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame)
-    ]
-    if palette_bytes[0] != palette_bytes[1]:
-        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)
-
-
-class _Frame(NamedTuple):
-    im: Image.Image
-    bbox: tuple[int, int, int, int] | None
-    encoderinfo: dict[str, Any]
-
-
-def _write_multiple_frames(
-    im: Image.Image, fp: IO[bytes], palette: _Palette | None
-) -> bool:
-    duration = im.encoderinfo.get("duration")
-    disposal = im.encoderinfo.get("disposal", im.info.get("disposal"))
-
-    im_frames: list[_Frame] = []
-    previous_im: Image.Image | None = 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
-                    if isinstance(k, str):
-                        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 and previous_im:
-                # 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:
-                    # To appear correctly in viewers using a convention,
-                    # only consider transparency, and not background color
-                    color = im.encoderinfo.get(
-                        "transparency", im.info.get("transparency")
-                    )
-                    if color is not None:
-                        if background_im is None:
-                            background = _get_background(im_frame, color)
-                            background_im = Image.new("P", im_frame.size, background)
-                            first_palette = im_frames[0].im.palette
-                            assert first_palette is not None
-                            background_im.putpalette(first_palette, first_palette.mode)
-                        bbox = _getbbox(background_im, im_frame)[1]
-                    else:
-                        bbox = (0, 0) + im_frame.size
-                elif encoderinfo.get("optimize") and im_frame.mode != "1":
-                    if "transparency" not in encoderinfo:
-                        assert im_frame.palette is not None
-                        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(_Frame(diff_frame or im_frame, bbox, 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 False
-
-    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
-
-            if frame_data.bbox != (0, 0) + im_frame.size:
-                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: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    _save(im, fp, filename, save_all=True)
-
-
-def _save(
-    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
-) -> None:
-    # 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: Image.Image) -> int:
-    interlace = im.encoderinfo.get("interlace", 1)
-
-    # workaround for @PIL153
-    if min(im.size) < 16:
-        interlace = 0
-
-    return interlace
-
-
-def _write_local_header(
-    fp: IO[bytes], im: Image.Image, offset: tuple[int, int], flags: int
-) -> None:
-    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: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    # 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
-                assert quant_proc.stdout is not None
-                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: Image.Image, info: dict[str, Any]) -> list[int] | None:
-    """
-    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
-
-            assert im.palette is not None
-            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
-    return None
-
-
-def _get_color_table_size(palette_bytes: bytes) -> int:
-    # 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: bytes) -> 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: Image.Image) -> bytes:
-    """
-    Gets the palette for inclusion in the gif header
-
-    :param im: Image object
-    :returns: Bytes, len<=768 suitable for inclusion in gif header
-    """
-    if not im.palette:
-        return b""
-
-    palette = bytes(im.palette.palette)
-    if im.palette.mode == "RGBA":
-        palette = b"".join(palette[i * 4 : i * 4 + 3] for i in range(len(palette) // 3))
-    return palette
-
-
-def _get_background(
-    im: Image.Image,
-    info_background: int | tuple[int, int, int] | tuple[int, int, int, int] | None,
-) -> int:
-    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
-            assert im.palette is not None
-            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: Image.Image, info: dict[str, Any]) -> list[bytes]:
-    """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: IO[bytes],
-    im_frame: Image.Image,
-    offset: tuple[int, int],
-    params: dict[str, Any],
-) -> None:
-    try:
-        im_frame.encoderinfo = params
-
-        # local image header
-        _write_local_header(fp, im_frame, offset, 0)
-
-        ImageFile._save(
-            im_frame,
-            fp,
-            [ImageFile._Tile("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: Image.Image, palette: _Palette | None = None, info: dict[str, Any] | None = None
-) -> tuple[list[bytes], list[int] | 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)
-
-    """
-    if info is None:
-        info = {}
-
-    used_palette_colors = _get_optimize(im, 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: Image.Image, offset: tuple[int, int] = (0, 0), **params: Any
-) -> list[bytes]:
-    """
-    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
-
-    """
-    from io import BytesIO
-
-    class Collector(BytesIO):
-        data = []
-
-        def write(self, data: Buffer) -> int:
-            self.data.append(data)
-            return len(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/python3.11/site-packages/PIL/GimpGradientFile.py

@@ -1,149 +0,0 @@
-#
-# 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 typing import IO, Callable
-
-from ._binary import o8
-
-EPSILON = 1e-10
-""""""  # Enable auto-doc for data member
-
-
-def linear(middle: float, pos: float) -> float:
-    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: float, pos: float) -> float:
-    return pos ** (log(0.5) / log(max(middle, EPSILON)))
-
-
-def sine(middle: float, pos: float) -> float:
-    return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
-
-
-def sphere_increasing(middle: float, pos: float) -> float:
-    return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
-
-
-def sphere_decreasing(middle: float, pos: float) -> float:
-    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: (
-        list[
-            tuple[
-                float,
-                float,
-                float,
-                list[float],
-                list[float],
-                Callable[[float, float], float],
-            ]
-        ]
-        | None
-    ) = None
-
-    def getpalette(self, entries: int = 256) -> tuple[bytes, str]:
-        assert self.gradient is not None
-        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: IO[bytes]) -> None:
-        if not fp.readline().startswith(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)
-
-        self.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)
-
-            self.gradient.append((x0, x1, xm, rgb0, rgb1, segment))

.venv/lib/python3.11/site-packages/PIL/GimpPaletteFile.py

@@ -1,72 +0,0 @@
-#
-# 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 io import BytesIO
-from typing import IO
-
-
-class GimpPaletteFile:
-    """File handler for GIMP's palette format."""
-
-    rawmode = "RGB"
-
-    def _read(self, fp: IO[bytes], limit: bool = True) -> None:
-        if not fp.readline().startswith(b"GIMP Palette"):
-            msg = "not a GIMP palette file"
-            raise SyntaxError(msg)
-
-        palette: list[int] = []
-        i = 0
-        while True:
-            if limit and i == 256 + 3:
-                break
-
-            i += 1
-            s = fp.readline()
-            if not s:
-                break
-
-            # skip fields and comment lines
-            if re.match(rb"\w+:|#", s):
-                continue
-            if limit and len(s) > 100:
-                msg = "bad palette file"
-                raise SyntaxError(msg)
-
-            v = s.split(maxsplit=3)
-            if len(v) < 3:
-                msg = "bad palette entry"
-                raise ValueError(msg)
-
-            palette += (int(v[i]) for i in range(3))
-            if limit and len(palette) == 768:
-                break
-
-        self.palette = bytes(palette)
-
-    def __init__(self, fp: IO[bytes]) -> None:
-        self._read(fp)
-
-    @classmethod
-    def frombytes(cls, data: bytes) -> GimpPaletteFile:
-        self = cls.__new__(cls)
-        self._read(BytesIO(data), False)
-        return self
-
-    def getpalette(self) -> tuple[bytes, str]:
-        return self.palette, self.rawmode

.venv/lib/python3.11/site-packages/PIL/GribStubImagePlugin.py

@@ -1,75 +0,0 @@
-#
-# 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
-
-import os
-from typing import IO
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler: ImageFile.StubHandler | None) -> None:
-    """
-    Install application-specific GRIB image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(b"GRIB") and prefix[7] == 1
-
-
-class GribStubImageFile(ImageFile.StubImageFile):
-    format = "GRIB"
-    format_description = "GRIB"
-
-    def _open(self) -> None:
-        if not _accept(self.fp.read(8)):
-            msg = "Not a GRIB file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(-8, os.SEEK_CUR)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> ImageFile.StubHandler | None:
-        return _handler
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    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/python3.11/site-packages/PIL/Hdf5StubImagePlugin.py

@@ -1,75 +0,0 @@
-#
-# 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
-
-import os
-from typing import IO
-
-from . import Image, ImageFile
-
-_handler = None
-
-
-def register_handler(handler: ImageFile.StubHandler | None) -> None:
-    """
-    Install application-specific HDF5 image handler.
-
-    :param handler: Handler object.
-    """
-    global _handler
-    _handler = handler
-
-
-# --------------------------------------------------------------------
-# Image adapter
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(b"\x89HDF\r\n\x1a\n")
-
-
-class HDF5StubImageFile(ImageFile.StubImageFile):
-    format = "HDF5"
-    format_description = "HDF5"
-
-    def _open(self) -> None:
-        if not _accept(self.fp.read(8)):
-            msg = "Not an HDF file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(-8, os.SEEK_CUR)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> ImageFile.StubHandler | None:
-        return _handler
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    if _handler is None or not hasattr(_handler, "save"):
-        msg = "HDF5 save handler not installed"
-        raise OSError(msg)
-    _handler.save(im, fp, filename)
-
-
-# --------------------------------------------------------------------
-# Registry
-
-Image.register_open(HDF5StubImageFile.format, HDF5StubImageFile, _accept)
-Image.register_save(HDF5StubImageFile.format, _save)
-
-Image.register_extensions(HDF5StubImageFile.format, [".h5", ".hdf"])

.venv/lib/python3.11/site-packages/PIL/IcnsImagePlugin.py

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

.venv/lib/python3.11/site-packages/PIL/IcoImagePlugin.py

@@ -1,381 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# Windows Icon support for PIL
-#
-# 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.
-#
-
-# This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
-# <casadebender@gmail.com>.
-# https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
-#
-# Icon format references:
-#   * https://en.wikipedia.org/wiki/ICO_(file_format)
-#   * https://msdn.microsoft.com/en-us/library/ms997538.aspx
-from __future__ import annotations
-
-import warnings
-from io import BytesIO
-from math import ceil, log
-from typing import IO, NamedTuple
-
-from . import BmpImagePlugin, Image, ImageFile, PngImagePlugin
-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
-
-#
-# --------------------------------------------------------------------
-
-_MAGIC = b"\0\0\1\0"
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    fp.write(_MAGIC)  # (2+2)
-    bmp = im.encoderinfo.get("bitmap_format") == "bmp"
-    sizes = im.encoderinfo.get(
-        "sizes",
-        [(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)],
-    )
-    frames = []
-    provided_ims = [im] + im.encoderinfo.get("append_images", [])
-    width, height = im.size
-    for size in sorted(set(sizes)):
-        if size[0] > width or size[1] > height or size[0] > 256 or size[1] > 256:
-            continue
-
-        for provided_im in provided_ims:
-            if provided_im.size != size:
-                continue
-            frames.append(provided_im)
-            if bmp:
-                bits = BmpImagePlugin.SAVE[provided_im.mode][1]
-                bits_used = [bits]
-                for other_im in provided_ims:
-                    if other_im.size != size:
-                        continue
-                    bits = BmpImagePlugin.SAVE[other_im.mode][1]
-                    if bits not in bits_used:
-                        # Another image has been supplied for this size
-                        # with a different bit depth
-                        frames.append(other_im)
-                        bits_used.append(bits)
-            break
-        else:
-            # TODO: invent a more convenient method for proportional scalings
-            frame = provided_im.copy()
-            frame.thumbnail(size, Image.Resampling.LANCZOS, reducing_gap=None)
-            frames.append(frame)
-    fp.write(o16(len(frames)))  # idCount(2)
-    offset = fp.tell() + len(frames) * 16
-    for frame in frames:
-        width, height = frame.size
-        # 0 means 256
-        fp.write(o8(width if width < 256 else 0))  # bWidth(1)
-        fp.write(o8(height if height < 256 else 0))  # bHeight(1)
-
-        bits, colors = BmpImagePlugin.SAVE[frame.mode][1:] if bmp else (32, 0)
-        fp.write(o8(colors))  # bColorCount(1)
-        fp.write(b"\0")  # bReserved(1)
-        fp.write(b"\0\0")  # wPlanes(2)
-        fp.write(o16(bits))  # wBitCount(2)
-
-        image_io = BytesIO()
-        if bmp:
-            frame.save(image_io, "dib")
-
-            if bits != 32:
-                and_mask = Image.new("1", size)
-                ImageFile._save(
-                    and_mask,
-                    image_io,
-                    [ImageFile._Tile("raw", (0, 0) + size, 0, ("1", 0, -1))],
-                )
-        else:
-            frame.save(image_io, "png")
-        image_io.seek(0)
-        image_bytes = image_io.read()
-        if bmp:
-            image_bytes = image_bytes[:8] + o32(height * 2) + image_bytes[12:]
-        bytes_len = len(image_bytes)
-        fp.write(o32(bytes_len))  # dwBytesInRes(4)
-        fp.write(o32(offset))  # dwImageOffset(4)
-        current = fp.tell()
-        fp.seek(offset)
-        fp.write(image_bytes)
-        offset = offset + bytes_len
-        fp.seek(current)
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix.startswith(_MAGIC)
-
-
-class IconHeader(NamedTuple):
-    width: int
-    height: int
-    nb_color: int
-    reserved: int
-    planes: int
-    bpp: int
-    size: int
-    offset: int
-    dim: tuple[int, int]
-    square: int
-    color_depth: int
-
-
-class IcoFile:
-    def __init__(self, buf: IO[bytes]) -> None:
-        """
-        Parse image from file-like object containing ico file data
-        """
-
-        # check magic
-        s = buf.read(6)
-        if not _accept(s):
-            msg = "not an ICO file"
-            raise SyntaxError(msg)
-
-        self.buf = buf
-        self.entry = []
-
-        # Number of items in file
-        self.nb_items = i16(s, 4)
-
-        # Get headers for each item
-        for i in range(self.nb_items):
-            s = buf.read(16)
-
-            # See Wikipedia
-            width = s[0] or 256
-            height = s[1] or 256
-
-            # No. of colors in image (0 if >=8bpp)
-            nb_color = s[2]
-            bpp = i16(s, 6)
-            icon_header = IconHeader(
-                width=width,
-                height=height,
-                nb_color=nb_color,
-                reserved=s[3],
-                planes=i16(s, 4),
-                bpp=i16(s, 6),
-                size=i32(s, 8),
-                offset=i32(s, 12),
-                dim=(width, height),
-                square=width * height,
-                # See Wikipedia notes about color depth.
-                # We need this just to differ images with equal sizes
-                color_depth=bpp or (nb_color != 0 and ceil(log(nb_color, 2))) or 256,
-            )
-
-            self.entry.append(icon_header)
-
-        self.entry = sorted(self.entry, key=lambda x: x.color_depth)
-        # ICO images are usually squares
-        self.entry = sorted(self.entry, key=lambda x: x.square, reverse=True)
-
-    def sizes(self) -> set[tuple[int, int]]:
-        """
-        Get a set of all available icon sizes and color depths.
-        """
-        return {(h.width, h.height) for h in self.entry}
-
-    def getentryindex(self, size: tuple[int, int], bpp: int | bool = False) -> int:
-        for i, h in enumerate(self.entry):
-            if size == h.dim and (bpp is False or bpp == h.color_depth):
-                return i
-        return 0
-
-    def getimage(self, size: tuple[int, int], bpp: int | bool = False) -> Image.Image:
-        """
-        Get an image from the icon
-        """
-        return self.frame(self.getentryindex(size, bpp))
-
-    def frame(self, idx: int) -> Image.Image:
-        """
-        Get an image from frame idx
-        """
-
-        header = self.entry[idx]
-
-        self.buf.seek(header.offset)
-        data = self.buf.read(8)
-        self.buf.seek(header.offset)
-
-        im: Image.Image
-        if data[:8] == PngImagePlugin._MAGIC:
-            # png frame
-            im = PngImagePlugin.PngImageFile(self.buf)
-            Image._decompression_bomb_check(im.size)
-        else:
-            # XOR + AND mask bmp frame
-            im = BmpImagePlugin.DibImageFile(self.buf)
-            Image._decompression_bomb_check(im.size)
-
-            # change tile dimension to only encompass XOR image
-            im._size = (im.size[0], int(im.size[1] / 2))
-            d, e, o, a = im.tile[0]
-            im.tile[0] = ImageFile._Tile(d, (0, 0) + im.size, o, a)
-
-            # figure out where AND mask image starts
-            if header.bpp == 32:
-                # 32-bit color depth icon image allows semitransparent areas
-                # PIL's DIB format ignores transparency bits, recover them.
-                # The DIB is packed in BGRX byte order where X is the alpha
-                # channel.
-
-                # Back up to start of bmp data
-                self.buf.seek(o)
-                # extract every 4th byte (eg. 3,7,11,15,...)
-                alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
-
-                # convert to an 8bpp grayscale image
-                try:
-                    mask = Image.frombuffer(
-                        "L",  # 8bpp
-                        im.size,  # (w, h)
-                        alpha_bytes,  # source chars
-                        "raw",  # raw decoder
-                        ("L", 0, -1),  # 8bpp inverted, unpadded, reversed
-                    )
-                except ValueError:
-                    if ImageFile.LOAD_TRUNCATED_IMAGES:
-                        mask = None
-                    else:
-                        raise
-            else:
-                # get AND image from end of bitmap
-                w = im.size[0]
-                if (w % 32) > 0:
-                    # bitmap row data is aligned to word boundaries
-                    w += 32 - (im.size[0] % 32)
-
-                # the total mask data is
-                # padded row size * height / bits per char
-
-                total_bytes = int((w * im.size[1]) / 8)
-                and_mask_offset = header.offset + header.size - total_bytes
-
-                self.buf.seek(and_mask_offset)
-                mask_data = self.buf.read(total_bytes)
-
-                # convert raw data to image
-                try:
-                    mask = Image.frombuffer(
-                        "1",  # 1 bpp
-                        im.size,  # (w, h)
-                        mask_data,  # source chars
-                        "raw",  # raw decoder
-                        ("1;I", int(w / 8), -1),  # 1bpp inverted, padded, reversed
-                    )
-                except ValueError:
-                    if ImageFile.LOAD_TRUNCATED_IMAGES:
-                        mask = None
-                    else:
-                        raise
-
-                # now we have two images, im is XOR image and mask is AND image
-
-            # apply mask image as alpha channel
-            if mask:
-                im = im.convert("RGBA")
-                im.putalpha(mask)
-
-        return im
-
-
-##
-# Image plugin for Windows Icon files.
-
-
-class IcoImageFile(ImageFile.ImageFile):
-    """
-    PIL read-only image support for Microsoft Windows .ico files.
-
-    By default the largest resolution image in the file will be loaded. This
-    can be changed by altering the 'size' attribute before calling 'load'.
-
-    The info dictionary has a key 'sizes' that is a list of the sizes available
-    in the icon file.
-
-    Handles classic, XP and Vista icon formats.
-
-    When saving, PNG compression is used. Support for this was only added in
-    Windows Vista. If you are unable to view the icon in Windows, convert the
-    image to "RGBA" mode before saving.
-
-    This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
-    <casadebender@gmail.com>.
-    https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
-    """
-
-    format = "ICO"
-    format_description = "Windows Icon"
-
-    def _open(self) -> None:
-        self.ico = IcoFile(self.fp)
-        self.info["sizes"] = self.ico.sizes()
-        self.size = self.ico.entry[0].dim
-        self.load()
-
-    @property
-    def size(self) -> tuple[int, int]:
-        return self._size
-
-    @size.setter
-    def size(self, value: tuple[int, int]) -> None:
-        if value not in self.info["sizes"]:
-            msg = "This is not one of the allowed sizes of this image"
-            raise ValueError(msg)
-        self._size = value
-
-    def load(self) -> Image.core.PixelAccess | None:
-        if self._im is not None and self.im.size == self.size:
-            # Already loaded
-            return Image.Image.load(self)
-        im = self.ico.getimage(self.size)
-        # if tile is PNG, it won't really be loaded yet
-        im.load()
-        self.im = im.im
-        self._mode = im.mode
-        if im.palette:
-            self.palette = im.palette
-        if im.size != self.size:
-            warnings.warn("Image was not the expected size")
-
-            index = self.ico.getentryindex(self.size)
-            sizes = list(self.info["sizes"])
-            sizes[index] = im.size
-            self.info["sizes"] = set(sizes)
-
-            self.size = im.size
-        return Image.Image.load(self)
-
-    def load_seek(self, pos: int) -> None:
-        # Flag the ImageFile.Parser so that it
-        # just does all the decode at the end.
-        pass
-
-
-#
-# --------------------------------------------------------------------
-
-
-Image.register_open(IcoImageFile.format, IcoImageFile, _accept)
-Image.register_save(IcoImageFile.format, _save)
-Image.register_extension(IcoImageFile.format, ".ico")
-
-Image.register_mime(IcoImageFile.format, "image/x-icon")

.venv/lib/python3.11/site-packages/PIL/ImImagePlugin.py

@@ -1,389 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# IFUNC IM file handling for PIL
-#
-# history:
-# 1995-09-01 fl   Created.
-# 1997-01-03 fl   Save palette images
-# 1997-01-08 fl   Added sequence support
-# 1997-01-23 fl   Added P and RGB save support
-# 1997-05-31 fl   Read floating point images
-# 1997-06-22 fl   Save floating point images
-# 1997-08-27 fl   Read and save 1-bit images
-# 1998-06-25 fl   Added support for RGB+LUT images
-# 1998-07-02 fl   Added support for YCC images
-# 1998-07-15 fl   Renamed offset attribute to avoid name clash
-# 1998-12-29 fl   Added I;16 support
-# 2001-02-17 fl   Use 're' instead of 'regex' (Python 2.1) (0.7)
-# 2003-09-26 fl   Added LA/PA support
-#
-# Copyright (c) 1997-2003 by Secret Labs AB.
-# Copyright (c) 1995-2001 by Fredrik Lundh.
-#
-# See the README file for information on usage and redistribution.
-#
-from __future__ import annotations
-
-import os
-import re
-from typing import IO, Any
-
-from . import Image, ImageFile, ImagePalette
-from ._util import DeferredError
-
-# --------------------------------------------------------------------
-# Standard tags
-
-COMMENT = "Comment"
-DATE = "Date"
-EQUIPMENT = "Digitalization equipment"
-FRAMES = "File size (no of images)"
-LUT = "Lut"
-NAME = "Name"
-SCALE = "Scale (x,y)"
-SIZE = "Image size (x*y)"
-MODE = "Image type"
-
-TAGS = {
-    COMMENT: 0,
-    DATE: 0,
-    EQUIPMENT: 0,
-    FRAMES: 0,
-    LUT: 0,
-    NAME: 0,
-    SCALE: 0,
-    SIZE: 0,
-    MODE: 0,
-}
-
-OPEN = {
-    # ifunc93/p3cfunc formats
-    "0 1 image": ("1", "1"),
-    "L 1 image": ("1", "1"),
-    "Greyscale image": ("L", "L"),
-    "Grayscale image": ("L", "L"),
-    "RGB image": ("RGB", "RGB;L"),
-    "RLB image": ("RGB", "RLB"),
-    "RYB image": ("RGB", "RLB"),
-    "B1 image": ("1", "1"),
-    "B2 image": ("P", "P;2"),
-    "B4 image": ("P", "P;4"),
-    "X 24 image": ("RGB", "RGB"),
-    "L 32 S image": ("I", "I;32"),
-    "L 32 F image": ("F", "F;32"),
-    # old p3cfunc formats
-    "RGB3 image": ("RGB", "RGB;T"),
-    "RYB3 image": ("RGB", "RYB;T"),
-    # extensions
-    "LA image": ("LA", "LA;L"),
-    "PA image": ("LA", "PA;L"),
-    "RGBA image": ("RGBA", "RGBA;L"),
-    "RGBX image": ("RGB", "RGBX;L"),
-    "CMYK image": ("CMYK", "CMYK;L"),
-    "YCC image": ("YCbCr", "YCbCr;L"),
-}
-
-# ifunc95 extensions
-for i in ["8", "8S", "16", "16S", "32", "32F"]:
-    OPEN[f"L {i} image"] = ("F", f"F;{i}")
-    OPEN[f"L*{i} image"] = ("F", f"F;{i}")
-for i in ["16", "16L", "16B"]:
-    OPEN[f"L {i} image"] = (f"I;{i}", f"I;{i}")
-    OPEN[f"L*{i} image"] = (f"I;{i}", f"I;{i}")
-for i in ["32S"]:
-    OPEN[f"L {i} image"] = ("I", f"I;{i}")
-    OPEN[f"L*{i} image"] = ("I", f"I;{i}")
-for j in range(2, 33):
-    OPEN[f"L*{j} image"] = ("F", f"F;{j}")
-
-
-# --------------------------------------------------------------------
-# Read IM directory
-
-split = re.compile(rb"^([A-Za-z][^:]*):[ \t]*(.*)[ \t]*$")
-
-
-def number(s: Any) -> float:
-    try:
-        return int(s)
-    except ValueError:
-        return float(s)
-
-
-##
-# Image plugin for the IFUNC IM file format.
-
-
-class ImImageFile(ImageFile.ImageFile):
-    format = "IM"
-    format_description = "IFUNC Image Memory"
-    _close_exclusive_fp_after_loading = False
-
-    def _open(self) -> None:
-        # Quick rejection: if there's not an LF among the first
-        # 100 bytes, this is (probably) not a text header.
-
-        if b"\n" not in self.fp.read(100):
-            msg = "not an IM file"
-            raise SyntaxError(msg)
-        self.fp.seek(0)
-
-        n = 0
-
-        # Default values
-        self.info[MODE] = "L"
-        self.info[SIZE] = (512, 512)
-        self.info[FRAMES] = 1
-
-        self.rawmode = "L"
-
-        while True:
-            s = self.fp.read(1)
-
-            # Some versions of IFUNC uses \n\r instead of \r\n...
-            if s == b"\r":
-                continue
-
-            if not s or s == b"\0" or s == b"\x1a":
-                break
-
-            # FIXME: this may read whole file if not a text file
-            s = s + self.fp.readline()
-
-            if len(s) > 100:
-                msg = "not an IM file"
-                raise SyntaxError(msg)
-
-            if s.endswith(b"\r\n"):
-                s = s[:-2]
-            elif s.endswith(b"\n"):
-                s = s[:-1]
-
-            try:
-                m = split.match(s)
-            except re.error as e:
-                msg = "not an IM file"
-                raise SyntaxError(msg) from e
-
-            if m:
-                k, v = m.group(1, 2)
-
-                # Don't know if this is the correct encoding,
-                # but a decent guess (I guess)
-                k = k.decode("latin-1", "replace")
-                v = v.decode("latin-1", "replace")
-
-                # Convert value as appropriate
-                if k in [FRAMES, SCALE, SIZE]:
-                    v = v.replace("*", ",")
-                    v = tuple(map(number, v.split(",")))
-                    if len(v) == 1:
-                        v = v[0]
-                elif k == MODE and v in OPEN:
-                    v, self.rawmode = OPEN[v]
-
-                # Add to dictionary. Note that COMMENT tags are
-                # combined into a list of strings.
-                if k == COMMENT:
-                    if k in self.info:
-                        self.info[k].append(v)
-                    else:
-                        self.info[k] = [v]
-                else:
-                    self.info[k] = v
-
-                if k in TAGS:
-                    n += 1
-
-            else:
-                msg = f"Syntax error in IM header: {s.decode('ascii', 'replace')}"
-                raise SyntaxError(msg)
-
-        if not n:
-            msg = "Not an IM file"
-            raise SyntaxError(msg)
-
-        # Basic attributes
-        self._size = self.info[SIZE]
-        self._mode = self.info[MODE]
-
-        # Skip forward to start of image data
-        while s and not s.startswith(b"\x1a"):
-            s = self.fp.read(1)
-        if not s:
-            msg = "File truncated"
-            raise SyntaxError(msg)
-
-        if LUT in self.info:
-            # convert lookup table to palette or lut attribute
-            palette = self.fp.read(768)
-            greyscale = 1  # greyscale palette
-            linear = 1  # linear greyscale palette
-            for i in range(256):
-                if palette[i] == palette[i + 256] == palette[i + 512]:
-                    if palette[i] != i:
-                        linear = 0
-                else:
-                    greyscale = 0
-            if self.mode in ["L", "LA", "P", "PA"]:
-                if greyscale:
-                    if not linear:
-                        self.lut = list(palette[:256])
-                else:
-                    if self.mode in ["L", "P"]:
-                        self._mode = self.rawmode = "P"
-                    elif self.mode in ["LA", "PA"]:
-                        self._mode = "PA"
-                        self.rawmode = "PA;L"
-                    self.palette = ImagePalette.raw("RGB;L", palette)
-            elif self.mode == "RGB":
-                if not greyscale or not linear:
-                    self.lut = list(palette)
-
-        self.frame = 0
-
-        self.__offset = offs = self.fp.tell()
-
-        self._fp = self.fp  # FIXME: hack
-
-        if self.rawmode.startswith("F;"):
-            # ifunc95 formats
-            try:
-                # use bit decoder (if necessary)
-                bits = int(self.rawmode[2:])
-                if bits not in [8, 16, 32]:
-                    self.tile = [
-                        ImageFile._Tile(
-                            "bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1)
-                        )
-                    ]
-                    return
-            except ValueError:
-                pass
-
-        if self.rawmode in ["RGB;T", "RYB;T"]:
-            # Old LabEye/3PC files.  Would be very surprised if anyone
-            # ever stumbled upon such a file ;-)
-            size = self.size[0] * self.size[1]
-            self.tile = [
-                ImageFile._Tile("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
-                ImageFile._Tile("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
-                ImageFile._Tile(
-                    "raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)
-                ),
-            ]
-        else:
-            # LabEye/IFUNC files
-            self.tile = [
-                ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
-            ]
-
-    @property
-    def n_frames(self) -> int:
-        return self.info[FRAMES]
-
-    @property
-    def is_animated(self) -> bool:
-        return self.info[FRAMES] > 1
-
-    def seek(self, frame: int) -> None:
-        if not self._seek_check(frame):
-            return
-        if isinstance(self._fp, DeferredError):
-            raise self._fp.ex
-
-        self.frame = frame
-
-        if self.mode == "1":
-            bits = 1
-        else:
-            bits = 8 * len(self.mode)
-
-        size = ((self.size[0] * bits + 7) // 8) * self.size[1]
-        offs = self.__offset + frame * size
-
-        self.fp = self._fp
-
-        self.tile = [
-            ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
-        ]
-
-    def tell(self) -> int:
-        return self.frame
-
-
-#
-# --------------------------------------------------------------------
-# Save IM files
-
-
-SAVE = {
-    # mode: (im type, raw mode)
-    "1": ("0 1", "1"),
-    "L": ("Greyscale", "L"),
-    "LA": ("LA", "LA;L"),
-    "P": ("Greyscale", "P"),
-    "PA": ("LA", "PA;L"),
-    "I": ("L 32S", "I;32S"),
-    "I;16": ("L 16", "I;16"),
-    "I;16L": ("L 16L", "I;16L"),
-    "I;16B": ("L 16B", "I;16B"),
-    "F": ("L 32F", "F;32F"),
-    "RGB": ("RGB", "RGB;L"),
-    "RGBA": ("RGBA", "RGBA;L"),
-    "RGBX": ("RGBX", "RGBX;L"),
-    "CMYK": ("CMYK", "CMYK;L"),
-    "YCbCr": ("YCC", "YCbCr;L"),
-}
-
-
-def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
-    try:
-        image_type, rawmode = SAVE[im.mode]
-    except KeyError as e:
-        msg = f"Cannot save {im.mode} images as IM"
-        raise ValueError(msg) from e
-
-    frames = im.encoderinfo.get("frames", 1)
-
-    fp.write(f"Image type: {image_type} image\r\n".encode("ascii"))
-    if filename:
-        # Each line must be 100 characters or less,
-        # or: SyntaxError("not an IM file")
-        # 8 characters are used for "Name: " and "\r\n"
-        # Keep just the filename, ditch the potentially overlong path
-        if isinstance(filename, bytes):
-            filename = filename.decode("ascii")
-        name, ext = os.path.splitext(os.path.basename(filename))
-        name = "".join([name[: 92 - len(ext)], ext])
-
-        fp.write(f"Name: {name}\r\n".encode("ascii"))
-    fp.write(f"Image size (x*y): {im.size[0]}*{im.size[1]}\r\n".encode("ascii"))
-    fp.write(f"File size (no of images): {frames}\r\n".encode("ascii"))
-    if im.mode in ["P", "PA"]:
-        fp.write(b"Lut: 1\r\n")
-    fp.write(b"\000" * (511 - fp.tell()) + b"\032")
-    if im.mode in ["P", "PA"]:
-        im_palette = im.im.getpalette("RGB", "RGB;L")
-        colors = len(im_palette) // 3
-        palette = b""
-        for i in range(3):
-            palette += im_palette[colors * i : colors * (i + 1)]
-            palette += b"\x00" * (256 - colors)
-        fp.write(palette)  # 768 bytes
-    ImageFile._save(
-        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))]
-    )
-
-
-#
-# --------------------------------------------------------------------
-# Registry
-
-
-Image.register_open(ImImageFile.format, ImImageFile)
-Image.register_save(ImImageFile.format, _save)
-
-Image.register_extension(ImImageFile.format, ".im")

.venv/lib/python3.11/site-packages/PIL/ImageChops.py

@@ -1,311 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# standard channel operations
-#
-# History:
-# 1996-03-24 fl   Created
-# 1996-08-13 fl   Added logical operations (for "1" images)
-# 2000-10-12 fl   Added offset method (from Image.py)
-#
-# Copyright (c) 1997-2000 by Secret Labs AB
-# Copyright (c) 1996-2000 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-from __future__ import annotations
-
-from . import Image
-
-
-def constant(image: Image.Image, value: int) -> Image.Image:
-    """Fill a channel with a given gray level.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.new("L", image.size, value)
-
-
-def duplicate(image: Image.Image) -> Image.Image:
-    """Copy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return image.copy()
-
-
-def invert(image: Image.Image) -> Image.Image:
-    """
-    Invert an image (channel). ::
-
-        out = MAX - image
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image.load()
-    return image._new(image.im.chop_invert())
-
-
-def lighter(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Compares the two images, pixel by pixel, and returns a new image containing
-    the lighter values. ::
-
-        out = max(image1, image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_lighter(image2.im))
-
-
-def darker(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Compares the two images, pixel by pixel, and returns a new image containing
-    the darker values. ::
-
-        out = min(image1, image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_darker(image2.im))
-
-
-def difference(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Returns the absolute value of the pixel-by-pixel difference between the two
-    images. ::
-
-        out = abs(image1 - image2)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_difference(image2.im))
-
-
-def multiply(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Superimposes two images on top of each other.
-
-    If you multiply an image with a solid black image, the result is black. If
-    you multiply with a solid white image, the image is unaffected. ::
-
-        out = image1 * image2 / MAX
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_multiply(image2.im))
-
-
-def screen(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Superimposes two inverted images on top of each other. ::
-
-        out = MAX - ((MAX - image1) * (MAX - image2) / MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_screen(image2.im))
-
-
-def soft_light(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Superimposes two images on top of each other using the Soft Light algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_soft_light(image2.im))
-
-
-def hard_light(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Superimposes two images on top of each other using the Hard Light algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_hard_light(image2.im))
-
-
-def overlay(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """
-    Superimposes two images on top of each other using the Overlay algorithm
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_overlay(image2.im))
-
-
-def add(
-    image1: Image.Image, image2: Image.Image, scale: float = 1.0, offset: float = 0
-) -> Image.Image:
-    """
-    Adds two images, dividing the result by scale and adding the
-    offset. If omitted, scale defaults to 1.0, and offset to 0.0. ::
-
-        out = ((image1 + image2) / scale + offset)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_add(image2.im, scale, offset))
-
-
-def subtract(
-    image1: Image.Image, image2: Image.Image, scale: float = 1.0, offset: float = 0
-) -> Image.Image:
-    """
-    Subtracts two images, dividing the result by scale and adding the offset.
-    If omitted, scale defaults to 1.0, and offset to 0.0. ::
-
-        out = ((image1 - image2) / scale + offset)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_subtract(image2.im, scale, offset))
-
-
-def add_modulo(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """Add two images, without clipping the result. ::
-
-        out = ((image1 + image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_add_modulo(image2.im))
-
-
-def subtract_modulo(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """Subtract two images, without clipping the result. ::
-
-        out = ((image1 - image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_subtract_modulo(image2.im))
-
-
-def logical_and(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """Logical AND between two images.
-
-    Both of the images must have mode "1". If you would like to perform a
-    logical AND on an image with a mode other than "1", try
-    :py:meth:`~PIL.ImageChops.multiply` instead, using a black-and-white mask
-    as the second image. ::
-
-        out = ((image1 and image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_and(image2.im))
-
-
-def logical_or(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """Logical OR between two images.
-
-    Both of the images must have mode "1". ::
-
-        out = ((image1 or image2) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_or(image2.im))
-
-
-def logical_xor(image1: Image.Image, image2: Image.Image) -> Image.Image:
-    """Logical XOR between two images.
-
-    Both of the images must have mode "1". ::
-
-        out = ((bool(image1) != bool(image2)) % MAX)
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    image1.load()
-    image2.load()
-    return image1._new(image1.im.chop_xor(image2.im))
-
-
-def blend(image1: Image.Image, image2: Image.Image, alpha: float) -> Image.Image:
-    """Blend images using constant transparency weight. Alias for
-    :py:func:`PIL.Image.blend`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.blend(image1, image2, alpha)
-
-
-def composite(
-    image1: Image.Image, image2: Image.Image, mask: Image.Image
-) -> Image.Image:
-    """Create composite using transparency mask. Alias for
-    :py:func:`PIL.Image.composite`.
-
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    return Image.composite(image1, image2, mask)
-
-
-def offset(image: Image.Image, xoffset: int, yoffset: int | None = None) -> Image.Image:
-    """Returns a copy of the image where data has been offset by the given
-    distances. Data wraps around the edges. If ``yoffset`` is omitted, it
-    is assumed to be equal to ``xoffset``.
-
-    :param image: Input image.
-    :param xoffset: The horizontal distance.
-    :param yoffset: The vertical distance.  If omitted, both
-        distances are set to the same value.
-    :rtype: :py:class:`~PIL.Image.Image`
-    """
-
-    if yoffset is None:
-        yoffset = xoffset
-    image.load()
-    return image._new(image.im.offset(xoffset, yoffset))

.venv/lib/python3.11/site-packages/PIL/ImageCms.py

@@ -1,1123 +0,0 @@
-# The Python Imaging Library.
-# $Id$
-
-# Optional color management support, based on Kevin Cazabon's PyCMS
-# library.
-
-# Originally released under LGPL.  Graciously donated to PIL in
-# March 2009, for distribution under the standard PIL license
-
-# History:
-
-# 2009-03-08 fl   Added to PIL.
-
-# Copyright (C) 2002-2003 Kevin Cazabon
-# Copyright (c) 2009 by Fredrik Lundh
-# Copyright (c) 2013 by Eric Soroos
-
-# See the README file for information on usage and redistribution.  See
-# below for the original description.
-from __future__ import annotations
-
-import operator
-import sys
-from enum import IntEnum, IntFlag
-from functools import reduce
-from typing import Any, Literal, SupportsFloat, SupportsInt, Union
-
-from . import Image, __version__
-from ._deprecate import deprecate
-from ._typing import SupportsRead
-
-try:
-    from . import _imagingcms as core
-
-    _CmsProfileCompatible = Union[
-        str, SupportsRead[bytes], core.CmsProfile, "ImageCmsProfile"
-    ]
-except ImportError as ex:
-    # Allow error import for doc purposes, but error out when accessing
-    # anything in core.
-    from ._util import DeferredError
-
-    core = DeferredError.new(ex)
-
-_DESCRIPTION = """
-pyCMS
-
-    a Python / PIL interface to the littleCMS ICC Color Management System
-    Copyright (C) 2002-2003 Kevin Cazabon
-    kevin@cazabon.com
-    https://www.cazabon.com
-
-    pyCMS home page:  https://www.cazabon.com/pyCMS
-    littleCMS home page:  https://www.littlecms.com
-    (littleCMS is Copyright (C) 1998-2001 Marti Maria)
-
-    Originally released under LGPL.  Graciously donated to PIL in
-    March 2009, for distribution under the standard PIL license
-
-    The pyCMS.py module provides a "clean" interface between Python/PIL and
-    pyCMSdll, taking care of some of the more complex handling of the direct
-    pyCMSdll functions, as well as error-checking and making sure that all
-    relevant data is kept together.
-
-    While it is possible to call pyCMSdll functions directly, it's not highly
-    recommended.
-
-    Version History:
-
-        1.0.0 pil       Oct 2013 Port to LCMS 2.
-
-        0.1.0 pil mod   March 10, 2009
-
-                        Renamed display profile to proof profile. The proof
-                        profile is the profile of the device that is being
-                        simulated, not the profile of the device which is
-                        actually used to display/print the final simulation
-                        (that'd be the output profile) - also see LCMSAPI.txt
-                        input colorspace -> using 'renderingIntent' -> proof
-                        colorspace -> using 'proofRenderingIntent' -> output
-                        colorspace
-
-                        Added LCMS FLAGS support.
-                        Added FLAGS["SOFTPROOFING"] as default flag for
-                        buildProofTransform (otherwise the proof profile/intent
-                        would be ignored).
-
-        0.1.0 pil       March 2009 - added to PIL, as PIL.ImageCms
-
-        0.0.2 alpha     Jan 6, 2002
-
-                        Added try/except statements around type() checks of
-                        potential CObjects... Python won't let you use type()
-                        on them, and raises a TypeError (stupid, if you ask
-                        me!)
-
-                        Added buildProofTransformFromOpenProfiles() function.
-                        Additional fixes in DLL, see DLL code for details.
-
-        0.0.1 alpha     first public release, Dec. 26, 2002
-
-    Known to-do list with current version (of Python interface, not pyCMSdll):
-
-        none
-
-"""
-
-_VERSION = "1.0.0 pil"
-
-
-def __getattr__(name: str) -> Any:
-    if name == "DESCRIPTION":
-        deprecate("PIL.ImageCms.DESCRIPTION", 12)
-        return _DESCRIPTION
-    elif name == "VERSION":
-        deprecate("PIL.ImageCms.VERSION", 12)
-        return _VERSION
-    elif name == "FLAGS":
-        deprecate("PIL.ImageCms.FLAGS", 12, "PIL.ImageCms.Flags")
-        return _FLAGS
-    msg = f"module '{__name__}' has no attribute '{name}'"
-    raise AttributeError(msg)
-
-
-# --------------------------------------------------------------------.
-
-
-#
-# intent/direction values
-
-
-class Intent(IntEnum):
-    PERCEPTUAL = 0
-    RELATIVE_COLORIMETRIC = 1
-    SATURATION = 2
-    ABSOLUTE_COLORIMETRIC = 3
-
-
-class Direction(IntEnum):
-    INPUT = 0
-    OUTPUT = 1
-    PROOF = 2
-
-
-#
-# flags
-
-
-class Flags(IntFlag):
-    """Flags and documentation are taken from ``lcms2.h``."""
-
-    NONE = 0
-    NOCACHE = 0x0040
-    """Inhibit 1-pixel cache"""
-    NOOPTIMIZE = 0x0100
-    """Inhibit optimizations"""
-    NULLTRANSFORM = 0x0200
-    """Don't transform anyway"""
-    GAMUTCHECK = 0x1000
-    """Out of Gamut alarm"""
-    SOFTPROOFING = 0x4000
-    """Do softproofing"""
-    BLACKPOINTCOMPENSATION = 0x2000
-    NOWHITEONWHITEFIXUP = 0x0004
-    """Don't fix scum dot"""
-    HIGHRESPRECALC = 0x0400
-    """Use more memory to give better accuracy"""
-    LOWRESPRECALC = 0x0800
-    """Use less memory to minimize resources"""
-    # this should be 8BITS_DEVICELINK, but that is not a valid name in Python:
-    USE_8BITS_DEVICELINK = 0x0008
-    """Create 8 bits devicelinks"""
-    GUESSDEVICECLASS = 0x0020
-    """Guess device class (for ``transform2devicelink``)"""
-    KEEP_SEQUENCE = 0x0080
-    """Keep profile sequence for devicelink creation"""
-    FORCE_CLUT = 0x0002
-    """Force CLUT optimization"""
-    CLUT_POST_LINEARIZATION = 0x0001
-    """create postlinearization tables if possible"""
-    CLUT_PRE_LINEARIZATION = 0x0010
-    """create prelinearization tables if possible"""
-    NONEGATIVES = 0x8000
-    """Prevent negative numbers in floating point transforms"""
-    COPY_ALPHA = 0x04000000
-    """Alpha channels are copied on ``cmsDoTransform()``"""
-    NODEFAULTRESOURCEDEF = 0x01000000
-
-    _GRIDPOINTS_1 = 1 << 16
-    _GRIDPOINTS_2 = 2 << 16
-    _GRIDPOINTS_4 = 4 << 16
-    _GRIDPOINTS_8 = 8 << 16
-    _GRIDPOINTS_16 = 16 << 16
-    _GRIDPOINTS_32 = 32 << 16
-    _GRIDPOINTS_64 = 64 << 16
-    _GRIDPOINTS_128 = 128 << 16
-
-    @staticmethod
-    def GRIDPOINTS(n: int) -> Flags:
-        """
-        Fine-tune control over number of gridpoints
-
-        :param n: :py:class:`int` in range ``0 <= n <= 255``
-        """
-        return Flags.NONE | ((n & 0xFF) << 16)
-
-
-_MAX_FLAG = reduce(operator.or_, Flags)
-
-
-_FLAGS = {
-    "MATRIXINPUT": 1,
-    "MATRIXOUTPUT": 2,
-    "MATRIXONLY": (1 | 2),
-    "NOWHITEONWHITEFIXUP": 4,  # Don't hot fix scum dot
-    # Don't create prelinearization tables on precalculated transforms
-    # (internal use):
-    "NOPRELINEARIZATION": 16,
-    "GUESSDEVICECLASS": 32,  # Guess device class (for transform2devicelink)
-    "NOTCACHE": 64,  # Inhibit 1-pixel cache
-    "NOTPRECALC": 256,
-    "NULLTRANSFORM": 512,  # Don't transform anyway
-    "HIGHRESPRECALC": 1024,  # Use more memory to give better accuracy
-    "LOWRESPRECALC": 2048,  # Use less memory to minimize resources
-    "WHITEBLACKCOMPENSATION": 8192,
-    "BLACKPOINTCOMPENSATION": 8192,
-    "GAMUTCHECK": 4096,  # Out of Gamut alarm
-    "SOFTPROOFING": 16384,  # Do softproofing
-    "PRESERVEBLACK": 32768,  # Black preservation
-    "NODEFAULTRESOURCEDEF": 16777216,  # CRD special
-    "GRIDPOINTS": lambda n: (n & 0xFF) << 16,  # Gridpoints
-}
-
-
-# --------------------------------------------------------------------.
-# Experimental PIL-level API
-# --------------------------------------------------------------------.
-
-##
-# Profile.
-
-
-class ImageCmsProfile:
-    def __init__(self, profile: str | SupportsRead[bytes] | core.CmsProfile) -> None:
-        """
-        :param profile: Either a string representing a filename,
-            a file like object containing a profile or a
-            low-level profile object
-
-        """
-        self.filename = None
-        self.product_name = None  # profile.product_name
-        self.product_info = None  # profile.product_info
-
-        if isinstance(profile, str):
-            if sys.platform == "win32":
-                profile_bytes_path = profile.encode()
-                try:
-                    profile_bytes_path.decode("ascii")
-                except UnicodeDecodeError:
-                    with open(profile, "rb") as f:
-                        self.profile = core.profile_frombytes(f.read())
-                    return
-            self.filename = profile
-            self.profile = core.profile_open(profile)
-        elif hasattr(profile, "read"):
-            self.profile = core.profile_frombytes(profile.read())
-        elif isinstance(profile, core.CmsProfile):
-            self.profile = profile
-        else:
-            msg = "Invalid type for Profile"  # type: ignore[unreachable]
-            raise TypeError(msg)
-
-    def tobytes(self) -> bytes:
-        """
-        Returns the profile in a format suitable for embedding in
-        saved images.
-
-        :returns: a bytes object containing the ICC profile.
-        """
-
-        return core.profile_tobytes(self.profile)
-
-
-class ImageCmsTransform(Image.ImagePointHandler):
-    """
-    Transform.  This can be used with the procedural API, or with the standard
-    :py:func:`~PIL.Image.Image.point` method.
-
-    Will return the output profile in the ``output.info['icc_profile']``.
-    """
-
-    def __init__(
-        self,
-        input: ImageCmsProfile,
-        output: ImageCmsProfile,
-        input_mode: str,
-        output_mode: str,
-        intent: Intent = Intent.PERCEPTUAL,
-        proof: ImageCmsProfile | None = None,
-        proof_intent: Intent = Intent.ABSOLUTE_COLORIMETRIC,
-        flags: Flags = Flags.NONE,
-    ):
-        supported_modes = (
-            "RGB",
-            "RGBA",
-            "RGBX",
-            "CMYK",
-            "I;16",
-            "I;16L",
-            "I;16B",
-            "YCbCr",
-            "LAB",
-            "L",
-            "1",
-        )
-        for mode in (input_mode, output_mode):
-            if mode not in supported_modes:
-                deprecate(
-                    mode,
-                    12,
-                    {
-                        "L;16": "I;16 or I;16L",
-                        "L:16B": "I;16B",
-                        "YCCA": "YCbCr",
-                        "YCC": "YCbCr",
-                    }.get(mode),
-                )
-        if proof is None:
-            self.transform = core.buildTransform(
-                input.profile, output.profile, input_mode, output_mode, intent, flags
-            )
-        else:
-            self.transform = core.buildProofTransform(
-                input.profile,
-                output.profile,
-                proof.profile,
-                input_mode,
-                output_mode,
-                intent,
-                proof_intent,
-                flags,
-            )
-        # Note: inputMode and outputMode are for pyCMS compatibility only
-        self.input_mode = self.inputMode = input_mode
-        self.output_mode = self.outputMode = output_mode
-
-        self.output_profile = output
-
-    def point(self, im: Image.Image) -> Image.Image:
-        return self.apply(im)
-
-    def apply(self, im: Image.Image, imOut: Image.Image | None = None) -> Image.Image:
-        if imOut is None:
-            imOut = Image.new(self.output_mode, im.size, None)
-        self.transform.apply(im.getim(), imOut.getim())
-        imOut.info["icc_profile"] = self.output_profile.tobytes()
-        return imOut
-
-    def apply_in_place(self, im: Image.Image) -> Image.Image:
-        if im.mode != self.output_mode:
-            msg = "mode mismatch"
-            raise ValueError(msg)  # wrong output mode
-        self.transform.apply(im.getim(), im.getim())
-        im.info["icc_profile"] = self.output_profile.tobytes()
-        return im
-
-
-def get_display_profile(handle: SupportsInt | None = None) -> ImageCmsProfile | None:
-    """
-    (experimental) Fetches the profile for the current display device.
-
-    :returns: ``None`` if the profile is not known.
-    """
-
-    if sys.platform != "win32":
-        return None
-
-    from . import ImageWin  # type: ignore[unused-ignore, unreachable]
-
-    if isinstance(handle, ImageWin.HDC):
-        profile = core.get_display_profile_win32(int(handle), 1)
-    else:
-        profile = core.get_display_profile_win32(int(handle or 0))
-    if profile is None:
-        return None
-    return ImageCmsProfile(profile)
-
-
-# --------------------------------------------------------------------.
-# pyCMS compatible layer
-# --------------------------------------------------------------------.
-
-
-class PyCMSError(Exception):
-    """(pyCMS) Exception class.
-    This is used for all errors in the pyCMS API."""
-
-    pass
-
-
-def profileToProfile(
-    im: Image.Image,
-    inputProfile: _CmsProfileCompatible,
-    outputProfile: _CmsProfileCompatible,
-    renderingIntent: Intent = Intent.PERCEPTUAL,
-    outputMode: str | None = None,
-    inPlace: bool = False,
-    flags: Flags = Flags.NONE,
-) -> Image.Image | None:
-    """
-    (pyCMS) Applies an ICC transformation to a given image, mapping from
-    ``inputProfile`` to ``outputProfile``.
-
-    If the input or output profiles specified are not valid filenames, a
-    :exc:`PyCMSError` will be raised.  If ``inPlace`` is ``True`` and
-    ``outputMode != im.mode``, a :exc:`PyCMSError` will be raised.
-    If an error occurs during application of the profiles,
-    a :exc:`PyCMSError` will be raised.
-    If ``outputMode`` is not a mode supported by the ``outputProfile`` (or by pyCMS),
-    a :exc:`PyCMSError` will be raised.
-
-    This function applies an ICC transformation to im from ``inputProfile``'s
-    color space to ``outputProfile``'s color space using the specified rendering
-    intent to decide how to handle out-of-gamut colors.
-
-    ``outputMode`` can be used to specify that a color mode conversion is to
-    be done using these profiles, but the specified profiles must be able
-    to handle that mode.  I.e., if converting im from RGB to CMYK using
-    profiles, the input profile must handle RGB data, and the output
-    profile must handle CMYK data.
-
-    :param im: An open :py:class:`~PIL.Image.Image` object (i.e. Image.new(...)
-        or Image.open(...), etc.)
-    :param inputProfile: String, as a valid filename path to the ICC input
-        profile you wish to use for this image, or a profile object
-    :param outputProfile: String, as a valid filename path to the ICC output
-        profile you wish to use for this image, or a profile object
-    :param renderingIntent: Integer (0-3) specifying the rendering intent you
-        wish to use for the transform
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-        they do.
-    :param outputMode: A valid PIL mode for the output image (i.e. "RGB",
-        "CMYK", etc.).  Note: if rendering the image "inPlace", outputMode
-        MUST be the same mode as the input, or omitted completely.  If
-        omitted, the outputMode will be the same as the mode of the input
-        image (im.mode)
-    :param inPlace: Boolean.  If ``True``, the original image is modified in-place,
-        and ``None`` is returned.  If ``False`` (default), a new
-        :py:class:`~PIL.Image.Image` object is returned with the transform applied.
-    :param flags: Integer (0-...) specifying additional flags
-    :returns: Either None or a new :py:class:`~PIL.Image.Image` object, depending on
-        the value of ``inPlace``
-    :exception PyCMSError:
-    """
-
-    if outputMode is None:
-        outputMode = im.mode
-
-    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
-        msg = "renderingIntent must be an integer between 0 and 3"
-        raise PyCMSError(msg)
-
-    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
-        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
-        raise PyCMSError(msg)
-
-    try:
-        if not isinstance(inputProfile, ImageCmsProfile):
-            inputProfile = ImageCmsProfile(inputProfile)
-        if not isinstance(outputProfile, ImageCmsProfile):
-            outputProfile = ImageCmsProfile(outputProfile)
-        transform = ImageCmsTransform(
-            inputProfile,
-            outputProfile,
-            im.mode,
-            outputMode,
-            renderingIntent,
-            flags=flags,
-        )
-        if inPlace:
-            transform.apply_in_place(im)
-            imOut = None
-        else:
-            imOut = transform.apply(im)
-    except (OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-    return imOut
-
-
-def getOpenProfile(
-    profileFilename: str | SupportsRead[bytes] | core.CmsProfile,
-) -> ImageCmsProfile:
-    """
-    (pyCMS) Opens an ICC profile file.
-
-    The PyCMSProfile object can be passed back into pyCMS for use in creating
-    transforms and such (as in ImageCms.buildTransformFromOpenProfiles()).
-
-    If ``profileFilename`` is not a valid filename for an ICC profile,
-    a :exc:`PyCMSError` will be raised.
-
-    :param profileFilename: String, as a valid filename path to the ICC profile
-        you wish to open, or a file-like object.
-    :returns: A CmsProfile class object.
-    :exception PyCMSError:
-    """
-
-    try:
-        return ImageCmsProfile(profileFilename)
-    except (OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def buildTransform(
-    inputProfile: _CmsProfileCompatible,
-    outputProfile: _CmsProfileCompatible,
-    inMode: str,
-    outMode: str,
-    renderingIntent: Intent = Intent.PERCEPTUAL,
-    flags: Flags = Flags.NONE,
-) -> ImageCmsTransform:
-    """
-    (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
-    ``outputProfile``. Use applyTransform to apply the transform to a given
-    image.
-
-    If the input or output profiles specified are not valid filenames, a
-    :exc:`PyCMSError` will be raised. If an error occurs during creation
-    of the transform, a :exc:`PyCMSError` will be raised.
-
-    If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
-    (or by pyCMS), a :exc:`PyCMSError` will be raised.
-
-    This function builds and returns an ICC transform from the ``inputProfile``
-    to the ``outputProfile`` using the ``renderingIntent`` to determine what to do
-    with out-of-gamut colors.  It will ONLY work for converting images that
-    are in ``inMode`` to images that are in ``outMode`` color format (PIL mode,
-    i.e. "RGB", "RGBA", "CMYK", etc.).
-
-    Building the transform is a fair part of the overhead in
-    ImageCms.profileToProfile(), so if you're planning on converting multiple
-    images using the same input/output settings, this can save you time.
-    Once you have a transform object, it can be used with
-    ImageCms.applyProfile() to convert images without the need to re-compute
-    the lookup table for the transform.
-
-    The reason pyCMS returns a class object rather than a handle directly
-    to the transform is that it needs to keep track of the PIL input/output
-    modes that the transform is meant for.  These attributes are stored in
-    the ``inMode`` and ``outMode`` attributes of the object (which can be
-    manually overridden if you really want to, but I don't know of any
-    time that would be of use, or would even work).
-
-    :param inputProfile: String, as a valid filename path to the ICC input
-        profile you wish to use for this transform, or a profile object
-    :param outputProfile: String, as a valid filename path to the ICC output
-        profile you wish to use for this transform, or a profile object
-    :param inMode: String, as a valid PIL mode that the appropriate profile
-        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
-    :param outMode: String, as a valid PIL mode that the appropriate profile
-        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
-    :param renderingIntent: Integer (0-3) specifying the rendering intent you
-        wish to use for the transform
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-        they do.
-    :param flags: Integer (0-...) specifying additional flags
-    :returns: A CmsTransform class object.
-    :exception PyCMSError:
-    """
-
-    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
-        msg = "renderingIntent must be an integer between 0 and 3"
-        raise PyCMSError(msg)
-
-    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
-        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
-        raise PyCMSError(msg)
-
-    try:
-        if not isinstance(inputProfile, ImageCmsProfile):
-            inputProfile = ImageCmsProfile(inputProfile)
-        if not isinstance(outputProfile, ImageCmsProfile):
-            outputProfile = ImageCmsProfile(outputProfile)
-        return ImageCmsTransform(
-            inputProfile, outputProfile, inMode, outMode, renderingIntent, flags=flags
-        )
-    except (OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def buildProofTransform(
-    inputProfile: _CmsProfileCompatible,
-    outputProfile: _CmsProfileCompatible,
-    proofProfile: _CmsProfileCompatible,
-    inMode: str,
-    outMode: str,
-    renderingIntent: Intent = Intent.PERCEPTUAL,
-    proofRenderingIntent: Intent = Intent.ABSOLUTE_COLORIMETRIC,
-    flags: Flags = Flags.SOFTPROOFING,
-) -> ImageCmsTransform:
-    """
-    (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
-    ``outputProfile``, but tries to simulate the result that would be
-    obtained on the ``proofProfile`` device.
-
-    If the input, output, or proof profiles specified are not valid
-    filenames, a :exc:`PyCMSError` will be raised.
-
-    If an error occurs during creation of the transform,
-    a :exc:`PyCMSError` will be raised.
-
-    If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
-    (or by pyCMS), a :exc:`PyCMSError` will be raised.
-
-    This function builds and returns an ICC transform from the ``inputProfile``
-    to the ``outputProfile``, but tries to simulate the result that would be
-    obtained on the ``proofProfile`` device using ``renderingIntent`` and
-    ``proofRenderingIntent`` to determine what to do with out-of-gamut
-    colors.  This is known as "soft-proofing".  It will ONLY work for
-    converting images that are in ``inMode`` to images that are in outMode
-    color format (PIL mode, i.e. "RGB", "RGBA", "CMYK", etc.).
-
-    Usage of the resulting transform object is exactly the same as with
-    ImageCms.buildTransform().
-
-    Proof profiling is generally used when using an output device to get a
-    good idea of what the final printed/displayed image would look like on
-    the ``proofProfile`` device when it's quicker and easier to use the
-    output device for judging color.  Generally, this means that the
-    output device is a monitor, or a dye-sub printer (etc.), and the simulated
-    device is something more expensive, complicated, or time consuming
-    (making it difficult to make a real print for color judgement purposes).
-
-    Soft-proofing basically functions by adjusting the colors on the
-    output device to match the colors of the device being simulated. However,
-    when the simulated device has a much wider gamut than the output
-    device, you may obtain marginal results.
-
-    :param inputProfile: String, as a valid filename path to the ICC input
-        profile you wish to use for this transform, or a profile object
-    :param outputProfile: String, as a valid filename path to the ICC output
-        (monitor, usually) profile you wish to use for this transform, or a
-        profile object
-    :param proofProfile: String, as a valid filename path to the ICC proof
-        profile you wish to use for this transform, or a profile object
-    :param inMode: String, as a valid PIL mode that the appropriate profile
-        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
-    :param outMode: String, as a valid PIL mode that the appropriate profile
-        also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
-    :param renderingIntent: Integer (0-3) specifying the rendering intent you
-        wish to use for the input->proof (simulated) transform
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-        they do.
-    :param proofRenderingIntent: Integer (0-3) specifying the rendering intent
-        you wish to use for proof->output transform
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-        they do.
-    :param flags: Integer (0-...) specifying additional flags
-    :returns: A CmsTransform class object.
-    :exception PyCMSError:
-    """
-
-    if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
-        msg = "renderingIntent must be an integer between 0 and 3"
-        raise PyCMSError(msg)
-
-    if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
-        msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
-        raise PyCMSError(msg)
-
-    try:
-        if not isinstance(inputProfile, ImageCmsProfile):
-            inputProfile = ImageCmsProfile(inputProfile)
-        if not isinstance(outputProfile, ImageCmsProfile):
-            outputProfile = ImageCmsProfile(outputProfile)
-        if not isinstance(proofProfile, ImageCmsProfile):
-            proofProfile = ImageCmsProfile(proofProfile)
-        return ImageCmsTransform(
-            inputProfile,
-            outputProfile,
-            inMode,
-            outMode,
-            renderingIntent,
-            proofProfile,
-            proofRenderingIntent,
-            flags,
-        )
-    except (OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-buildTransformFromOpenProfiles = buildTransform
-buildProofTransformFromOpenProfiles = buildProofTransform
-
-
-def applyTransform(
-    im: Image.Image, transform: ImageCmsTransform, inPlace: bool = False
-) -> Image.Image | None:
-    """
-    (pyCMS) Applies a transform to a given image.
-
-    If ``im.mode != transform.input_mode``, a :exc:`PyCMSError` is raised.
-
-    If ``inPlace`` is ``True`` and ``transform.input_mode != transform.output_mode``, a
-    :exc:`PyCMSError` is raised.
-
-    If ``im.mode``, ``transform.input_mode`` or ``transform.output_mode`` is not
-    supported by pyCMSdll or the profiles you used for the transform, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while the transform is being applied,
-    a :exc:`PyCMSError` is raised.
-
-    This function applies a pre-calculated transform (from
-    ImageCms.buildTransform() or ImageCms.buildTransformFromOpenProfiles())
-    to an image. The transform can be used for multiple images, saving
-    considerable calculation time if doing the same conversion multiple times.
-
-    If you want to modify im in-place instead of receiving a new image as
-    the return value, set ``inPlace`` to ``True``.  This can only be done if
-    ``transform.input_mode`` and ``transform.output_mode`` are the same, because we
-    can't change the mode in-place (the buffer sizes for some modes are
-    different).  The default behavior is to return a new :py:class:`~PIL.Image.Image`
-    object of the same dimensions in mode ``transform.output_mode``.
-
-    :param im: An :py:class:`~PIL.Image.Image` object, and ``im.mode`` must be the same
-        as the ``input_mode`` supported by the transform.
-    :param transform: A valid CmsTransform class object
-    :param inPlace: Bool.  If ``True``, ``im`` is modified in place and ``None`` is
-        returned, if ``False``, a new :py:class:`~PIL.Image.Image` object with the
-        transform applied is returned (and ``im`` is not changed). The default is
-        ``False``.
-    :returns: Either ``None``, or a new :py:class:`~PIL.Image.Image` object,
-        depending on the value of ``inPlace``. The profile will be returned in
-        the image's ``info['icc_profile']``.
-    :exception PyCMSError:
-    """
-
-    try:
-        if inPlace:
-            transform.apply_in_place(im)
-            imOut = None
-        else:
-            imOut = transform.apply(im)
-    except (TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-    return imOut
-
-
-def createProfile(
-    colorSpace: Literal["LAB", "XYZ", "sRGB"], colorTemp: SupportsFloat = 0
-) -> core.CmsProfile:
-    """
-    (pyCMS) Creates a profile.
-
-    If colorSpace not in ``["LAB", "XYZ", "sRGB"]``,
-    a :exc:`PyCMSError` is raised.
-
-    If using LAB and ``colorTemp`` is not a positive integer,
-    a :exc:`PyCMSError` is raised.
-
-    If an error occurs while creating the profile,
-    a :exc:`PyCMSError` is raised.
-
-    Use this function to create common profiles on-the-fly instead of
-    having to supply a profile on disk and knowing the path to it.  It
-    returns a normal CmsProfile object that can be passed to
-    ImageCms.buildTransformFromOpenProfiles() to create a transform to apply
-    to images.
-
-    :param colorSpace: String, the color space of the profile you wish to
-        create.
-        Currently only "LAB", "XYZ", and "sRGB" are supported.
-    :param colorTemp: Positive number for the white point for the profile, in
-        degrees Kelvin (i.e. 5000, 6500, 9600, etc.).  The default is for D50
-        illuminant if omitted (5000k).  colorTemp is ONLY applied to LAB
-        profiles, and is ignored for XYZ and sRGB.
-    :returns: A CmsProfile class object
-    :exception PyCMSError:
-    """
-
-    if colorSpace not in ["LAB", "XYZ", "sRGB"]:
-        msg = (
-            f"Color space not supported for on-the-fly profile creation ({colorSpace})"
-        )
-        raise PyCMSError(msg)
-
-    if colorSpace == "LAB":
-        try:
-            colorTemp = float(colorTemp)
-        except (TypeError, ValueError) as e:
-            msg = f'Color temperature must be numeric, "{colorTemp}" not valid'
-            raise PyCMSError(msg) from e
-
-    try:
-        return core.createProfile(colorSpace, colorTemp)
-    except (TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileName(profile: _CmsProfileCompatible) -> str:
-    """
-
-    (pyCMS) Gets the internal product name for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile,
-    a :exc:`PyCMSError` is raised If an error occurs while trying
-    to obtain the name tag, a :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the INTERNAL name of the profile (stored
-    in an ICC tag in the profile itself), usually the one used when the
-    profile was originally created.  Sometimes this tag also contains
-    additional information supplied by the creator.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal name of the profile as stored
-        in an ICC tag.
-    :exception PyCMSError:
-    """
-
-    try:
-        # add an extra newline to preserve pyCMS compatibility
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        # do it in python, not c.
-        #    // name was "%s - %s" (model, manufacturer) || Description ,
-        #    // but if the Model and Manufacturer were the same or the model
-        #    // was long, Just the model,  in 1.x
-        model = profile.profile.model
-        manufacturer = profile.profile.manufacturer
-
-        if not (model or manufacturer):
-            return (profile.profile.profile_description or "") + "\n"
-        if not manufacturer or (model and len(model) > 30):
-            return f"{model}\n"
-        return f"{model} - {manufacturer}\n"
-
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileInfo(profile: _CmsProfileCompatible) -> str:
-    """
-    (pyCMS) Gets the internal product information for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile,
-    a :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the info tag,
-    a :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the information stored in the profile's
-    info tag.  This often contains details about the profile, and how it
-    was created, as supplied by the creator.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal profile information stored in
-        an ICC tag.
-    :exception PyCMSError:
-    """
-
-    try:
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        # add an extra newline to preserve pyCMS compatibility
-        # Python, not C. the white point bits weren't working well,
-        # so skipping.
-        # info was description \r\n\r\n copyright \r\n\r\n K007 tag \r\n\r\n whitepoint
-        description = profile.profile.profile_description
-        cpright = profile.profile.copyright
-        elements = [element for element in (description, cpright) if element]
-        return "\r\n\r\n".join(elements) + "\r\n\r\n"
-
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileCopyright(profile: _CmsProfileCompatible) -> str:
-    """
-    (pyCMS) Gets the copyright for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the copyright tag,
-    a :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the information stored in the profile's
-    copyright tag.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal profile information stored in
-        an ICC tag.
-    :exception PyCMSError:
-    """
-    try:
-        # add an extra newline to preserve pyCMS compatibility
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        return (profile.profile.copyright or "") + "\n"
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileManufacturer(profile: _CmsProfileCompatible) -> str:
-    """
-    (pyCMS) Gets the manufacturer for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the manufacturer tag, a
-    :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the information stored in the profile's
-    manufacturer tag.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal profile information stored in
-        an ICC tag.
-    :exception PyCMSError:
-    """
-    try:
-        # add an extra newline to preserve pyCMS compatibility
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        return (profile.profile.manufacturer or "") + "\n"
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileModel(profile: _CmsProfileCompatible) -> str:
-    """
-    (pyCMS) Gets the model for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the model tag,
-    a :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the information stored in the profile's
-    model tag.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal profile information stored in
-        an ICC tag.
-    :exception PyCMSError:
-    """
-
-    try:
-        # add an extra newline to preserve pyCMS compatibility
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        return (profile.profile.model or "") + "\n"
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getProfileDescription(profile: _CmsProfileCompatible) -> str:
-    """
-    (pyCMS) Gets the description for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the description tag,
-    a :exc:`PyCMSError` is raised.
-
-    Use this function to obtain the information stored in the profile's
-    description tag.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: A string containing the internal profile information stored in an
-        ICC tag.
-    :exception PyCMSError:
-    """
-
-    try:
-        # add an extra newline to preserve pyCMS compatibility
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        return (profile.profile.profile_description or "") + "\n"
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def getDefaultIntent(profile: _CmsProfileCompatible) -> int:
-    """
-    (pyCMS) Gets the default intent name for the given profile.
-
-    If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
-    :exc:`PyCMSError` is raised.
-
-    If an error occurs while trying to obtain the default intent, a
-    :exc:`PyCMSError` is raised.
-
-    Use this function to determine the default (and usually best optimized)
-    rendering intent for this profile.  Most profiles support multiple
-    rendering intents, but are intended mostly for one type of conversion.
-    If you wish to use a different intent than returned, use
-    ImageCms.isIntentSupported() to verify it will work first.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :returns: Integer 0-3 specifying the default rendering intent for this
-        profile.
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-            they do.
-    :exception PyCMSError:
-    """
-
-    try:
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        return profile.profile.rendering_intent
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def isIntentSupported(
-    profile: _CmsProfileCompatible, intent: Intent, direction: Direction
-) -> Literal[-1, 1]:
-    """
-    (pyCMS) Checks if a given intent is supported.
-
-    Use this function to verify that you can use your desired
-    ``intent`` with ``profile``, and that ``profile`` can be used for the
-    input/output/proof profile as you desire.
-
-    Some profiles are created specifically for one "direction", can cannot
-    be used for others. Some profiles can only be used for certain
-    rendering intents, so it's best to either verify this before trying
-    to create a transform with them (using this function), or catch the
-    potential :exc:`PyCMSError` that will occur if they don't
-    support the modes you select.
-
-    :param profile: EITHER a valid CmsProfile object, OR a string of the
-        filename of an ICC profile.
-    :param intent: Integer (0-3) specifying the rendering intent you wish to
-        use with this profile
-
-            ImageCms.Intent.PERCEPTUAL            = 0 (DEFAULT)
-            ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
-            ImageCms.Intent.SATURATION            = 2
-            ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
-
-        see the pyCMS documentation for details on rendering intents and what
-            they do.
-    :param direction: Integer specifying if the profile is to be used for
-        input, output, or proof
-
-            INPUT  = 0 (or use ImageCms.Direction.INPUT)
-            OUTPUT = 1 (or use ImageCms.Direction.OUTPUT)
-            PROOF  = 2 (or use ImageCms.Direction.PROOF)
-
-    :returns: 1 if the intent/direction are supported, -1 if they are not.
-    :exception PyCMSError:
-    """
-
-    try:
-        if not isinstance(profile, ImageCmsProfile):
-            profile = ImageCmsProfile(profile)
-        # FIXME: I get different results for the same data w. different
-        # compilers.  Bug in LittleCMS or in the binding?
-        if profile.profile.is_intent_supported(intent, direction):
-            return 1
-        else:
-            return -1
-    except (AttributeError, OSError, TypeError, ValueError) as v:
-        raise PyCMSError(v) from v
-
-
-def versions() -> tuple[str, str | None, str, str]:
-    """
-    (pyCMS) Fetches versions.
-    """
-
-    deprecate(
-        "PIL.ImageCms.versions()",
-        12,
-        '(PIL.features.version("littlecms2"), sys.version, PIL.__version__)',
-    )
-    return _VERSION, core.littlecms_version, sys.version.split()[0], __version__

.venv/lib/python3.11/site-packages/PIL/ImageColor.py

@@ -1,320 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# map CSS3-style colour description strings to RGB
-#
-# History:
-# 2002-10-24 fl   Added support for CSS-style color strings
-# 2002-12-15 fl   Added RGBA support
-# 2004-03-27 fl   Fixed remaining int() problems for Python 1.5.2
-# 2004-07-19 fl   Fixed gray/grey spelling issues
-# 2009-03-05 fl   Fixed rounding error in grayscale calculation
-#
-# Copyright (c) 2002-2004 by Secret Labs AB
-# Copyright (c) 2002-2004 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-from __future__ import annotations
-
-import re
-from functools import lru_cache
-
-from . import Image
-
-
-@lru_cache
-def getrgb(color: str) -> tuple[int, int, int] | tuple[int, int, int, int]:
-    """
-     Convert a color string to an RGB or RGBA tuple. If the string cannot be
-     parsed, this function raises a :py:exc:`ValueError` exception.
-
-    .. versionadded:: 1.1.4
-
-    :param color: A color string
-    :return: ``(red, green, blue[, alpha])``
-    """
-    if len(color) > 100:
-        msg = "color specifier is too long"
-        raise ValueError(msg)
-    color = color.lower()
-
-    rgb = colormap.get(color, None)
-    if rgb:
-        if isinstance(rgb, tuple):
-            return rgb
-        rgb_tuple = getrgb(rgb)
-        assert len(rgb_tuple) == 3
-        colormap[color] = rgb_tuple
-        return rgb_tuple
-
-    # check for known string formats
-    if re.match("#[a-f0-9]{3}$", color):
-        return int(color[1] * 2, 16), int(color[2] * 2, 16), int(color[3] * 2, 16)
-
-    if re.match("#[a-f0-9]{4}$", color):
-        return (
-            int(color[1] * 2, 16),
-            int(color[2] * 2, 16),
-            int(color[3] * 2, 16),
-            int(color[4] * 2, 16),
-        )
-
-    if re.match("#[a-f0-9]{6}$", color):
-        return int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
-
-    if re.match("#[a-f0-9]{8}$", color):
-        return (
-            int(color[1:3], 16),
-            int(color[3:5], 16),
-            int(color[5:7], 16),
-            int(color[7:9], 16),
-        )
-
-    m = re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
-    if m:
-        return int(m.group(1)), int(m.group(2)), int(m.group(3))
-
-    m = re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color)
-    if m:
-        return (
-            int((int(m.group(1)) * 255) / 100.0 + 0.5),
-            int((int(m.group(2)) * 255) / 100.0 + 0.5),
-            int((int(m.group(3)) * 255) / 100.0 + 0.5),
-        )
-
-    m = re.match(
-        r"hsl\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
-    )
-    if m:
-        from colorsys import hls_to_rgb
-
-        rgb_floats = hls_to_rgb(
-            float(m.group(1)) / 360.0,
-            float(m.group(3)) / 100.0,
-            float(m.group(2)) / 100.0,
-        )
-        return (
-            int(rgb_floats[0] * 255 + 0.5),
-            int(rgb_floats[1] * 255 + 0.5),
-            int(rgb_floats[2] * 255 + 0.5),
-        )
-
-    m = re.match(
-        r"hs[bv]\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
-    )
-    if m:
-        from colorsys import hsv_to_rgb
-
-        rgb_floats = hsv_to_rgb(
-            float(m.group(1)) / 360.0,
-            float(m.group(2)) / 100.0,
-            float(m.group(3)) / 100.0,
-        )
-        return (
-            int(rgb_floats[0] * 255 + 0.5),
-            int(rgb_floats[1] * 255 + 0.5),
-            int(rgb_floats[2] * 255 + 0.5),
-        )
-
-    m = re.match(r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
-    if m:
-        return int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
-    msg = f"unknown color specifier: {repr(color)}"
-    raise ValueError(msg)
-
-
-@lru_cache
-def getcolor(color: str, mode: str) -> int | tuple[int, ...]:
-    """
-    Same as :py:func:`~PIL.ImageColor.getrgb` for most modes. However, if
-    ``mode`` is HSV, converts the RGB value to a HSV value, or if ``mode`` is
-    not color or a palette image, converts the RGB value to a grayscale value.
-    If the string cannot be parsed, this function raises a :py:exc:`ValueError`
-    exception.
-
-    .. versionadded:: 1.1.4
-
-    :param color: A color string
-    :param mode: Convert result to this mode
-    :return: ``graylevel, (graylevel, alpha) or (red, green, blue[, alpha])``
-    """
-    # same as getrgb, but converts the result to the given mode
-    rgb, alpha = getrgb(color), 255
-    if len(rgb) == 4:
-        alpha = rgb[3]
-        rgb = rgb[:3]
-
-    if mode == "HSV":
-        from colorsys import rgb_to_hsv
-
-        r, g, b = rgb
-        h, s, v = rgb_to_hsv(r / 255, g / 255, b / 255)
-        return int(h * 255), int(s * 255), int(v * 255)
-    elif Image.getmodebase(mode) == "L":
-        r, g, b = rgb
-        # ITU-R Recommendation 601-2 for nonlinear RGB
-        # scaled to 24 bits to match the convert's implementation.
-        graylevel = (r * 19595 + g * 38470 + b * 7471 + 0x8000) >> 16
-        if mode[-1] == "A":
-            return graylevel, alpha
-        return graylevel
-    elif mode[-1] == "A":
-        return rgb + (alpha,)
-    return rgb
-
-
-colormap: dict[str, str | tuple[int, int, int]] = {
-    # X11 colour table from https://drafts.csswg.org/css-color-4/, with
-    # gray/grey spelling issues fixed.  This is a superset of HTML 4.0
-    # colour names used in CSS 1.
-    "aliceblue": "#f0f8ff",
-    "antiquewhite": "#faebd7",
-    "aqua": "#00ffff",
-    "aquamarine": "#7fffd4",
-    "azure": "#f0ffff",
-    "beige": "#f5f5dc",
-    "bisque": "#ffe4c4",
-    "black": "#000000",
-    "blanchedalmond": "#ffebcd",
-    "blue": "#0000ff",
-    "blueviolet": "#8a2be2",
-    "brown": "#a52a2a",
-    "burlywood": "#deb887",
-    "cadetblue": "#5f9ea0",
-    "chartreuse": "#7fff00",
-    "chocolate": "#d2691e",
-    "coral": "#ff7f50",
-    "cornflowerblue": "#6495ed",
-    "cornsilk": "#fff8dc",
-    "crimson": "#dc143c",
-    "cyan": "#00ffff",
-    "darkblue": "#00008b",
-    "darkcyan": "#008b8b",
-    "darkgoldenrod": "#b8860b",
-    "darkgray": "#a9a9a9",
-    "darkgrey": "#a9a9a9",
-    "darkgreen": "#006400",
-    "darkkhaki": "#bdb76b",
-    "darkmagenta": "#8b008b",
-    "darkolivegreen": "#556b2f",
-    "darkorange": "#ff8c00",
-    "darkorchid": "#9932cc",
-    "darkred": "#8b0000",
-    "darksalmon": "#e9967a",
-    "darkseagreen": "#8fbc8f",
-    "darkslateblue": "#483d8b",
-    "darkslategray": "#2f4f4f",
-    "darkslategrey": "#2f4f4f",
-    "darkturquoise": "#00ced1",
-    "darkviolet": "#9400d3",
-    "deeppink": "#ff1493",
-    "deepskyblue": "#00bfff",
-    "dimgray": "#696969",
-    "dimgrey": "#696969",
-    "dodgerblue": "#1e90ff",
-    "firebrick": "#b22222",
-    "floralwhite": "#fffaf0",
-    "forestgreen": "#228b22",
-    "fuchsia": "#ff00ff",
-    "gainsboro": "#dcdcdc",
-    "ghostwhite": "#f8f8ff",
-    "gold": "#ffd700",
-    "goldenrod": "#daa520",
-    "gray": "#808080",
-    "grey": "#808080",
-    "green": "#008000",
-    "greenyellow": "#adff2f",
-    "honeydew": "#f0fff0",
-    "hotpink": "#ff69b4",
-    "indianred": "#cd5c5c",
-    "indigo": "#4b0082",
-    "ivory": "#fffff0",
-    "khaki": "#f0e68c",
-    "lavender": "#e6e6fa",
-    "lavenderblush": "#fff0f5",
-    "lawngreen": "#7cfc00",
-    "lemonchiffon": "#fffacd",
-    "lightblue": "#add8e6",
-    "lightcoral": "#f08080",
-    "lightcyan": "#e0ffff",
-    "lightgoldenrodyellow": "#fafad2",
-    "lightgreen": "#90ee90",
-    "lightgray": "#d3d3d3",
-    "lightgrey": "#d3d3d3",
-    "lightpink": "#ffb6c1",
-    "lightsalmon": "#ffa07a",
-    "lightseagreen": "#20b2aa",
-    "lightskyblue": "#87cefa",
-    "lightslategray": "#778899",
-    "lightslategrey": "#778899",
-    "lightsteelblue": "#b0c4de",
-    "lightyellow": "#ffffe0",
-    "lime": "#00ff00",
-    "limegreen": "#32cd32",
-    "linen": "#faf0e6",
-    "magenta": "#ff00ff",
-    "maroon": "#800000",
-    "mediumaquamarine": "#66cdaa",
-    "mediumblue": "#0000cd",
-    "mediumorchid": "#ba55d3",
-    "mediumpurple": "#9370db",
-    "mediumseagreen": "#3cb371",
-    "mediumslateblue": "#7b68ee",
-    "mediumspringgreen": "#00fa9a",
-    "mediumturquoise": "#48d1cc",
-    "mediumvioletred": "#c71585",
-    "midnightblue": "#191970",
-    "mintcream": "#f5fffa",
-    "mistyrose": "#ffe4e1",
-    "moccasin": "#ffe4b5",
-    "navajowhite": "#ffdead",
-    "navy": "#000080",
-    "oldlace": "#fdf5e6",
-    "olive": "#808000",
-    "olivedrab": "#6b8e23",
-    "orange": "#ffa500",
-    "orangered": "#ff4500",
-    "orchid": "#da70d6",
-    "palegoldenrod": "#eee8aa",
-    "palegreen": "#98fb98",
-    "paleturquoise": "#afeeee",
-    "palevioletred": "#db7093",
-    "papayawhip": "#ffefd5",
-    "peachpuff": "#ffdab9",
-    "peru": "#cd853f",
-    "pink": "#ffc0cb",
-    "plum": "#dda0dd",
-    "powderblue": "#b0e0e6",
-    "purple": "#800080",
-    "rebeccapurple": "#663399",
-    "red": "#ff0000",
-    "rosybrown": "#bc8f8f",
-    "royalblue": "#4169e1",
-    "saddlebrown": "#8b4513",
-    "salmon": "#fa8072",
-    "sandybrown": "#f4a460",
-    "seagreen": "#2e8b57",
-    "seashell": "#fff5ee",
-    "sienna": "#a0522d",
-    "silver": "#c0c0c0",
-    "skyblue": "#87ceeb",
-    "slateblue": "#6a5acd",
-    "slategray": "#708090",
-    "slategrey": "#708090",
-    "snow": "#fffafa",
-    "springgreen": "#00ff7f",
-    "steelblue": "#4682b4",
-    "tan": "#d2b48c",
-    "teal": "#008080",
-    "thistle": "#d8bfd8",
-    "tomato": "#ff6347",
-    "turquoise": "#40e0d0",
-    "violet": "#ee82ee",
-    "wheat": "#f5deb3",
-    "white": "#ffffff",
-    "whitesmoke": "#f5f5f5",
-    "yellow": "#ffff00",
-    "yellowgreen": "#9acd32",
-}

.venv/lib/python3.11/site-packages/PIL/ImageDraw.py

@@ -1,1232 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# drawing interface operations
-#
-# History:
-# 1996-04-13 fl   Created (experimental)
-# 1996-08-07 fl   Filled polygons, ellipses.
-# 1996-08-13 fl   Added text support
-# 1998-06-28 fl   Handle I and F images
-# 1998-12-29 fl   Added arc; use arc primitive to draw ellipses
-# 1999-01-10 fl   Added shape stuff (experimental)
-# 1999-02-06 fl   Added bitmap support
-# 1999-02-11 fl   Changed all primitives to take options
-# 1999-02-20 fl   Fixed backwards compatibility
-# 2000-10-12 fl   Copy on write, when necessary
-# 2001-02-18 fl   Use default ink for bitmap/text also in fill mode
-# 2002-10-24 fl   Added support for CSS-style color strings
-# 2002-12-10 fl   Added experimental support for RGBA-on-RGB drawing
-# 2002-12-11 fl   Refactored low-level drawing API (work in progress)
-# 2004-08-26 fl   Made Draw() a factory function, added getdraw() support
-# 2004-09-04 fl   Added width support to line primitive
-# 2004-09-10 fl   Added font mode handling
-# 2006-06-19 fl   Added font bearing support (getmask2)
-#
-# Copyright (c) 1997-2006 by Secret Labs AB
-# Copyright (c) 1996-2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-from __future__ import annotations
-
-import math
-import struct
-from collections.abc import Sequence
-from types import ModuleType
-from typing import Any, AnyStr, Callable, Union, cast
-
-from . import Image, ImageColor
-from ._deprecate import deprecate
-from ._typing import Coords
-
-# experimental access to the outline API
-Outline: Callable[[], Image.core._Outline] = Image.core.outline
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from . import ImageDraw2, ImageFont
-
-_Ink = Union[float, tuple[int, ...], str]
-
-"""
-A simple 2D drawing interface for PIL images.
-<p>
-Application code should use the <b>Draw</b> factory, instead of
-directly.
-"""
-
-
-class ImageDraw:
-    font: (
-        ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont | None
-    ) = None
-
-    def __init__(self, im: Image.Image, mode: str | None = None) -> None:
-        """
-        Create a drawing instance.
-
-        :param im: The image to draw in.
-        :param mode: Optional mode to use for color values.  For RGB
-           images, this argument can be RGB or RGBA (to blend the
-           drawing into the image).  For all other modes, this argument
-           must be the same as the image mode.  If omitted, the mode
-           defaults to the mode of the image.
-        """
-        im.load()
-        if im.readonly:
-            im._copy()  # make it writeable
-        blend = 0
-        if mode is None:
-            mode = im.mode
-        if mode != im.mode:
-            if mode == "RGBA" and im.mode == "RGB":
-                blend = 1
-            else:
-                msg = "mode mismatch"
-                raise ValueError(msg)
-        if mode == "P":
-            self.palette = im.palette
-        else:
-            self.palette = None
-        self._image = im
-        self.im = im.im
-        self.draw = Image.core.draw(self.im, blend)
-        self.mode = mode
-        if mode in ("I", "F"):
-            self.ink = self.draw.draw_ink(1)
-        else:
-            self.ink = self.draw.draw_ink(-1)
-        if mode in ("1", "P", "I", "F"):
-            # FIXME: fix Fill2 to properly support matte for I+F images
-            self.fontmode = "1"
-        else:
-            self.fontmode = "L"  # aliasing is okay for other modes
-        self.fill = False
-
-    def getfont(
-        self,
-    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
-        """
-        Get the current default font.
-
-        To set the default font for this ImageDraw instance::
-
-            from PIL import ImageDraw, ImageFont
-            draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        To set the default font for all future ImageDraw instances::
-
-            from PIL import ImageDraw, ImageFont
-            ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
-
-        If the current default font is ``None``,
-        it is initialized with ``ImageFont.load_default()``.
-
-        :returns: An image font."""
-        if not self.font:
-            # FIXME: should add a font repository
-            from . import ImageFont
-
-            self.font = ImageFont.load_default()
-        return self.font
-
-    def _getfont(
-        self, font_size: float | None
-    ) -> ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont:
-        if font_size is not None:
-            from . import ImageFont
-
-            return ImageFont.load_default(font_size)
-        else:
-            return self.getfont()
-
-    def _getink(
-        self, ink: _Ink | None, fill: _Ink | None = None
-    ) -> tuple[int | None, int | None]:
-        result_ink = None
-        result_fill = None
-        if ink is None and fill is None:
-            if self.fill:
-                result_fill = self.ink
-            else:
-                result_ink = self.ink
-        else:
-            if ink is not None:
-                if isinstance(ink, str):
-                    ink = ImageColor.getcolor(ink, self.mode)
-                if self.palette and isinstance(ink, tuple):
-                    ink = self.palette.getcolor(ink, self._image)
-                result_ink = self.draw.draw_ink(ink)
-            if fill is not None:
-                if isinstance(fill, str):
-                    fill = ImageColor.getcolor(fill, self.mode)
-                if self.palette and isinstance(fill, tuple):
-                    fill = self.palette.getcolor(fill, self._image)
-                result_fill = self.draw.draw_ink(fill)
-        return result_ink, result_fill
-
-    def arc(
-        self,
-        xy: Coords,
-        start: float,
-        end: float,
-        fill: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw an arc."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_arc(xy, start, end, ink, width)
-
-    def bitmap(
-        self, xy: Sequence[int], bitmap: Image.Image, fill: _Ink | None = None
-    ) -> None:
-        """Draw a bitmap."""
-        bitmap.load()
-        ink, fill = self._getink(fill)
-        if ink is None:
-            ink = fill
-        if ink is not None:
-            self.draw.draw_bitmap(xy, bitmap.im, ink)
-
-    def chord(
-        self,
-        xy: Coords,
-        start: float,
-        end: float,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a chord."""
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_chord(xy, start, end, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            self.draw.draw_chord(xy, start, end, ink, 0, width)
-
-    def ellipse(
-        self,
-        xy: Coords,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw an ellipse."""
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_ellipse(xy, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            self.draw.draw_ellipse(xy, ink, 0, width)
-
-    def circle(
-        self,
-        xy: Sequence[float],
-        radius: float,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a circle given center coordinates and a radius."""
-        ellipse_xy = (xy[0] - radius, xy[1] - radius, xy[0] + radius, xy[1] + radius)
-        self.ellipse(ellipse_xy, fill, outline, width)
-
-    def line(
-        self,
-        xy: Coords,
-        fill: _Ink | None = None,
-        width: int = 0,
-        joint: str | None = None,
-    ) -> None:
-        """Draw a line, or a connected sequence of line segments."""
-        ink = self._getink(fill)[0]
-        if ink is not None:
-            self.draw.draw_lines(xy, ink, width)
-            if joint == "curve" and width > 4:
-                points: Sequence[Sequence[float]]
-                if isinstance(xy[0], (list, tuple)):
-                    points = cast(Sequence[Sequence[float]], xy)
-                else:
-                    points = [
-                        cast(Sequence[float], tuple(xy[i : i + 2]))
-                        for i in range(0, len(xy), 2)
-                    ]
-                for i in range(1, len(points) - 1):
-                    point = points[i]
-                    angles = [
-                        math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
-                        % 360
-                        for start, end in (
-                            (points[i - 1], point),
-                            (point, points[i + 1]),
-                        )
-                    ]
-                    if angles[0] == angles[1]:
-                        # This is a straight line, so no joint is required
-                        continue
-
-                    def coord_at_angle(
-                        coord: Sequence[float], angle: float
-                    ) -> tuple[float, ...]:
-                        x, y = coord
-                        angle -= 90
-                        distance = width / 2 - 1
-                        return tuple(
-                            p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
-                            for p, p_d in (
-                                (x, distance * math.cos(math.radians(angle))),
-                                (y, distance * math.sin(math.radians(angle))),
-                            )
-                        )
-
-                    flipped = (
-                        angles[1] > angles[0] and angles[1] - 180 > angles[0]
-                    ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
-                    coords = [
-                        (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
-                        (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
-                    ]
-                    if flipped:
-                        start, end = (angles[1] + 90, angles[0] + 90)
-                    else:
-                        start, end = (angles[0] - 90, angles[1] - 90)
-                    self.pieslice(coords, start - 90, end - 90, fill)
-
-                    if width > 8:
-                        # Cover potential gaps between the line and the joint
-                        if flipped:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] + 90),
-                                point,
-                                coord_at_angle(point, angles[1] + 90),
-                            ]
-                        else:
-                            gap_coords = [
-                                coord_at_angle(point, angles[0] - 90),
-                                point,
-                                coord_at_angle(point, angles[1] - 90),
-                            ]
-                        self.line(gap_coords, fill, width=3)
-
-    def shape(
-        self,
-        shape: Image.core._Outline,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-    ) -> None:
-        """(Experimental) Draw a shape."""
-        shape.close()
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_outline(shape, fill_ink, 1)
-        if ink is not None and ink != fill_ink:
-            self.draw.draw_outline(shape, ink, 0)
-
-    def pieslice(
-        self,
-        xy: Coords,
-        start: float,
-        end: float,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a pieslice."""
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_pieslice(xy, start, end, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            self.draw.draw_pieslice(xy, start, end, ink, 0, width)
-
-    def point(self, xy: Coords, fill: _Ink | None = None) -> None:
-        """Draw one or more individual pixels."""
-        ink, fill = self._getink(fill)
-        if ink is not None:
-            self.draw.draw_points(xy, ink)
-
-    def polygon(
-        self,
-        xy: Coords,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a polygon."""
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_polygon(xy, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            if width == 1:
-                self.draw.draw_polygon(xy, ink, 0, width)
-            elif self.im is not None:
-                # To avoid expanding the polygon outwards,
-                # use the fill as a mask
-                mask = Image.new("1", self.im.size)
-                mask_ink = self._getink(1)[0]
-                draw = Draw(mask)
-                draw.draw.draw_polygon(xy, mask_ink, 1)
-
-                self.draw.draw_polygon(xy, ink, 0, width * 2 - 1, mask.im)
-
-    def regular_polygon(
-        self,
-        bounding_circle: Sequence[Sequence[float] | float],
-        n_sides: int,
-        rotation: float = 0,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a regular polygon."""
-        xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
-        self.polygon(xy, fill, outline, width)
-
-    def rectangle(
-        self,
-        xy: Coords,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-    ) -> None:
-        """Draw a rectangle."""
-        ink, fill_ink = self._getink(outline, fill)
-        if fill_ink is not None:
-            self.draw.draw_rectangle(xy, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            self.draw.draw_rectangle(xy, ink, 0, width)
-
-    def rounded_rectangle(
-        self,
-        xy: Coords,
-        radius: float = 0,
-        fill: _Ink | None = None,
-        outline: _Ink | None = None,
-        width: int = 1,
-        *,
-        corners: tuple[bool, bool, bool, bool] | None = None,
-    ) -> None:
-        """Draw a rounded rectangle."""
-        if isinstance(xy[0], (list, tuple)):
-            (x0, y0), (x1, y1) = cast(Sequence[Sequence[float]], xy)
-        else:
-            x0, y0, x1, y1 = cast(Sequence[float], xy)
-        if x1 < x0:
-            msg = "x1 must be greater than or equal to x0"
-            raise ValueError(msg)
-        if y1 < y0:
-            msg = "y1 must be greater than or equal to y0"
-            raise ValueError(msg)
-        if corners is None:
-            corners = (True, True, True, True)
-
-        d = radius * 2
-
-        x0 = round(x0)
-        y0 = round(y0)
-        x1 = round(x1)
-        y1 = round(y1)
-        full_x, full_y = False, False
-        if all(corners):
-            full_x = d >= x1 - x0 - 1
-            if full_x:
-                # The two left and two right corners are joined
-                d = x1 - x0
-            full_y = d >= y1 - y0 - 1
-            if full_y:
-                # The two top and two bottom corners are joined
-                d = y1 - y0
-            if full_x and full_y:
-                # If all corners are joined, that is a circle
-                return self.ellipse(xy, fill, outline, width)
-
-        if d == 0 or not any(corners):
-            # If the corners have no curve,
-            # or there are no corners,
-            # that is a rectangle
-            return self.rectangle(xy, fill, outline, width)
-
-        r = int(d // 2)
-        ink, fill_ink = self._getink(outline, fill)
-
-        def draw_corners(pieslice: bool) -> None:
-            parts: tuple[tuple[tuple[float, float, float, float], int, int], ...]
-            if full_x:
-                # Draw top and bottom halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 180, 360),
-                    ((x0, y1 - d, x0 + d, y1), 0, 180),
-                )
-            elif full_y:
-                # Draw left and right halves
-                parts = (
-                    ((x0, y0, x0 + d, y0 + d), 90, 270),
-                    ((x1 - d, y0, x1, y0 + d), 270, 90),
-                )
-            else:
-                # Draw four separate corners
-                parts = tuple(
-                    part
-                    for i, part in enumerate(
-                        (
-                            ((x0, y0, x0 + d, y0 + d), 180, 270),
-                            ((x1 - d, y0, x1, y0 + d), 270, 360),
-                            ((x1 - d, y1 - d, x1, y1), 0, 90),
-                            ((x0, y1 - d, x0 + d, y1), 90, 180),
-                        )
-                    )
-                    if corners[i]
-                )
-            for part in parts:
-                if pieslice:
-                    self.draw.draw_pieslice(*(part + (fill_ink, 1)))
-                else:
-                    self.draw.draw_arc(*(part + (ink, width)))
-
-        if fill_ink is not None:
-            draw_corners(True)
-
-            if full_x:
-                self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill_ink, 1)
-            elif x1 - r - 1 > x0 + r + 1:
-                self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill_ink, 1)
-            if not full_x and not full_y:
-                left = [x0, y0, x0 + r, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, fill_ink, 1)
-
-                right = [x1 - r, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, fill_ink, 1)
-        if ink is not None and ink != fill_ink and width != 0:
-            draw_corners(False)
-
-            if not full_x:
-                top = [x0, y0, x1, y0 + width - 1]
-                if corners[0]:
-                    top[0] += r + 1
-                if corners[1]:
-                    top[2] -= r + 1
-                self.draw.draw_rectangle(top, ink, 1)
-
-                bottom = [x0, y1 - width + 1, x1, y1]
-                if corners[3]:
-                    bottom[0] += r + 1
-                if corners[2]:
-                    bottom[2] -= r + 1
-                self.draw.draw_rectangle(bottom, ink, 1)
-            if not full_y:
-                left = [x0, y0, x0 + width - 1, y1]
-                if corners[0]:
-                    left[1] += r + 1
-                if corners[3]:
-                    left[3] -= r + 1
-                self.draw.draw_rectangle(left, ink, 1)
-
-                right = [x1 - width + 1, y0, x1, y1]
-                if corners[1]:
-                    right[1] += r + 1
-                if corners[2]:
-                    right[3] -= r + 1
-                self.draw.draw_rectangle(right, ink, 1)
-
-    def _multiline_check(self, text: AnyStr) -> bool:
-        split_character = "\n" if isinstance(text, str) else b"\n"
-
-        return split_character in text
-
-    def text(
-        self,
-        xy: tuple[float, float],
-        text: AnyStr,
-        fill: _Ink | None = None,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ) = None,
-        anchor: str | None = None,
-        spacing: float = 4,
-        align: str = "left",
-        direction: str | None = None,
-        features: list[str] | None = None,
-        language: str | None = None,
-        stroke_width: float = 0,
-        stroke_fill: _Ink | None = None,
-        embedded_color: bool = False,
-        *args: Any,
-        **kwargs: Any,
-    ) -> None:
-        """Draw text."""
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self._getfont(kwargs.get("font_size"))
-
-        if self._multiline_check(text):
-            return self.multiline_text(
-                xy,
-                text,
-                fill,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                stroke_fill,
-                embedded_color,
-            )
-
-        def getink(fill: _Ink | None) -> int:
-            ink, fill_ink = self._getink(fill)
-            if ink is None:
-                assert fill_ink is not None
-                return fill_ink
-            return ink
-
-        def draw_text(ink: int, stroke_width: float = 0) -> None:
-            mode = self.fontmode
-            if stroke_width == 0 and embedded_color:
-                mode = "RGBA"
-            coord = []
-            for i in range(2):
-                coord.append(int(xy[i]))
-            start = (math.modf(xy[0])[0], math.modf(xy[1])[0])
-            try:
-                mask, offset = font.getmask2(  # type: ignore[union-attr,misc]
-                    text,
-                    mode,
-                    direction=direction,
-                    features=features,
-                    language=language,
-                    stroke_width=stroke_width,
-                    stroke_filled=True,
-                    anchor=anchor,
-                    ink=ink,
-                    start=start,
-                    *args,
-                    **kwargs,
-                )
-                coord = [coord[0] + offset[0], coord[1] + offset[1]]
-            except AttributeError:
-                try:
-                    mask = font.getmask(  # type: ignore[misc]
-                        text,
-                        mode,
-                        direction,
-                        features,
-                        language,
-                        stroke_width,
-                        anchor,
-                        ink,
-                        start=start,
-                        *args,
-                        **kwargs,
-                    )
-                except TypeError:
-                    mask = font.getmask(text)
-            if mode == "RGBA":
-                # font.getmask2(mode="RGBA") returns color in RGB bands and mask in A
-                # extract mask and set text alpha
-                color, mask = mask, mask.getband(3)
-                ink_alpha = struct.pack("i", ink)[3]
-                color.fillband(3, ink_alpha)
-                x, y = coord
-                if self.im is not None:
-                    self.im.paste(
-                        color, (x, y, x + mask.size[0], y + mask.size[1]), mask
-                    )
-            else:
-                self.draw.draw_bitmap(coord, mask, ink)
-
-        ink = getink(fill)
-        if ink is not None:
-            stroke_ink = None
-            if stroke_width:
-                stroke_ink = getink(stroke_fill) if stroke_fill is not None else ink
-
-            if stroke_ink is not None:
-                # Draw stroked text
-                draw_text(stroke_ink, stroke_width)
-
-                # Draw normal text
-                if ink != stroke_ink:
-                    draw_text(ink)
-            else:
-                # Only draw normal text
-                draw_text(ink)
-
-    def _prepare_multiline_text(
-        self,
-        xy: tuple[float, float],
-        text: AnyStr,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ),
-        anchor: str | None,
-        spacing: float,
-        align: str,
-        direction: str | None,
-        features: list[str] | None,
-        language: str | None,
-        stroke_width: float,
-        embedded_color: bool,
-        font_size: float | None,
-    ) -> tuple[
-        ImageFont.ImageFont | ImageFont.FreeTypeFont | ImageFont.TransposedFont,
-        list[tuple[tuple[float, float], str, AnyStr]],
-    ]:
-        if anchor is None:
-            anchor = "lt" if direction == "ttb" else "la"
-        elif len(anchor) != 2:
-            msg = "anchor must be a 2 character string"
-            raise ValueError(msg)
-        elif anchor[1] in "tb" and direction != "ttb":
-            msg = "anchor not supported for multiline text"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self._getfont(font_size)
-
-        lines = text.split("\n" if isinstance(text, str) else b"\n")
-        line_spacing = (
-            self.textbbox((0, 0), "A", font, stroke_width=stroke_width)[3]
-            + stroke_width
-            + spacing
-        )
-
-        top = xy[1]
-        parts = []
-        if direction == "ttb":
-            left = xy[0]
-            for line in lines:
-                parts.append(((left, top), anchor, line))
-                left += line_spacing
-        else:
-            widths = []
-            max_width: float = 0
-            for line in lines:
-                line_width = self.textlength(
-                    line,
-                    font,
-                    direction=direction,
-                    features=features,
-                    language=language,
-                    embedded_color=embedded_color,
-                )
-                widths.append(line_width)
-                max_width = max(max_width, line_width)
-
-            if anchor[1] == "m":
-                top -= (len(lines) - 1) * line_spacing / 2.0
-            elif anchor[1] == "d":
-                top -= (len(lines) - 1) * line_spacing
-
-            for idx, line in enumerate(lines):
-                left = xy[0]
-                width_difference = max_width - widths[idx]
-
-                # align by align parameter
-                if align in ("left", "justify"):
-                    pass
-                elif align == "center":
-                    left += width_difference / 2.0
-                elif align == "right":
-                    left += width_difference
-                else:
-                    msg = 'align must be "left", "center", "right" or "justify"'
-                    raise ValueError(msg)
-
-                if (
-                    align == "justify"
-                    and width_difference != 0
-                    and idx != len(lines) - 1
-                ):
-                    words = line.split(" " if isinstance(text, str) else b" ")
-                    if len(words) > 1:
-                        # align left by anchor
-                        if anchor[0] == "m":
-                            left -= max_width / 2.0
-                        elif anchor[0] == "r":
-                            left -= max_width
-
-                        word_widths = [
-                            self.textlength(
-                                word,
-                                font,
-                                direction=direction,
-                                features=features,
-                                language=language,
-                                embedded_color=embedded_color,
-                            )
-                            for word in words
-                        ]
-                        word_anchor = "l" + anchor[1]
-                        width_difference = max_width - sum(word_widths)
-                        for i, word in enumerate(words):
-                            parts.append(((left, top), word_anchor, word))
-                            left += word_widths[i] + width_difference / (len(words) - 1)
-                        top += line_spacing
-                        continue
-
-                # align left by anchor
-                if anchor[0] == "m":
-                    left -= width_difference / 2.0
-                elif anchor[0] == "r":
-                    left -= width_difference
-                parts.append(((left, top), anchor, line))
-                top += line_spacing
-
-        return font, parts
-
-    def multiline_text(
-        self,
-        xy: tuple[float, float],
-        text: AnyStr,
-        fill: _Ink | None = None,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ) = None,
-        anchor: str | None = None,
-        spacing: float = 4,
-        align: str = "left",
-        direction: str | None = None,
-        features: list[str] | None = None,
-        language: str | None = None,
-        stroke_width: float = 0,
-        stroke_fill: _Ink | None = None,
-        embedded_color: bool = False,
-        *,
-        font_size: float | None = None,
-    ) -> None:
-        font, lines = self._prepare_multiline_text(
-            xy,
-            text,
-            font,
-            anchor,
-            spacing,
-            align,
-            direction,
-            features,
-            language,
-            stroke_width,
-            embedded_color,
-            font_size,
-        )
-
-        for xy, anchor, line in lines:
-            self.text(
-                xy,
-                line,
-                fill,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                stroke_fill=stroke_fill,
-                embedded_color=embedded_color,
-            )
-
-    def textlength(
-        self,
-        text: AnyStr,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ) = None,
-        direction: str | None = None,
-        features: list[str] | None = None,
-        language: str | None = None,
-        embedded_color: bool = False,
-        *,
-        font_size: float | None = None,
-    ) -> float:
-        """Get the length of a given string, in pixels with 1/64 precision."""
-        if self._multiline_check(text):
-            msg = "can't measure length of multiline text"
-            raise ValueError(msg)
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self._getfont(font_size)
-        mode = "RGBA" if embedded_color else self.fontmode
-        return font.getlength(text, mode, direction, features, language)
-
-    def textbbox(
-        self,
-        xy: tuple[float, float],
-        text: AnyStr,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ) = None,
-        anchor: str | None = None,
-        spacing: float = 4,
-        align: str = "left",
-        direction: str | None = None,
-        features: list[str] | None = None,
-        language: str | None = None,
-        stroke_width: float = 0,
-        embedded_color: bool = False,
-        *,
-        font_size: float | None = None,
-    ) -> tuple[float, float, float, float]:
-        """Get the bounding box of a given string, in pixels."""
-        if embedded_color and self.mode not in ("RGB", "RGBA"):
-            msg = "Embedded color supported only in RGB and RGBA modes"
-            raise ValueError(msg)
-
-        if font is None:
-            font = self._getfont(font_size)
-
-        if self._multiline_check(text):
-            return self.multiline_textbbox(
-                xy,
-                text,
-                font,
-                anchor,
-                spacing,
-                align,
-                direction,
-                features,
-                language,
-                stroke_width,
-                embedded_color,
-            )
-
-        mode = "RGBA" if embedded_color else self.fontmode
-        bbox = font.getbbox(
-            text, mode, direction, features, language, stroke_width, anchor
-        )
-        return bbox[0] + xy[0], bbox[1] + xy[1], bbox[2] + xy[0], bbox[3] + xy[1]
-
-    def multiline_textbbox(
-        self,
-        xy: tuple[float, float],
-        text: AnyStr,
-        font: (
-            ImageFont.ImageFont
-            | ImageFont.FreeTypeFont
-            | ImageFont.TransposedFont
-            | None
-        ) = None,
-        anchor: str | None = None,
-        spacing: float = 4,
-        align: str = "left",
-        direction: str | None = None,
-        features: list[str] | None = None,
-        language: str | None = None,
-        stroke_width: float = 0,
-        embedded_color: bool = False,
-        *,
-        font_size: float | None = None,
-    ) -> tuple[float, float, float, float]:
-        font, lines = self._prepare_multiline_text(
-            xy,
-            text,
-            font,
-            anchor,
-            spacing,
-            align,
-            direction,
-            features,
-            language,
-            stroke_width,
-            embedded_color,
-            font_size,
-        )
-
-        bbox: tuple[float, float, float, float] | None = None
-
-        for xy, anchor, line in lines:
-            bbox_line = self.textbbox(
-                xy,
-                line,
-                font,
-                anchor,
-                direction=direction,
-                features=features,
-                language=language,
-                stroke_width=stroke_width,
-                embedded_color=embedded_color,
-            )
-            if bbox is None:
-                bbox = bbox_line
-            else:
-                bbox = (
-                    min(bbox[0], bbox_line[0]),
-                    min(bbox[1], bbox_line[1]),
-                    max(bbox[2], bbox_line[2]),
-                    max(bbox[3], bbox_line[3]),
-                )
-
-        if bbox is None:
-            return xy[0], xy[1], xy[0], xy[1]
-        return bbox
-
-
-def Draw(im: Image.Image, mode: str | None = None) -> ImageDraw:
-    """
-    A simple 2D drawing interface for PIL images.
-
-    :param im: The image to draw in.
-    :param mode: Optional mode to use for color values.  For RGB
-       images, this argument can be RGB or RGBA (to blend the
-       drawing into the image).  For all other modes, this argument
-       must be the same as the image mode.  If omitted, the mode
-       defaults to the mode of the image.
-    """
-    try:
-        return getattr(im, "getdraw")(mode)
-    except AttributeError:
-        return ImageDraw(im, mode)
-
-
-def getdraw(
-    im: Image.Image | None = None, hints: list[str] | None = None
-) -> tuple[ImageDraw2.Draw | None, ModuleType]:
-    """
-    :param im: The image to draw in.
-    :param hints: An optional list of hints. Deprecated.
-    :returns: A (drawing context, drawing resource factory) tuple.
-    """
-    if hints is not None:
-        deprecate("'hints' parameter", 12)
-    from . import ImageDraw2
-
-    draw = ImageDraw2.Draw(im) if im is not None else None
-    return draw, ImageDraw2
-
-
-def floodfill(
-    image: Image.Image,
-    xy: tuple[int, int],
-    value: float | tuple[int, ...],
-    border: float | tuple[int, ...] | None = None,
-    thresh: float = 0,
-) -> None:
-    """
-    .. warning:: This method is experimental.
-
-    Fills a bounded region with a given color.
-
-    :param image: Target image.
-    :param xy: Seed position (a 2-item coordinate tuple). See
-        :ref:`coordinate-system`.
-    :param value: Fill color.
-    :param border: Optional border value.  If given, the region consists of
-        pixels with a color different from the border color.  If not given,
-        the region consists of pixels having the same color as the seed
-        pixel.
-    :param thresh: Optional threshold value which specifies a maximum
-        tolerable difference of a pixel value from the 'background' in
-        order for it to be replaced. Useful for filling regions of
-        non-homogeneous, but similar, colors.
-    """
-    # based on an implementation by Eric S. Raymond
-    # amended by yo1995 @20180806
-    pixel = image.load()
-    assert pixel is not None
-    x, y = xy
-    try:
-        background = pixel[x, y]
-        if _color_diff(value, background) <= thresh:
-            return  # seed point already has fill color
-        pixel[x, y] = value
-    except (ValueError, IndexError):
-        return  # seed point outside image
-    edge = {(x, y)}
-    # use a set to keep record of current and previous edge pixels
-    # to reduce memory consumption
-    full_edge = set()
-    while edge:
-        new_edge = set()
-        for x, y in edge:  # 4 adjacent method
-            for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
-                # If already processed, or if a coordinate is negative, skip
-                if (s, t) in full_edge or s < 0 or t < 0:
-                    continue
-                try:
-                    p = pixel[s, t]
-                except (ValueError, IndexError):
-                    pass
-                else:
-                    full_edge.add((s, t))
-                    if border is None:
-                        fill = _color_diff(p, background) <= thresh
-                    else:
-                        fill = p not in (value, border)
-                    if fill:
-                        pixel[s, t] = value
-                        new_edge.add((s, t))
-        full_edge = edge  # discard pixels processed
-        edge = new_edge
-
-
-def _compute_regular_polygon_vertices(
-    bounding_circle: Sequence[Sequence[float] | float], n_sides: int, rotation: float
-) -> list[tuple[float, float]]:
-    """
-    Generate a list of vertices for a 2D regular polygon.
-
-    :param bounding_circle: The bounding circle is a sequence defined
-        by a point and radius. The polygon is inscribed in this circle.
-        (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
-    :param n_sides: Number of sides
-        (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
-    :param rotation: Apply an arbitrary rotation to the polygon
-        (e.g. ``rotation=90``, applies a 90 degree rotation)
-    :return: List of regular polygon vertices
-        (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
-
-    How are the vertices computed?
-    1. Compute the following variables
-        - theta: Angle between the apothem & the nearest polygon vertex
-        - side_length: Length of each polygon edge
-        - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
-        - polygon_radius: Polygon radius (last element of bounding_circle)
-        - angles: Location of each polygon vertex in polar grid
-            (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
-
-    2. For each angle in angles, get the polygon vertex at that angle
-        The vertex is computed using the equation below.
-            X= xcos(φ) + ysin(φ)
-            Y= −xsin(φ) + ycos(φ)
-
-        Note:
-            φ = angle in degrees
-            x = 0
-            y = polygon_radius
-
-        The formula above assumes rotation around the origin.
-        In our case, we are rotating around the centroid.
-        To account for this, we use the formula below
-            X = xcos(φ) + ysin(φ) + centroid_x
-            Y = −xsin(φ) + ycos(φ) + centroid_y
-    """
-    # 1. Error Handling
-    # 1.1 Check `n_sides` has an appropriate value
-    if not isinstance(n_sides, int):
-        msg = "n_sides should be an int"  # type: ignore[unreachable]
-        raise TypeError(msg)
-    if n_sides < 3:
-        msg = "n_sides should be an int > 2"
-        raise ValueError(msg)
-
-    # 1.2 Check `bounding_circle` has an appropriate value
-    if not isinstance(bounding_circle, (list, tuple)):
-        msg = "bounding_circle should be a sequence"
-        raise TypeError(msg)
-
-    if len(bounding_circle) == 3:
-        if not all(isinstance(i, (int, float)) for i in bounding_circle):
-            msg = "bounding_circle should only contain numeric data"
-            raise ValueError(msg)
-
-        *centroid, polygon_radius = cast(list[float], list(bounding_circle))
-    elif len(bounding_circle) == 2 and isinstance(bounding_circle[0], (list, tuple)):
-        if not all(
-            isinstance(i, (int, float)) for i in bounding_circle[0]
-        ) or not isinstance(bounding_circle[1], (int, float)):
-            msg = "bounding_circle should only contain numeric data"
-            raise ValueError(msg)
-
-        if len(bounding_circle[0]) != 2:
-            msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
-            raise ValueError(msg)
-
-        centroid = cast(list[float], list(bounding_circle[0]))
-        polygon_radius = cast(float, bounding_circle[1])
-    else:
-        msg = (
-            "bounding_circle should contain 2D coordinates "
-            "and a radius (e.g. (x, y, r) or ((x, y), r) )"
-        )
-        raise ValueError(msg)
-
-    if polygon_radius <= 0:
-        msg = "bounding_circle radius should be > 0"
-        raise ValueError(msg)
-
-    # 1.3 Check `rotation` has an appropriate value
-    if not isinstance(rotation, (int, float)):
-        msg = "rotation should be an int or float"  # type: ignore[unreachable]
-        raise ValueError(msg)
-
-    # 2. Define Helper Functions
-    def _apply_rotation(point: list[float], degrees: float) -> tuple[float, float]:
-        return (
-            round(
-                point[0] * math.cos(math.radians(360 - degrees))
-                - point[1] * math.sin(math.radians(360 - degrees))
-                + centroid[0],
-                2,
-            ),
-            round(
-                point[1] * math.cos(math.radians(360 - degrees))
-                + point[0] * math.sin(math.radians(360 - degrees))
-                + centroid[1],
-                2,
-            ),
-        )
-
-    def _compute_polygon_vertex(angle: float) -> tuple[float, float]:
-        start_point = [polygon_radius, 0]
-        return _apply_rotation(start_point, angle)
-
-    def _get_angles(n_sides: int, rotation: float) -> list[float]:
-        angles = []
-        degrees = 360 / n_sides
-        # Start with the bottom left polygon vertex
-        current_angle = (270 - 0.5 * degrees) + rotation
-        for _ in range(n_sides):
-            angles.append(current_angle)
-            current_angle += degrees
-            if current_angle > 360:
-                current_angle -= 360
-        return angles
-
-    # 3. Variable Declarations
-    angles = _get_angles(n_sides, rotation)
-
-    # 4. Compute Vertices
-    return [_compute_polygon_vertex(angle) for angle in angles]
-
-
-def _color_diff(
-    color1: float | tuple[int, ...], color2: float | tuple[int, ...]
-) -> float:
-    """
-    Uses 1-norm distance to calculate difference between two values.
-    """
-    first = color1 if isinstance(color1, tuple) else (color1,)
-    second = color2 if isinstance(color2, tuple) else (color2,)
-
-    return sum(abs(first[i] - second[i]) for i in range(len(second)))

.venv/lib/python3.11/site-packages/PIL/ImageDraw2.py

@@ -1,243 +0,0 @@
-#
-# The Python Imaging Library
-# $Id$
-#
-# WCK-style drawing interface operations
-#
-# History:
-# 2003-12-07 fl   created
-# 2005-05-15 fl   updated; added to PIL as ImageDraw2
-# 2005-05-15 fl   added text support
-# 2005-05-20 fl   added arc/chord/pieslice support
-#
-# Copyright (c) 2003-2005 by Secret Labs AB
-# Copyright (c) 2003-2005 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-
-"""
-(Experimental) WCK-style drawing interface operations
-
-.. seealso:: :py:mod:`PIL.ImageDraw`
-"""
-from __future__ import annotations
-
-from typing import Any, AnyStr, BinaryIO
-
-from . import Image, ImageColor, ImageDraw, ImageFont, ImagePath
-from ._typing import Coords, StrOrBytesPath
-
-
-class Pen:
-    """Stores an outline color and width."""
-
-    def __init__(self, color: str, width: int = 1, opacity: int = 255) -> None:
-        self.color = ImageColor.getrgb(color)
-        self.width = width
-
-
-class Brush:
-    """Stores a fill color"""
-
-    def __init__(self, color: str, opacity: int = 255) -> None:
-        self.color = ImageColor.getrgb(color)
-
-
-class Font:
-    """Stores a TrueType font and color"""
-
-    def __init__(
-        self, color: str, file: StrOrBytesPath | BinaryIO, size: float = 12
-    ) -> None:
-        # FIXME: add support for bitmap fonts
-        self.color = ImageColor.getrgb(color)
-        self.font = ImageFont.truetype(file, size)
-
-
-class Draw:
-    """
-    (Experimental) WCK-style drawing interface
-    """
-
-    def __init__(
-        self,
-        image: Image.Image | str,
-        size: tuple[int, int] | list[int] | None = None,
-        color: float | tuple[float, ...] | str | None = None,
-    ) -> None:
-        if isinstance(image, str):
-            if size is None:
-                msg = "If image argument is mode string, size must be a list or tuple"
-                raise ValueError(msg)
-            image = Image.new(image, size, color)
-        self.draw = ImageDraw.Draw(image)
-        self.image = image
-        self.transform: tuple[float, float, float, float, float, float] | None = None
-
-    def flush(self) -> Image.Image:
-        return self.image
-
-    def render(
-        self,
-        op: str,
-        xy: Coords,
-        pen: Pen | Brush | None,
-        brush: Brush | Pen | None = None,
-        **kwargs: Any,
-    ) -> None:
-        # handle color arguments
-        outline = fill = None
-        width = 1
-        if isinstance(pen, Pen):
-            outline = pen.color
-            width = pen.width
-        elif isinstance(brush, Pen):
-            outline = brush.color
-            width = brush.width
-        if isinstance(brush, Brush):
-            fill = brush.color
-        elif isinstance(pen, Brush):
-            fill = pen.color
-        # handle transformation
-        if self.transform:
-            path = ImagePath.Path(xy)
-            path.transform(self.transform)
-            xy = path
-        # render the item
-        if op in ("arc", "line"):
-            kwargs.setdefault("fill", outline)
-        else:
-            kwargs.setdefault("fill", fill)
-            kwargs.setdefault("outline", outline)
-        if op == "line":
-            kwargs.setdefault("width", width)
-        getattr(self.draw, op)(xy, **kwargs)
-
-    def settransform(self, offset: tuple[float, float]) -> None:
-        """Sets a transformation offset."""
-        (xoffset, yoffset) = offset
-        self.transform = (1, 0, xoffset, 0, 1, yoffset)
-
-    def arc(
-        self,
-        xy: Coords,
-        pen: Pen | Brush | None,
-        start: float,
-        end: float,
-        *options: Any,
-    ) -> None:
-        """
-        Draws an arc (a portion of a circle outline) between the start and end
-        angles, inside the given bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.arc`
-        """
-        self.render("arc", xy, pen, *options, start=start, end=end)
-
-    def chord(
-        self,
-        xy: Coords,
-        pen: Pen | Brush | None,
-        start: float,
-        end: float,
-        *options: Any,
-    ) -> None:
-        """
-        Same as :py:meth:`~PIL.ImageDraw2.Draw.arc`, but connects the end points
-        with a straight line.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.chord`
-        """
-        self.render("chord", xy, pen, *options, start=start, end=end)
-
-    def ellipse(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
-        """
-        Draws an ellipse inside the given bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.ellipse`
-        """
-        self.render("ellipse", xy, pen, *options)
-
-    def line(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
-        """
-        Draws a line between the coordinates in the ``xy`` list.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.line`
-        """
-        self.render("line", xy, pen, *options)
-
-    def pieslice(
-        self,
-        xy: Coords,
-        pen: Pen | Brush | None,
-        start: float,
-        end: float,
-        *options: Any,
-    ) -> None:
-        """
-        Same as arc, but also draws straight lines between the end points and the
-        center of the bounding box.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.pieslice`
-        """
-        self.render("pieslice", xy, pen, *options, start=start, end=end)
-
-    def polygon(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
-        """
-        Draws a polygon.
-
-        The polygon outline consists of straight lines between the given
-        coordinates, plus a straight line between the last and the first
-        coordinate.
-
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.polygon`
-        """
-        self.render("polygon", xy, pen, *options)
-
-    def rectangle(self, xy: Coords, pen: Pen | Brush | None, *options: Any) -> None:
-        """
-        Draws a rectangle.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.rectangle`
-        """
-        self.render("rectangle", xy, pen, *options)
-
-    def text(self, xy: tuple[float, float], text: AnyStr, font: Font) -> None:
-        """
-        Draws the string at the given position.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.text`
-        """
-        if self.transform:
-            path = ImagePath.Path(xy)
-            path.transform(self.transform)
-            xy = path
-        self.draw.text(xy, text, font=font.font, fill=font.color)
-
-    def textbbox(
-        self, xy: tuple[float, float], text: AnyStr, font: Font
-    ) -> tuple[float, float, float, float]:
-        """
-        Returns bounding box (in pixels) of given text.
-
-        :return: ``(left, top, right, bottom)`` bounding box
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textbbox`
-        """
-        if self.transform:
-            path = ImagePath.Path(xy)
-            path.transform(self.transform)
-            xy = path
-        return self.draw.textbbox(xy, text, font=font.font)
-
-    def textlength(self, text: AnyStr, font: Font) -> float:
-        """
-        Returns length (in pixels) of given text.
-        This is the amount by which following text should be offset.
-
-        .. seealso:: :py:meth:`PIL.ImageDraw.ImageDraw.textlength`
-        """
-        return self.draw.textlength(text, font=font.font)

.venv/lib/python3.11/site-packages/PIL/ImageEnhance.py

@@ -1,113 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# image enhancement classes
-#
-# For a background, see "Image Processing By Interpolation and
-# Extrapolation", Paul Haeberli and Douglas Voorhies.  Available
-# at http://www.graficaobscura.com/interp/index.html
-#
-# History:
-# 1996-03-23 fl  Created
-# 2009-06-16 fl  Fixed mean calculation
-#
-# 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 Image, ImageFilter, ImageStat
-
-
-class _Enhance:
-    image: Image.Image
-    degenerate: Image.Image
-
-    def enhance(self, factor: float) -> Image.Image:
-        """
-        Returns an enhanced image.
-
-        :param factor: A floating point value controlling the enhancement.
-                       Factor 1.0 always returns a copy of the original image,
-                       lower factors mean less color (brightness, contrast,
-                       etc), and higher values more. There are no restrictions
-                       on this value.
-        :rtype: :py:class:`~PIL.Image.Image`
-        """
-        return Image.blend(self.degenerate, self.image, factor)
-
-
-class Color(_Enhance):
-    """Adjust image color balance.
-
-    This class can be used to adjust the colour balance of an image, in
-    a manner similar to the controls on a colour TV set. An enhancement
-    factor of 0.0 gives a black and white image. A factor of 1.0 gives
-    the original image.
-    """
-
-    def __init__(self, image: Image.Image) -> None:
-        self.image = image
-        self.intermediate_mode = "L"
-        if "A" in image.getbands():
-            self.intermediate_mode = "LA"
-
-        if self.intermediate_mode != image.mode:
-            image = image.convert(self.intermediate_mode).convert(image.mode)
-        self.degenerate = image
-
-
-class Contrast(_Enhance):
-    """Adjust image contrast.
-
-    This class can be used to control the contrast of an image, similar
-    to the contrast control on a TV set. An enhancement factor of 0.0
-    gives a solid gray image. A factor of 1.0 gives the original image.
-    """
-
-    def __init__(self, image: Image.Image) -> None:
-        self.image = image
-        if image.mode != "L":
-            image = image.convert("L")
-        mean = int(ImageStat.Stat(image).mean[0] + 0.5)
-        self.degenerate = Image.new("L", image.size, mean)
-        if self.degenerate.mode != self.image.mode:
-            self.degenerate = self.degenerate.convert(self.image.mode)
-
-        if "A" in self.image.getbands():
-            self.degenerate.putalpha(self.image.getchannel("A"))
-
-
-class Brightness(_Enhance):
-    """Adjust image brightness.
-
-    This class can be used to control the brightness of an image.  An
-    enhancement factor of 0.0 gives a black image. A factor of 1.0 gives the
-    original image.
-    """
-
-    def __init__(self, image: Image.Image) -> None:
-        self.image = image
-        self.degenerate = Image.new(image.mode, image.size, 0)
-
-        if "A" in image.getbands():
-            self.degenerate.putalpha(image.getchannel("A"))
-
-
-class Sharpness(_Enhance):
-    """Adjust image sharpness.
-
-    This class can be used to adjust the sharpness of an image. An
-    enhancement factor of 0.0 gives a blurred image, a factor of 1.0 gives the
-    original image, and a factor of 2.0 gives a sharpened image.
-    """
-
-    def __init__(self, image: Image.Image) -> None:
-        self.image = image
-        self.degenerate = image.filter(ImageFilter.SMOOTH)
-
-        if "A" in image.getbands():
-            self.degenerate.putalpha(image.getchannel("A"))

.venv/lib/python3.11/site-packages/PIL/ImageFile.py

@@ -1,922 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# base class for image file handlers
-#
-# history:
-# 1995-09-09 fl   Created
-# 1996-03-11 fl   Fixed load mechanism.
-# 1996-04-15 fl   Added pcx/xbm decoders.
-# 1996-04-30 fl   Added encoders.
-# 1996-12-14 fl   Added load helpers
-# 1997-01-11 fl   Use encode_to_file where possible
-# 1997-08-27 fl   Flush output in _save
-# 1998-03-05 fl   Use memory mapping for some modes
-# 1999-02-04 fl   Use memory mapping also for "I;16" and "I;16B"
-# 1999-05-31 fl   Added image parser
-# 2000-10-12 fl   Set readonly flag on memory-mapped images
-# 2002-03-20 fl   Use better messages for common decoder errors
-# 2003-04-21 fl   Fall back on mmap/map_buffer if map is not available
-# 2003-10-30 fl   Added StubImageFile class
-# 2004-02-25 fl   Made incremental parser more robust
-#
-# 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 abc
-import io
-import itertools
-import logging
-import os
-import struct
-from typing import IO, Any, NamedTuple, cast
-
-from . import ExifTags, Image
-from ._deprecate import deprecate
-from ._util import DeferredError, is_path
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from ._typing import StrOrBytesPath
-
-logger = logging.getLogger(__name__)
-
-MAXBLOCK = 65536
-
-SAFEBLOCK = 1024 * 1024
-
-LOAD_TRUNCATED_IMAGES = False
-"""Whether or not to load truncated image files. User code may change this."""
-
-ERRORS = {
-    -1: "image buffer overrun error",
-    -2: "decoding error",
-    -3: "unknown error",
-    -8: "bad configuration",
-    -9: "out of memory error",
-}
-"""
-Dict of known error codes returned from :meth:`.PyDecoder.decode`,
-:meth:`.PyEncoder.encode` :meth:`.PyEncoder.encode_to_pyfd` and
-:meth:`.PyEncoder.encode_to_file`.
-"""
-
-
-#
-# --------------------------------------------------------------------
-# Helpers
-
-
-def _get_oserror(error: int, *, encoder: bool) -> OSError:
-    try:
-        msg = Image.core.getcodecstatus(error)
-    except AttributeError:
-        msg = ERRORS.get(error)
-    if not msg:
-        msg = f"{'encoder' if encoder else 'decoder'} error {error}"
-    msg += f" when {'writing' if encoder else 'reading'} image file"
-    return OSError(msg)
-
-
-def raise_oserror(error: int) -> OSError:
-    deprecate(
-        "raise_oserror",
-        12,
-        action="It is only useful for translating error codes returned by a codec's "
-        "decode() method, which ImageFile already does automatically.",
-    )
-    raise _get_oserror(error, encoder=False)
-
-
-def _tilesort(t: _Tile) -> int:
-    # sort on offset
-    return t[2]
-
-
-class _Tile(NamedTuple):
-    codec_name: str
-    extents: tuple[int, int, int, int] | None
-    offset: int = 0
-    args: tuple[Any, ...] | str | None = None
-
-
-#
-# --------------------------------------------------------------------
-# ImageFile base class
-
-
-class ImageFile(Image.Image):
-    """Base class for image file format handlers."""
-
-    def __init__(
-        self, fp: StrOrBytesPath | IO[bytes], filename: str | bytes | None = None
-    ) -> None:
-        super().__init__()
-
-        self._min_frame = 0
-
-        self.custom_mimetype: str | None = None
-
-        self.tile: list[_Tile] = []
-        """ A list of tile descriptors """
-
-        self.readonly = 1  # until we know better
-
-        self.decoderconfig: tuple[Any, ...] = ()
-        self.decodermaxblock = MAXBLOCK
-
-        if is_path(fp):
-            # filename
-            self.fp = open(fp, "rb")
-            self.filename = os.fspath(fp)
-            self._exclusive_fp = True
-        else:
-            # stream
-            self.fp = cast(IO[bytes], fp)
-            self.filename = filename if filename is not None else ""
-            # can be overridden
-            self._exclusive_fp = False
-
-        try:
-            try:
-                self._open()
-            except (
-                IndexError,  # end of data
-                TypeError,  # end of data (ord)
-                KeyError,  # unsupported mode
-                EOFError,  # got header but not the first frame
-                struct.error,
-            ) as v:
-                raise SyntaxError(v) from v
-
-            if not self.mode or self.size[0] <= 0 or self.size[1] <= 0:
-                msg = "not identified by this driver"
-                raise SyntaxError(msg)
-        except BaseException:
-            # close the file only if we have opened it this constructor
-            if self._exclusive_fp:
-                self.fp.close()
-            raise
-
-    def _open(self) -> None:
-        pass
-
-    def _close_fp(self):
-        if getattr(self, "_fp", False) and not isinstance(self._fp, DeferredError):
-            if self._fp != self.fp:
-                self._fp.close()
-            self._fp = DeferredError(ValueError("Operation on closed image"))
-        if self.fp:
-            self.fp.close()
-
-    def close(self) -> None:
-        """
-        Closes the file pointer, if possible.
-
-        This operation will destroy the image core and release its memory.
-        The image data will be unusable afterward.
-
-        This function is required to close images that have multiple frames or
-        have not had their file read and closed by the
-        :py:meth:`~PIL.Image.Image.load` method. See :ref:`file-handling` for
-        more information.
-        """
-        try:
-            self._close_fp()
-            self.fp = None
-        except Exception as msg:
-            logger.debug("Error closing: %s", msg)
-
-        super().close()
-
-    def get_child_images(self) -> list[ImageFile]:
-        child_images = []
-        exif = self.getexif()
-        ifds = []
-        if ExifTags.Base.SubIFDs in exif:
-            subifd_offsets = exif[ExifTags.Base.SubIFDs]
-            if subifd_offsets:
-                if not isinstance(subifd_offsets, tuple):
-                    subifd_offsets = (subifd_offsets,)
-                for subifd_offset in subifd_offsets:
-                    ifds.append((exif._get_ifd_dict(subifd_offset), subifd_offset))
-        ifd1 = exif.get_ifd(ExifTags.IFD.IFD1)
-        if ifd1 and ifd1.get(ExifTags.Base.JpegIFOffset):
-            assert exif._info is not None
-            ifds.append((ifd1, exif._info.next))
-
-        offset = None
-        for ifd, ifd_offset in ifds:
-            assert self.fp is not None
-            current_offset = self.fp.tell()
-            if offset is None:
-                offset = current_offset
-
-            fp = self.fp
-            if ifd is not None:
-                thumbnail_offset = ifd.get(ExifTags.Base.JpegIFOffset)
-                if thumbnail_offset is not None:
-                    thumbnail_offset += getattr(self, "_exif_offset", 0)
-                    self.fp.seek(thumbnail_offset)
-
-                    length = ifd.get(ExifTags.Base.JpegIFByteCount)
-                    assert isinstance(length, int)
-                    data = self.fp.read(length)
-                    fp = io.BytesIO(data)
-
-            with Image.open(fp) as im:
-                from . import TiffImagePlugin
-
-                if thumbnail_offset is None and isinstance(
-                    im, TiffImagePlugin.TiffImageFile
-                ):
-                    im._frame_pos = [ifd_offset]
-                    im._seek(0)
-                im.load()
-                child_images.append(im)
-
-        if offset is not None:
-            assert self.fp is not None
-            self.fp.seek(offset)
-        return child_images
-
-    def get_format_mimetype(self) -> str | None:
-        if self.custom_mimetype:
-            return self.custom_mimetype
-        if self.format is not None:
-            return Image.MIME.get(self.format.upper())
-        return None
-
-    def __getstate__(self) -> list[Any]:
-        return super().__getstate__() + [self.filename]
-
-    def __setstate__(self, state: list[Any]) -> None:
-        self.tile = []
-        if len(state) > 5:
-            self.filename = state[5]
-        super().__setstate__(state)
-
-    def verify(self) -> None:
-        """Check file integrity"""
-
-        # raise exception if something's wrong.  must be called
-        # directly after open, and closes file when finished.
-        if self._exclusive_fp:
-            self.fp.close()
-        self.fp = None
-
-    def load(self) -> Image.core.PixelAccess | None:
-        """Load image data based on tile list"""
-
-        if not self.tile and self._im is None:
-            msg = "cannot load this image"
-            raise OSError(msg)
-
-        pixel = Image.Image.load(self)
-        if not self.tile:
-            return pixel
-
-        self.map: mmap.mmap | None = None
-        use_mmap = self.filename and len(self.tile) == 1
-
-        readonly = 0
-
-        # look for read/seek overrides
-        if hasattr(self, "load_read"):
-            read = self.load_read
-            # don't use mmap if there are custom read/seek functions
-            use_mmap = False
-        else:
-            read = self.fp.read
-
-        if hasattr(self, "load_seek"):
-            seek = self.load_seek
-            use_mmap = False
-        else:
-            seek = self.fp.seek
-
-        if use_mmap:
-            # try memory mapping
-            decoder_name, extents, offset, args = self.tile[0]
-            if isinstance(args, str):
-                args = (args, 0, 1)
-            if (
-                decoder_name == "raw"
-                and isinstance(args, tuple)
-                and len(args) >= 3
-                and args[0] == self.mode
-                and args[0] in Image._MAPMODES
-            ):
-                try:
-                    # use mmap, if possible
-                    import mmap
-
-                    with open(self.filename) as fp:
-                        self.map = mmap.mmap(fp.fileno(), 0, access=mmap.ACCESS_READ)
-                    if offset + self.size[1] * args[1] > self.map.size():
-                        msg = "buffer is not large enough"
-                        raise OSError(msg)
-                    self.im = Image.core.map_buffer(
-                        self.map, self.size, decoder_name, offset, args
-                    )
-                    readonly = 1
-                    # After trashing self.im,
-                    # we might need to reload the palette data.
-                    if self.palette:
-                        self.palette.dirty = 1
-                except (AttributeError, OSError, ImportError):
-                    self.map = None
-
-        self.load_prepare()
-        err_code = -3  # initialize to unknown error
-        if not self.map:
-            # sort tiles in file order
-            self.tile.sort(key=_tilesort)
-
-            # FIXME: This is a hack to handle TIFF's JpegTables tag.
-            prefix = getattr(self, "tile_prefix", b"")
-
-            # Remove consecutive duplicates that only differ by their offset
-            self.tile = [
-                list(tiles)[-1]
-                for _, tiles in itertools.groupby(
-                    self.tile, lambda tile: (tile[0], tile[1], tile[3])
-                )
-            ]
-            for i, (decoder_name, extents, offset, args) in enumerate(self.tile):
-                seek(offset)
-                decoder = Image._getdecoder(
-                    self.mode, decoder_name, args, self.decoderconfig
-                )
-                try:
-                    decoder.setimage(self.im, extents)
-                    if decoder.pulls_fd:
-                        decoder.setfd(self.fp)
-                        err_code = decoder.decode(b"")[1]
-                    else:
-                        b = prefix
-                        while True:
-                            read_bytes = self.decodermaxblock
-                            if i + 1 < len(self.tile):
-                                next_offset = self.tile[i + 1].offset
-                                if next_offset > offset:
-                                    read_bytes = next_offset - offset
-                            try:
-                                s = read(read_bytes)
-                            except (IndexError, struct.error) as e:
-                                # truncated png/gif
-                                if LOAD_TRUNCATED_IMAGES:
-                                    break
-                                else:
-                                    msg = "image file is truncated"
-                                    raise OSError(msg) from e
-
-                            if not s:  # truncated jpeg
-                                if LOAD_TRUNCATED_IMAGES:
-                                    break
-                                else:
-                                    msg = (
-                                        "image file is truncated "
-                                        f"({len(b)} bytes not processed)"
-                                    )
-                                    raise OSError(msg)
-
-                            b = b + s
-                            n, err_code = decoder.decode(b)
-                            if n < 0:
-                                break
-                            b = b[n:]
-                finally:
-                    # Need to cleanup here to prevent leaks
-                    decoder.cleanup()
-
-        self.tile = []
-        self.readonly = readonly
-
-        self.load_end()
-
-        if self._exclusive_fp and self._close_exclusive_fp_after_loading:
-            self.fp.close()
-        self.fp = None
-
-        if not self.map and not LOAD_TRUNCATED_IMAGES and err_code < 0:
-            # still raised if decoder fails to return anything
-            raise _get_oserror(err_code, encoder=False)
-
-        return Image.Image.load(self)
-
-    def load_prepare(self) -> None:
-        # create image memory if necessary
-        if self._im is None:
-            self.im = Image.core.new(self.mode, self.size)
-        # create palette (optional)
-        if self.mode == "P":
-            Image.Image.load(self)
-
-    def load_end(self) -> None:
-        # may be overridden
-        pass
-
-    # may be defined for contained formats
-    # def load_seek(self, pos: int) -> None:
-    #     pass
-
-    # may be defined for blocked formats (e.g. PNG)
-    # def load_read(self, read_bytes: int) -> bytes:
-    #     pass
-
-    def _seek_check(self, frame: int) -> bool:
-        if (
-            frame < self._min_frame
-            # Only check upper limit on frames if additional seek operations
-            # are not required to do so
-            or (
-                not (hasattr(self, "_n_frames") and self._n_frames is None)
-                and frame >= getattr(self, "n_frames") + self._min_frame
-            )
-        ):
-            msg = "attempt to seek outside sequence"
-            raise EOFError(msg)
-
-        return self.tell() != frame
-
-
-class StubHandler(abc.ABC):
-    def open(self, im: StubImageFile) -> None:
-        pass
-
-    @abc.abstractmethod
-    def load(self, im: StubImageFile) -> Image.Image:
-        pass
-
-
-class StubImageFile(ImageFile, metaclass=abc.ABCMeta):
-    """
-    Base class for stub image loaders.
-
-    A stub loader is an image loader that can identify files of a
-    certain format, but relies on external code to load the file.
-    """
-
-    @abc.abstractmethod
-    def _open(self) -> None:
-        pass
-
-    def load(self) -> Image.core.PixelAccess | None:
-        loader = self._load()
-        if loader is None:
-            msg = f"cannot find loader for this {self.format} file"
-            raise OSError(msg)
-        image = loader.load(self)
-        assert image is not None
-        # become the other object (!)
-        self.__class__ = image.__class__  # type: ignore[assignment]
-        self.__dict__ = image.__dict__
-        return image.load()
-
-    @abc.abstractmethod
-    def _load(self) -> StubHandler | None:
-        """(Hook) Find actual image loader."""
-        pass
-
-
-class Parser:
-    """
-    Incremental image parser.  This class implements the standard
-    feed/close consumer interface.
-    """
-
-    incremental = None
-    image: Image.Image | None = None
-    data: bytes | None = None
-    decoder: Image.core.ImagingDecoder | PyDecoder | None = None
-    offset = 0
-    finished = 0
-
-    def reset(self) -> None:
-        """
-        (Consumer) Reset the parser.  Note that you can only call this
-        method immediately after you've created a parser; parser
-        instances cannot be reused.
-        """
-        assert self.data is None, "cannot reuse parsers"
-
-    def feed(self, data: bytes) -> None:
-        """
-        (Consumer) Feed data to the parser.
-
-        :param data: A string buffer.
-        :exception OSError: If the parser failed to parse the image file.
-        """
-        # collect data
-
-        if self.finished:
-            return
-
-        if self.data is None:
-            self.data = data
-        else:
-            self.data = self.data + data
-
-        # parse what we have
-        if self.decoder:
-            if self.offset > 0:
-                # skip header
-                skip = min(len(self.data), self.offset)
-                self.data = self.data[skip:]
-                self.offset = self.offset - skip
-                if self.offset > 0 or not self.data:
-                    return
-
-            n, e = self.decoder.decode(self.data)
-
-            if n < 0:
-                # end of stream
-                self.data = None
-                self.finished = 1
-                if e < 0:
-                    # decoding error
-                    self.image = None
-                    raise _get_oserror(e, encoder=False)
-                else:
-                    # end of image
-                    return
-            self.data = self.data[n:]
-
-        elif self.image:
-            # if we end up here with no decoder, this file cannot
-            # be incrementally parsed.  wait until we've gotten all
-            # available data
-            pass
-
-        else:
-            # attempt to open this file
-            try:
-                with io.BytesIO(self.data) as fp:
-                    im = Image.open(fp)
-            except OSError:
-                pass  # not enough data
-            else:
-                flag = hasattr(im, "load_seek") or hasattr(im, "load_read")
-                if flag or len(im.tile) != 1:
-                    # custom load code, or multiple tiles
-                    self.decode = None
-                else:
-                    # initialize decoder
-                    im.load_prepare()
-                    d, e, o, a = im.tile[0]
-                    im.tile = []
-                    self.decoder = Image._getdecoder(im.mode, d, a, im.decoderconfig)
-                    self.decoder.setimage(im.im, e)
-
-                    # calculate decoder offset
-                    self.offset = o
-                    if self.offset <= len(self.data):
-                        self.data = self.data[self.offset :]
-                        self.offset = 0
-
-                self.image = im
-
-    def __enter__(self) -> Parser:
-        return self
-
-    def __exit__(self, *args: object) -> None:
-        self.close()
-
-    def close(self) -> Image.Image:
-        """
-        (Consumer) Close the stream.
-
-        :returns: An image object.
-        :exception OSError: If the parser failed to parse the image file either
-                            because it cannot be identified or cannot be
-                            decoded.
-        """
-        # finish decoding
-        if self.decoder:
-            # get rid of what's left in the buffers
-            self.feed(b"")
-            self.data = self.decoder = None
-            if not self.finished:
-                msg = "image was incomplete"
-                raise OSError(msg)
-        if not self.image:
-            msg = "cannot parse this image"
-            raise OSError(msg)
-        if self.data:
-            # incremental parsing not possible; reopen the file
-            # not that we have all data
-            with io.BytesIO(self.data) as fp:
-                try:
-                    self.image = Image.open(fp)
-                finally:
-                    self.image.load()
-        return self.image
-
-
-# --------------------------------------------------------------------
-
-
-def _save(im: Image.Image, fp: IO[bytes], tile: list[_Tile], bufsize: int = 0) -> None:
-    """Helper to save image based on tile list
-
-    :param im: Image object.
-    :param fp: File object.
-    :param tile: Tile list.
-    :param bufsize: Optional buffer size
-    """
-
-    im.load()
-    if not hasattr(im, "encoderconfig"):
-        im.encoderconfig = ()
-    tile.sort(key=_tilesort)
-    # FIXME: make MAXBLOCK a configuration parameter
-    # It would be great if we could have the encoder specify what it needs
-    # But, it would need at least the image size in most cases. RawEncode is
-    # a tricky case.
-    bufsize = max(MAXBLOCK, bufsize, im.size[0] * 4)  # see RawEncode.c
-    try:
-        fh = fp.fileno()
-        fp.flush()
-        _encode_tile(im, fp, tile, bufsize, fh)
-    except (AttributeError, io.UnsupportedOperation) as exc:
-        _encode_tile(im, fp, tile, bufsize, None, exc)
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-
-def _encode_tile(
-    im: Image.Image,
-    fp: IO[bytes],
-    tile: list[_Tile],
-    bufsize: int,
-    fh: int | None,
-    exc: BaseException | None = None,
-) -> None:
-    for encoder_name, extents, offset, args in tile:
-        if offset > 0:
-            fp.seek(offset)
-        encoder = Image._getencoder(im.mode, encoder_name, args, im.encoderconfig)
-        try:
-            encoder.setimage(im.im, extents)
-            if encoder.pushes_fd:
-                encoder.setfd(fp)
-                errcode = encoder.encode_to_pyfd()[1]
-            else:
-                if exc:
-                    # compress to Python file-compatible object
-                    while True:
-                        errcode, data = encoder.encode(bufsize)[1:]
-                        fp.write(data)
-                        if errcode:
-                            break
-                else:
-                    # slight speedup: compress to real file object
-                    assert fh is not None
-                    errcode = encoder.encode_to_file(fh, bufsize)
-            if errcode < 0:
-                raise _get_oserror(errcode, encoder=True) from exc
-        finally:
-            encoder.cleanup()
-
-
-def _safe_read(fp: IO[bytes], size: int) -> bytes:
-    """
-    Reads large blocks in a safe way.  Unlike fp.read(n), this function
-    doesn't trust the user.  If the requested size is larger than
-    SAFEBLOCK, the file is read block by block.
-
-    :param fp: File handle.  Must implement a <b>read</b> method.
-    :param size: Number of bytes to read.
-    :returns: A string containing <i>size</i> bytes of data.
-
-    Raises an OSError if the file is truncated and the read cannot be completed
-
-    """
-    if size <= 0:
-        return b""
-    if size <= SAFEBLOCK:
-        data = fp.read(size)
-        if len(data) < size:
-            msg = "Truncated File Read"
-            raise OSError(msg)
-        return data
-    blocks: list[bytes] = []
-    remaining_size = size
-    while remaining_size > 0:
-        block = fp.read(min(remaining_size, SAFEBLOCK))
-        if not block:
-            break
-        blocks.append(block)
-        remaining_size -= len(block)
-    if sum(len(block) for block in blocks) < size:
-        msg = "Truncated File Read"
-        raise OSError(msg)
-    return b"".join(blocks)
-
-
-class PyCodecState:
-    def __init__(self) -> None:
-        self.xsize = 0
-        self.ysize = 0
-        self.xoff = 0
-        self.yoff = 0
-
-    def extents(self) -> tuple[int, int, int, int]:
-        return self.xoff, self.yoff, self.xoff + self.xsize, self.yoff + self.ysize
-
-
-class PyCodec:
-    fd: IO[bytes] | None
-
-    def __init__(self, mode: str, *args: Any) -> None:
-        self.im: Image.core.ImagingCore | None = None
-        self.state = PyCodecState()
-        self.fd = None
-        self.mode = mode
-        self.init(args)
-
-    def init(self, args: tuple[Any, ...]) -> None:
-        """
-        Override to perform codec specific initialization
-
-        :param args: Tuple of arg items from the tile entry
-        :returns: None
-        """
-        self.args = args
-
-    def cleanup(self) -> None:
-        """
-        Override to perform codec specific cleanup
-
-        :returns: None
-        """
-        pass
-
-    def setfd(self, fd: IO[bytes]) -> None:
-        """
-        Called from ImageFile to set the Python file-like object
-
-        :param fd: A Python file-like object
-        :returns: None
-        """
-        self.fd = fd
-
-    def setimage(
-        self,
-        im: Image.core.ImagingCore,
-        extents: tuple[int, int, int, int] | None = None,
-    ) -> None:
-        """
-        Called from ImageFile to set the core output image for the codec
-
-        :param im: A core image object
-        :param extents: a 4 tuple of (x0, y0, x1, y1) defining the rectangle
-            for this tile
-        :returns: None
-        """
-
-        # following c code
-        self.im = im
-
-        if extents:
-            (x0, y0, x1, y1) = extents
-        else:
-            (x0, y0, x1, y1) = (0, 0, 0, 0)
-
-        if x0 == 0 and x1 == 0:
-            self.state.xsize, self.state.ysize = self.im.size
-        else:
-            self.state.xoff = x0
-            self.state.yoff = y0
-            self.state.xsize = x1 - x0
-            self.state.ysize = y1 - y0
-
-        if self.state.xsize <= 0 or self.state.ysize <= 0:
-            msg = "Size cannot be negative"
-            raise ValueError(msg)
-
-        if (
-            self.state.xsize + self.state.xoff > self.im.size[0]
-            or self.state.ysize + self.state.yoff > self.im.size[1]
-        ):
-            msg = "Tile cannot extend outside image"
-            raise ValueError(msg)
-
-
-class PyDecoder(PyCodec):
-    """
-    Python implementation of a format decoder. Override this class and
-    add the decoding logic in the :meth:`decode` method.
-
-    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
-    """
-
-    _pulls_fd = False
-
-    @property
-    def pulls_fd(self) -> bool:
-        return self._pulls_fd
-
-    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        """
-        Override to perform the decoding process.
-
-        :param buffer: A bytes object with the data to be decoded.
-        :returns: A tuple of ``(bytes consumed, errcode)``.
-            If finished with decoding return -1 for the bytes consumed.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        msg = "unavailable in base decoder"
-        raise NotImplementedError(msg)
-
-    def set_as_raw(
-        self, data: bytes, rawmode: str | None = None, extra: tuple[Any, ...] = ()
-    ) -> None:
-        """
-        Convenience method to set the internal image from a stream of raw data
-
-        :param data: Bytes to be set
-        :param rawmode: The rawmode to be used for the decoder.
-            If not specified, it will default to the mode of the image
-        :param extra: Extra arguments for the decoder.
-        :returns: None
-        """
-
-        if not rawmode:
-            rawmode = self.mode
-        d = Image._getdecoder(self.mode, "raw", rawmode, extra)
-        assert self.im is not None
-        d.setimage(self.im, self.state.extents())
-        s = d.decode(data)
-
-        if s[0] >= 0:
-            msg = "not enough image data"
-            raise ValueError(msg)
-        if s[1] != 0:
-            msg = "cannot decode image data"
-            raise ValueError(msg)
-
-
-class PyEncoder(PyCodec):
-    """
-    Python implementation of a format encoder. Override this class and
-    add the decoding logic in the :meth:`encode` method.
-
-    See :ref:`Writing Your Own File Codec in Python<file-codecs-py>`
-    """
-
-    _pushes_fd = False
-
-    @property
-    def pushes_fd(self) -> bool:
-        return self._pushes_fd
-
-    def encode(self, bufsize: int) -> tuple[int, int, bytes]:
-        """
-        Override to perform the encoding process.
-
-        :param bufsize: Buffer size.
-        :returns: A tuple of ``(bytes encoded, errcode, bytes)``.
-            If finished with encoding return 1 for the error code.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        msg = "unavailable in base encoder"
-        raise NotImplementedError(msg)
-
-    def encode_to_pyfd(self) -> tuple[int, int]:
-        """
-        If ``pushes_fd`` is ``True``, then this method will be used,
-        and ``encode()`` will only be called once.
-
-        :returns: A tuple of ``(bytes consumed, errcode)``.
-            Err codes are from :data:`.ImageFile.ERRORS`.
-        """
-        if not self.pushes_fd:
-            return 0, -8  # bad configuration
-        bytes_consumed, errcode, data = self.encode(0)
-        if data:
-            assert self.fd is not None
-            self.fd.write(data)
-        return bytes_consumed, errcode
-
-    def encode_to_file(self, fh: int, bufsize: int) -> int:
-        """
-        :param fh: File handle.
-        :param bufsize: Buffer size.
-
-        :returns: If finished successfully, return 0.
-            Otherwise, return an error code. Err codes are from
-            :data:`.ImageFile.ERRORS`.
-        """
-        errcode = 0
-        while errcode == 0:
-            status, errcode, buf = self.encode(bufsize)
-            if status > 0:
-                os.write(fh, buf[status:])
-        return errcode