Disable Django Debug Mode

[DEPENDABOT] Update: Bump whitenoise from 6.8.2 to 6.9.0

.clinerules

@@ -0,0 +1,30 @@
+# Project Startup Rules
+
+## Development Server
+IMPORTANT: Always follow these instructions exactly when starting the development server:
+
+```bash
+lsof -ti :8000 | xargs kill -9; find . -type d -name "__pycache__" -exec rm -r {} +; uv run manage.py tailwind runserver
+```
+
+Note: These steps must be executed in this exact order as a single command to ensure consistent behavior.
+
+## Package Management
+IMPORTANT: When a Python package is needed, only use UV to add it:
+```bash
+uv add <package>
+```
+Do not attempt to install packages using any other method.
+
+## Django Management Commands
+IMPORTANT: When running any Django manage.py commands (migrations, shell, etc.), always use UV:
+```bash
+uv run manage.py <command>
+```
+This applies to all management commands including but not limited to:
+- Making migrations: `uv run manage.py makemigrations`
+- Applying migrations: `uv run manage.py migrate`
+- Creating superuser: `uv run manage.py createsuperuser`
+- Starting shell: `uv run manage.py shell`
+
+NEVER use `python manage.py` or `uv run python manage.py`. Always use `uv run manage.py` directly.

.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+  # Python dependencies
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "[DEPENDABOT] Update"
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"
+    reviewers:
+      - "pacnpal"
+
+  # GitHub Actions dependencies
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "[DEPENDABOT] Update Actions"

.github/workflows/django.yml

@@ -0,0 +1,41 @@
+name: Django CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: [3.13.1]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Install Homebrew on Linux
+      if: runner.os == 'Linux'
+      run: |
+        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+        echo "/home/linuxbrew/.linuxbrew/bin" >> $GITHUB_PATH
+    
+    - name: Install GDAL with Homebrew
+      run: brew install gdal
+      
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        
+    - name: Run Tests
+      run: |
+        python manage.py test

.github/workflows/review.yml

@@ -0,0 +1,34 @@
+name: Claude Code Review
+
+permissions:
+  contents: read
+  pull-requests: write
+
+on:
+  # Run on new/updated PRs
+  pull_request:
+    types: [opened, reopened, synchronize]
+  
+  # Allow manual triggers for existing PRs
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'Pull Request Number'
+        required: true
+        type: string
+
+jobs:
+  code-review:
+    runs-on: ubuntu-latest
+    environment: development_environment
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          
+      - name: Run Claude Review
+        uses: pacnpal/claude-code-review@main
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          anthropic-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          pr-number: ${{ github.event.pull_request.number || inputs.pr_number }}

.gitignore

@@ -32,3 +32,344 @@ parks/__pycache__/views.cpython-312.pyc
 .venv/lib/python3.12/site-packages
 thrillwiki/__pycache__/urls.cpython-312.pyc
 thrillwiki/__pycache__/views.cpython-312.pyc
+.pytest_cache.github
+static/css/tailwind.css
+static/css/tailwind.css
+.venv
+location/__pycache__
+analytics/__pycache__
+designers/__pycache__
+history_tracking/__pycache__
+media/migrations/__pycache__/0001_initial.cpython-312.pyc
+accounts/__pycache__/__init__.cpython-312.pyc
+accounts/__pycache__/adapters.cpython-312.pyc
+accounts/__pycache__/admin.cpython-312.pyc
+accounts/__pycache__/apps.cpython-312.pyc
+accounts/__pycache__/models.cpython-312.pyc
+accounts/__pycache__/signals.cpython-312.pyc
+accounts/__pycache__/urls.cpython-312.pyc
+accounts/__pycache__/views.cpython-312.pyc
+accounts/migrations/__pycache__/__init__.cpython-312.pyc
+accounts/migrations/__pycache__/0001_initial.cpython-312.pyc
+companies/__pycache__/__init__.cpython-312.pyc
+companies/__pycache__/admin.cpython-312.pyc
+companies/__pycache__/apps.cpython-312.pyc
+companies/__pycache__/models.cpython-312.pyc
+companies/__pycache__/signals.cpython-312.pyc
+companies/__pycache__/urls.cpython-312.pyc
+companies/__pycache__/views.cpython-312.pyc
+companies/migrations/__pycache__/__init__.cpython-312.pyc
+companies/migrations/__pycache__/0001_initial.cpython-312.pyc
+core/__pycache__/__init__.cpython-312.pyc
+core/__pycache__/admin.cpython-312.pyc
+core/__pycache__/apps.cpython-312.pyc
+core/__pycache__/models.cpython-312.pyc
+core/__pycache__/views.cpython-312.pyc
+core/migrations/__pycache__/__init__.cpython-312.pyc
+core/migrations/__pycache__/0001_initial.cpython-312.pyc
+email_service/__pycache__/__init__.cpython-312.pyc
+email_service/__pycache__/admin.cpython-312.pyc
+email_service/__pycache__/apps.cpython-312.pyc
+email_service/__pycache__/models.cpython-312.pyc
+email_service/__pycache__/services.cpython-312.pyc
+email_service/migrations/__pycache__/__init__.cpython-312.pyc
+email_service/migrations/__pycache__/0001_initial.cpython-312.pyc
+media/__pycache__/__init__.cpython-312.pyc
+media/__pycache__/admin.cpython-312.pyc
+media/__pycache__/apps.cpython-312.pyc
+media/__pycache__/models.cpython-312.pyc
+media/migrations/__pycache__/__init__.cpython-312.pyc
+media/migrations/__pycache__/0001_initial.cpython-312.pyc
+parks/__pycache__/__init__.cpython-312.pyc
+parks/__pycache__/admin.cpython-312.pyc
+parks/__pycache__/apps.cpython-312.pyc
+parks/__pycache__/models.cpython-312.pyc
+parks/__pycache__/signals.cpython-312.pyc
+parks/__pycache__/urls.cpython-312.pyc
+parks/__pycache__/views.cpython-312.pyc
+parks/migrations/__pycache__/__init__.cpython-312.pyc
+parks/migrations/__pycache__/0001_initial.cpython-312.pyc
+reviews/__pycache__/__init__.cpython-312.pyc
+reviews/__pycache__/admin.cpython-312.pyc
+reviews/__pycache__/apps.cpython-312.pyc
+reviews/__pycache__/models.cpython-312.pyc
+reviews/__pycache__/signals.cpython-312.pyc
+reviews/__pycache__/urls.cpython-312.pyc
+reviews/__pycache__/views.cpython-312.pyc
+reviews/migrations/__pycache__/__init__.cpython-312.pyc
+reviews/migrations/__pycache__/0001_initial.cpython-312.pyc
+rides/__pycache__/__init__.cpython-312.pyc
+rides/__pycache__/admin.cpython-312.pyc
+rides/__pycache__/apps.cpython-312.pyc
+rides/__pycache__/models.cpython-312.pyc
+rides/__pycache__/signals.cpython-312.pyc
+rides/__pycache__/urls.cpython-312.pyc
+rides/__pycache__/views.cpython-312.pyc
+rides/migrations/__pycache__/__init__.cpython-312.pyc
+rides/migrations/__pycache__/0001_initial.cpython-312.pyc
+thrillwiki/__pycache__/__init__.cpython-312.pyc
+thrillwiki/__pycache__/settings.cpython-312.pyc
+thrillwiki/__pycache__/urls.cpython-312.pyc
+thrillwiki/__pycache__/views.cpython-312.pyc
+thrillwiki/__pycache__/wsgi.cpython-312.pyc
+accounts/__pycache__/__init__.cpython-312.pyc
+accounts/__pycache__/adapters.cpython-312.pyc
+accounts/__pycache__/admin.cpython-312.pyc
+accounts/__pycache__/apps.cpython-312.pyc
+accounts/__pycache__/models.cpython-312.pyc
+accounts/__pycache__/signals.cpython-312.pyc
+accounts/__pycache__/urls.cpython-312.pyc
+accounts/__pycache__/views.cpython-312.pyc
+accounts/migrations/__pycache__/__init__.cpython-312.pyc
+accounts/migrations/__pycache__/0001_initial.cpython-312.pyc
+companies/__pycache__/__init__.cpython-312.pyc
+companies/__pycache__/admin.cpython-312.pyc
+companies/__pycache__/apps.cpython-312.pyc
+companies/__pycache__/models.cpython-312.pyc
+companies/__pycache__/signals.cpython-312.pyc
+companies/__pycache__/urls.cpython-312.pyc
+companies/__pycache__/views.cpython-312.pyc
+companies/migrations/__pycache__/__init__.cpython-312.pyc
+companies/migrations/__pycache__/0001_initial.cpython-312.pyc
+core/__pycache__/__init__.cpython-312.pyc
+core/__pycache__/admin.cpython-312.pyc
+core/__pycache__/apps.cpython-312.pyc
+core/__pycache__/models.cpython-312.pyc
+core/__pycache__/views.cpython-312.pyc
+core/migrations/__pycache__/__init__.cpython-312.pyc
+core/migrations/__pycache__/0001_initial.cpython-312.pyc
+email_service/__pycache__/__init__.cpython-312.pyc
+email_service/__pycache__/admin.cpython-312.pyc
+email_service/__pycache__/apps.cpython-312.pyc
+email_service/__pycache__/models.cpython-312.pyc
+email_service/__pycache__/services.cpython-312.pyc
+email_service/migrations/__pycache__/__init__.cpython-312.pyc
+email_service/migrations/__pycache__/0001_initial.cpython-312.pyc
+media/__pycache__/__init__.cpython-312.pyc
+media/__pycache__/admin.cpython-312.pyc
+media/__pycache__/apps.cpython-312.pyc
+media/__pycache__/models.cpython-312.pyc
+media/migrations/__pycache__/__init__.cpython-312.pyc
+media/migrations/__pycache__/0001_initial.cpython-312.pyc
+parks/__pycache__/__init__.cpython-312.pyc
+parks/__pycache__/admin.cpython-312.pyc
+parks/__pycache__/apps.cpython-312.pyc
+parks/__pycache__/models.cpython-312.pyc
+parks/__pycache__/signals.cpython-312.pyc
+parks/__pycache__/urls.cpython-312.pyc
+parks/__pycache__/views.cpython-312.pyc
+parks/migrations/__pycache__/__init__.cpython-312.pyc
+parks/migrations/__pycache__/0001_initial.cpython-312.pyc
+reviews/__pycache__/__init__.cpython-312.pyc
+reviews/__pycache__/admin.cpython-312.pyc
+reviews/__pycache__/apps.cpython-312.pyc
+reviews/__pycache__/models.cpython-312.pyc
+reviews/__pycache__/signals.cpython-312.pyc
+reviews/__pycache__/urls.cpython-312.pyc
+reviews/__pycache__/views.cpython-312.pyc
+reviews/migrations/__pycache__/__init__.cpython-312.pyc
+reviews/migrations/__pycache__/0001_initial.cpython-312.pyc
+rides/__pycache__/__init__.cpython-312.pyc
+rides/__pycache__/admin.cpython-312.pyc
+rides/__pycache__/apps.cpython-312.pyc
+rides/__pycache__/models.cpython-312.pyc
+rides/__pycache__/signals.cpython-312.pyc
+rides/__pycache__/urls.cpython-312.pyc
+rides/__pycache__/views.cpython-312.pyc
+rides/migrations/__pycache__/__init__.cpython-312.pyc
+rides/migrations/__pycache__/0001_initial.cpython-312.pyc
+thrillwiki/__pycache__/__init__.cpython-312.pyc
+thrillwiki/__pycache__/settings.cpython-312.pyc
+thrillwiki/__pycache__/urls.cpython-312.pyc
+thrillwiki/__pycache__/views.cpython-312.pyc
+thrillwiki/__pycache__/wsgi.cpython-312.pyc
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+***REMOVED***
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.[AWS-SECRET-REMOVED]tBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items

.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,70 +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
-
-# on Windows, a path can contain colons and backslashes and has to be converted:
-if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
-    # transform D:\path\to\venv to /d/path/to/venv on MSYS
-    # and to /cygdrive/d/path/to/venv on Cygwin
-    export VIRTUAL_ENV=$(cygpath "/home/pac/thrillwiki/thrillwiki_django_no_react/.venv")
-else
-    # use the path as-is
-    export VIRTUAL_ENV="/home/pac/thrillwiki/thrillwiki_django_no_react/.venv"
-fi
-
-_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,27 +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 "/home/pac/thrillwiki/thrillwiki_django_no_react/.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 "/home/pac/thrillwiki/thrillwiki_django_no_react/.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/automat-visualize

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from automat._visualize import tool
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(tool())

.venv/bin/black

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from black import patched_main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(patched_main())

.venv/bin/blackd

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from blackd import patched_main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(patched_main())

.venv/bin/cftp

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.conch.scripts.cftp import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/ckeygen

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.conch.scripts.ckeygen import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/conch

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.conch.scripts.conch import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/coverage

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from coverage.cmdline import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/coverage-3.12

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from coverage.cmdline import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/coverage3

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from coverage.cmdline import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/daphne

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from daphne.cli import CommandLineInterface
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(CommandLineInterface.entrypoint())

.venv/bin/django-admin

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from django.core.management import execute_from_command_line
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(execute_from_command_line())

.venv/bin/dotenv

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from dotenv.__main__ import cli
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(cli())

.venv/bin/flake8

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

.venv/bin/mailmail

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.mail.scripts.mailmail import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/normalizer

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from charset_normalizer.cli import cli_detect
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(cli_detect())

.venv/bin/pip

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- 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 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- 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.12

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- 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/py.test

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pytest import console_main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(console_main())

.venv/bin/pycodestyle

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pycodestyle import _main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(_main())

.venv/bin/pyflakes

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pyflakes.api import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/pyhtmlizer

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.scripts.htmlizer import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/pytest

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from pytest import console_main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(console_main())

.venv/bin/python

@@ -1 +0,0 @@
-python3

.venv/bin/python3

@@ -1 +0,0 @@
-/usr/local/bin/python3

.venv/bin/python3.12

@@ -1 +0,0 @@
-python3

.venv/bin/sqlformat

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from sqlparse.__main__ import main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())

.venv/bin/tkconch

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.conch.scripts.tkconch import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/trial

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.scripts.trial import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/twist

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.application.twist._twist import Twist
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(Twist.main())

.venv/bin/twistd

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from twisted.scripts.twistd import run
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())

.venv/bin/wamp

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from autobahn.__main__ import _main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(_main())

.venv/bin/xbrnetwork

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from autobahn.xbr._cli import _main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(_main())

.venv/bin/xbrnetwork-ui

@@ -1,8 +0,0 @@
-#!/home/pac/thrillwiki/thrillwiki_django_no_react/.venv/bin/python3
-# -*- coding: utf-8 -*-
-import re
-import sys
-from autobahn.xbr._gui import _main
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
-    sys.exit(_main())

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/INSTALLER

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

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/LICENSE

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

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/METADATA

@@ -1,199 +0,0 @@
-Metadata-Version: 2.1
-Name: Automat
-Version: 24.8.1
-Summary: Self-service finite-state machines for the programmer on the go.
-Author-email: Glyph <code@glyph.im>
-License: Copyright (c) 2014
-        Rackspace
-        
-        Permission is hereby granted, free of charge, to any person obtaining
-        a copy of this software and associated documentation files (the
-        "Software"), to deal in the Software without restriction, including
-        without limitation the rights to use, copy, modify, merge, publish,
-        distribute, sublicense, and/or sell copies of the Software, and to
-        permit persons to whom the Software is furnished to do so, subject to
-        the following conditions:
-        
-        The above copyright notice and this permission notice shall be
-        included in all copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-        LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-        
-Project-URL: Documentation, https://automat.readthedocs.io/
-Project-URL: Source, https://github.com/glyph/automat/
-Keywords: fsm,state machine,automata
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typing-extensions; python_version < "3.10"
-Provides-Extra: visualize
-Requires-Dist: graphviz>0.5.1; extra == "visualize"
-Requires-Dist: Twisted>=16.1.1; extra == "visualize"
-
-# Automat #
-
-[![Documentation Status](https://readthedocs.org/projects/automat/badge/?version=latest)](http://automat.readthedocs.io/en/latest/)
-[![Build Status](https://github.com/glyph/automat/actions/workflows/ci.yml/badge.svg?branch=trunk)](https://github.com/glyph/automat/actions/workflows/ci.yml?query=branch%3Atrunk)
-[![Coverage Status](http://codecov.io/github/glyph/automat/coverage.svg?branch=trunk)](http://codecov.io/github/glyph/automat?branch=trunk)
-
-## Self-service finite-state machines for the programmer on the go. ##
-
-Automat is a library for concise, idiomatic Python expression of finite-state
-automata (particularly deterministic finite-state transducers).
-
-Read more here, or on [Read the Docs](https://automat.readthedocs.io/), or watch the following videos for an overview and presentation
-
-### Why use state machines? ###
-
-Sometimes you have to create an object whose behavior varies with its state,
-but still wishes to present a consistent interface to its callers.
-
-For example, let's say you're writing the software for a coffee machine.  It
-has a lid that can be opened or closed, a chamber for water, a chamber for
-coffee beans, and a button for "brew".
-
-There are a number of possible states for the coffee machine.  It might or
-might not have water.  It might or might not have beans.  The lid might be open
-or closed.  The "brew" button should only actually attempt to brew coffee in
-one of these configurations, and the "open lid" button should only work if the
-coffee is not, in fact, brewing.
-
-With diligence and attention to detail, you can implement this correctly using
-a collection of attributes on an object; `hasWater`, `hasBeans`, `isLidOpen`
-and so on.  However, you have to keep all these attributes consistent.  As the
-coffee maker becomes more complex - perhaps you add an additional chamber for
-flavorings so you can make hazelnut coffee, for example - you have to keep
-adding more and more checks and more and more reasoning about which
-combinations of states are allowed.
-
-Rather than adding tedious `if` checks to every single method to make sure that
-each of these flags are exactly what you expect, you can use a state machine to
-ensure that if your code runs at all, it will be run with all the required
-values initialized, because they have to be called in the order you declare
-them.
-
-You can read about state machines and their advantages for Python programmers
-in more detail [in this excellent article by Jean-Paul
-Calderone](https://web.archive.org/web/20160507053658/https://clusterhq.com/2013/12/05/what-is-a-state-machine/).
-
-### What makes Automat different? ###
-
-There are
-[dozens of libraries on PyPI implementing state machines](https://pypi.org/search/?q=finite+state+machine).
-So it behooves me to say why yet another one would be a good idea.
-
-Automat is designed around this principle: while organizing your code around
-state machines is a good idea, your callers don't, and shouldn't have to, care
-that you've done so.  In Python, the "input" to a stateful system is a method
-call; the "output" may be a method call, if you need to invoke a side effect,
-or a return value, if you are just performing a computation in memory.  Most
-other state-machine libraries require you to explicitly create an input object,
-provide that object to a generic "input" method, and then receive results,
-sometimes in terms of that library's interfaces and sometimes in terms of
-classes you define yourself.
-
-For example, a snippet of the coffee-machine example above might be implemented
-as follows in naive Python:
-
-```python
-class CoffeeMachine(object):
-    def brewButton(self) -> None:
-        if self.hasWater and self.hasBeans and not self.isLidOpen:
-            self.heatTheHeatingElement()
-            # ...
-```
-
-With Automat, you'd begin with a `typing.Protocol` that describes all of your
-inputs:
-
-```python
-from typing import Protocol
-
-class CoffeeBrewer(Protocol):
-    def brewButton(self) -> None:
-        "The user pressed the 'brew' button."
-    def putInBeans(self) -> None:
-        "The user put in some beans."
-```
-
-We'll then need a concrete class to contain the shared core of state shared
-among the different states:
-
-```python
-from dataclasses import dataclass
-
-@dataclass
-class BrewerCore:
-    heatingElement: HeatingElement
-```
-
-Next, we need to describe our state machine, including all of our states.  For
-simplicity's sake let's say that the only two states are `noBeans` and
-`haveBeans`:
-
-```python
-from automat import TypeMachineBuilder
-
-builder = TypeMachineBuilder(CoffeeBrewer, BrewerCore)
-noBeans = builder.state("noBeans")
-haveBeans = builder.state("haveBeans")
-```
-
-Next we can describe a simple transition; when we put in beans, we move to the
-`haveBeans` state, with no other behavior.
-
-```python
-# When we don't have beans, upon putting in beans, we will then have beans
-noBeans.upon(CoffeeBrewer.putInBeans).to(haveBeans).returns(None)
-```
-
-And then another transition that we describe with a decorator, one that *does*
-have some behavior, that needs to heat up the heating element to brew the
-coffee:
-
-```python
-@haveBeans.upon(CoffeeBrewer.brewButton).to(noBeans)
-def heatUp(inputs: CoffeeBrewer, core: BrewerCore) -> None:
-    """
-    When we have beans, upon pressing the brew button, we will then not have
-    beans any more (as they have been entered into the brewing chamber) and
-    our output will be heating the heating element.
-    """
-    print("Brewing the coffee...")
-    core.heatingElement.turnOn()
-```
-
-Then we finalize the state machine by building it, which gives us a callable
-that takes a `BrewerCore` and returns a synthetic `CoffeeBrewer`
-
-```python
-newCoffeeMachine = builder.build()
-```
-
-```python
->>> coffee = newCoffeeMachine(BrewerCore(HeatingElement()))
->>> machine.putInBeans()
->>> machine.brewButton()
-Brewing the coffee...
-```
-
-All of the *inputs* are provided by calling them like methods, all of the
-*output behaviors* are automatically invoked when they are produced according
-to the outputs specified to `upon` and all of the states are simply opaque
-tokens.

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/RECORD

@@ -1,39 +0,0 @@
-../../../bin/automat-visualize,sha256=IsKluasmdX-znO8xCKiVIZ1zYKnBxs3ykFbJ3SxJ4vs,266
-Automat-24.8.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-Automat-24.8.1.dist-info/LICENSE,[AWS-SECRET-REMOVED]zv_-9TA43Y,1053
-Automat-24.8.1.dist-info/METADATA,sha256=XJIxL4Olb15WCoAdVEcORum39__wiCXQR6LNubERZ6M,8396
-Automat-24.8.1.dist-info/RECORD,,
-Automat-24.8.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-Automat-24.8.1.dist-info/entry_points.txt,[AWS-SECRET-REMOVED]rPNlGi7NbQ,62
-Automat-24.8.1.dist-info/top_level.txt,sha256=vg4zAOyhP_3YCmpKZLNgFw1uMF3lC_b6TKsdz7jBSpI,8
-automat/__init__.py,[AWS-SECRET-REMOVED]WD_RltPB-U,356
-automat/__pycache__/__init__.cpython-312.pyc,,
-automat/__pycache__/_core.cpython-312.pyc,,
-automat/__pycache__/_discover.cpython-312.pyc,,
-automat/__pycache__/_introspection.cpython-312.pyc,,
-automat/__pycache__/_methodical.cpython-312.pyc,,
-automat/__pycache__/_runtimeproto.cpython-312.pyc,,
-automat/__pycache__/_typed.cpython-312.pyc,,
-automat/__pycache__/_visualize.cpython-312.pyc,,
-automat/_core.py,sha256=oe4QNlfvmgsnKe_8fyNiOsHsfz5xPArGuXWle9zePp8,6663
-automat/_discover.py,sha256=KRbmm7kxpd-WReDQU4qe6hVKGUKmGBHUjYIkRneO4mc,5197
-automat/_introspection.py,sha256=uF5ymY-GZckyRxvRs7UToPBV_oVV6xHmvlBVey9nv80,1441
-automat/_methodical.py,sha256=YgZXraDe6dvK6w_Y9xfPa0kXCka4ZeGLfcb4IfK4bnI,17243
-automat/_runtimeproto.py,sha256=mJ_[AWS-SECRET-REMOVED],1654
-automat/_test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-automat/_test/__pycache__/__init__.cpython-312.pyc,,
-automat/_test/__pycache__/test_core.cpython-312.pyc,,
-automat/_test/__pycache__/test_discover.cpython-312.pyc,,
-automat/_test/__pycache__/test_methodical.cpython-312.pyc,,
-automat/_test/__pycache__/test_trace.cpython-312.pyc,,
-automat/_test/__pycache__/test_type_based.cpython-312.pyc,,
-automat/_test/__pycache__/test_visualize.cpython-312.pyc,,
-automat/_test/test_core.py,sha256=PJHNvQ85i8vjH-oF6nPNKB84_noTyl2dQSv_iRl70J8,3481
-automat/_test/test_discover.py,[AWS-SECRET-REMOVED]Gg7kQnbvtw,22067
-automat/_test/test_methodical.py,sha256=SKMMbl-6bjH-QZ1hDFRItCOyKF4SstuA4QvExnVhn7w,20267
-automat/_test/test_trace.py,sha256=tty7P_ctJtk38ZXnpmEy-J9Rn-Hh2AKb_ia6EmtXSQI,3299
-automat/_test/test_type_based.py,[AWS-SECRET-REMOVED]AegU_OUvko,17872
-automat/_test/test_visualize.py,sha256=HXBPgMAD0OTz_l1Yq0lI3d1vJ_l3sHTH67Jauaf-2sk,14631
-automat/_typed.py,sha256=lMzMgUfX713Xw_W4pr8iyPqcdpRSbu4rEpRlrXAOW2k,24204
-automat/_visualize.py,sha256=DQYig2mBKX-LquPEEy89Y_qyj21tSutAUaFsF1F64ws,6512
-automat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/WHEEL

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

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-automat-visualize = automat._visualize:tool

.venv/lib/python3.12/site-packages/Automat-24.8.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-automat

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/INSTALLER

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

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/LICENSE

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

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/LICENSE.python

@@ -1,288 +0,0 @@
-Django is licensed under the three-clause BSD license; see the file
-LICENSE for details.
-
-Django includes code from the Python standard library, which is licensed under
-the Python license, a permissive open source license. The copyright and license
-is included below for compliance with Python's terms.
-
-----------------------------------------------------------------------
-
-Copyright (c) 2001-present Python Software Foundation; All Rights Reserved
-
-A. HISTORY OF THE SOFTWARE
-==========================
-
-Python was created in the early 1990s by Guido van Rossum at Stichting
-Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
-as a successor of a language called ABC.  Guido remains Python's
-principal author, although it includes many contributions from others.
-
-In 1995, Guido continued his work on Python at the Corporation for
-National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
-in Reston, Virginia where he released several versions of the
-software.
-
-In May 2000, Guido and the Python core development team moved to
-BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
-year, the PythonLabs team moved to Digital Creations, which became
-Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
-https://www.python.org/psf/) was formed, a non-profit organization
-created specifically to own Python-related Intellectual Property.
-Zope Corporation was a sponsoring member of the PSF.
-
-All Python releases are Open Source (see https://opensource.org for
-the Open Source Definition).  Historically, most, but not all, Python
-releases have also been GPL-compatible; the table below summarizes
-the various releases.
-
-    Release         Derived     Year        Owner       GPL-
-                    from                                compatible? (1)
-
-    0.9.0 thru 1.2              1991-1995   CWI         yes
-    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
-    1.6             1.5.2       2000        CNRI        no
-    2.0             1.6         2000        BeOpen.com  no
-    1.6.1           1.6         2001        CNRI        yes (2)
-    2.1             2.0+1.6.1   2001        PSF         no
-    2.0.1           2.0+1.6.1   2001        PSF         yes
-    2.1.1           2.1+2.0.1   2001        PSF         yes
-    2.1.2           2.1.1       2002        PSF         yes
-    2.1.3           2.1.2       2002        PSF         yes
-    2.2 and above   2.1.1       2001-now    PSF         yes
-
-Footnotes:
-
-(1) GPL-compatible doesn't mean that we're distributing Python under
-    the GPL.  All Python licenses, unlike the GPL, let you distribute
-    a modified version without making your changes open source.  The
-    GPL-compatible licenses make it possible to combine Python with
-    other software that is released under the GPL; the others don't.
-
-(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
-    because its license has a choice of law clause.  According to
-    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
-    is "not incompatible" with the GPL.
-
-Thanks to the many outside volunteers who have worked under Guido's
-direction to make these releases possible.
-
-
-B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
-[AWS-SECRET-REMOVED]=======================
-
-Python software and documentation are licensed under the
-Python Software Foundation License Version 2.
-
-Starting with Python 3.8.6, examples, recipes, and other code in
-the documentation are dual licensed under the PSF License Version 2
-and the Zero-Clause BSD license.
-
-Some software incorporated into Python is under different licenses.
-The licenses are listed with code falling under that license.
-
-
-PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
---------------------------------------------
-
-1. This LICENSE AGREEMENT is between the Python Software Foundation
-("PSF"), and the Individual or Organization ("Licensee") accessing and
-otherwise using this software ("Python") in source or binary form and
-its associated documentation.
-
-2. Subject to the terms and conditions of this License Agreement, PSF hereby
-grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
-analyze, test, perform and/or display publicly, prepare derivative works,
-distribute, and otherwise use Python alone or in any derivative version,
-provided, however, that PSF's License Agreement and PSF's notice of copyright,
-i.e., "Copyright (c) 2001-2024 Python Software Foundation; All Rights Reserved"
-are retained in Python alone or in any derivative version prepared by Licensee.
-
-3. In the event Licensee prepares a derivative work that is based on
-or incorporates Python or any part thereof, and wants to make
-the derivative work available to others as provided herein, then
-Licensee hereby agrees to include in any such work a brief summary of
-the changes made to Python.
-
-4. PSF is making Python available to Licensee on an "AS IS"
-basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
-IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
-DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
-FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
-INFRINGE ANY THIRD PARTY RIGHTS.
-
-5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
-FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
-A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
-OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-
-6. This License Agreement will automatically terminate upon a material
-breach of its terms and conditions.
-
-7. Nothing in this License Agreement shall be deemed to create any
-relationship of agency, partnership, or joint venture between PSF and
-Licensee.  This License Agreement does not grant permission to use PSF
-trademarks or trade name in a trademark sense to endorse or promote
-products or services of Licensee, or any third party.
-
-8. By copying, installing or otherwise using Python, Licensee
-agrees to be bound by the terms and conditions of this License
-Agreement.
-
-
-BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
--------------------------------------------
-
-BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
-
-1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
-office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
-Individual or Organization ("Licensee") accessing and otherwise using
-this software in source or binary form and its associated
-documentation ("the Software").
-
-2. Subject to the terms and conditions of this BeOpen Python License
-Agreement, BeOpen hereby grants Licensee a non-exclusive,
-royalty-free, world-wide license to reproduce, analyze, test, perform
-and/or display publicly, prepare derivative works, distribute, and
-otherwise use the Software alone or in any derivative version,
-provided, however, that the BeOpen Python License is retained in the
-Software, alone or in any derivative version prepared by Licensee.
-
-3. BeOpen is making the Software available to Licensee on an "AS IS"
-basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
-IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
-DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
-FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
-INFRINGE ANY THIRD PARTY RIGHTS.
-
-4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
-SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
-AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
-DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-
-5. This License Agreement will automatically terminate upon a material
-breach of its terms and conditions.
-
-6. This License Agreement shall be governed by and interpreted in all
-respects by the law of the State of California, excluding conflict of
-law provisions.  Nothing in this License Agreement shall be deemed to
-create any relationship of agency, partnership, or joint venture
-between BeOpen and Licensee.  This License Agreement does not grant
-permission to use BeOpen trademarks or trade names in a trademark
-sense to endorse or promote products or services of Licensee, or any
-third party.  As an exception, the "BeOpen Python" logos available at
-http://www.pythonlabs.com/logos.html may be used according to the
-permissions granted on that web page.
-
-7. By copying, installing or otherwise using the software, Licensee
-agrees to be bound by the terms and conditions of this License
-Agreement.
-
-
-CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
----------------------------------------
-
-1. This LICENSE AGREEMENT is between the Corporation for National
-Research Initiatives, having an office at 1895 Preston White Drive,
-Reston, VA 20191 ("CNRI"), and the Individual or Organization
-("Licensee") accessing and otherwise using Python 1.6.1 software in
-source or binary form and its associated documentation.
-
-2. Subject to the terms and conditions of this License Agreement, CNRI
-hereby grants Licensee a nonexclusive, royalty-free, world-wide
-license to reproduce, analyze, test, perform and/or display publicly,
-prepare derivative works, distribute, and otherwise use Python 1.6.1
-alone or in any derivative version, provided, however, that CNRI's
-License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
-1995-2001 Corporation for National Research Initiatives; All Rights
-Reserved" are retained in Python 1.6.1 alone or in any derivative
-version prepared by Licensee.  Alternately, in lieu of CNRI's License
-Agreement, Licensee may substitute the following text (omitting the
-quotes): "Python 1.6.1 is made available subject to the terms and
-conditions in CNRI's License Agreement.  This Agreement together with
-Python 1.6.1 may be located on the internet using the following
-unique, persistent identifier (known as a handle): 1895.22/1013.  This
-Agreement may also be obtained from a proxy server on the internet
-using the following URL: http://hdl.handle.net/1895.22/1013".
-
-3. In the event Licensee prepares a derivative work that is based on
-or incorporates Python 1.6.1 or any part thereof, and wants to make
-the derivative work available to others as provided herein, then
-Licensee hereby agrees to include in any such work a brief summary of
-the changes made to Python 1.6.1.
-
-4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
-basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
-IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
-DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
-FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
-INFRINGE ANY THIRD PARTY RIGHTS.
-
-5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
-1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
-A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
-OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
-
-6. This License Agreement will automatically terminate upon a material
-breach of its terms and conditions.
-
-7. This License Agreement shall be governed by the federal
-intellectual property law of the United States, including without
-limitation the federal copyright law, and, to the extent such
-U.S. federal law does not apply, by the law of the Commonwealth of
-Virginia, excluding Virginia's conflict of law provisions.
-Notwithstanding the foregoing, with regard to derivative works based
-on Python 1.6.1 that incorporate non-separable material that was
-previously distributed under the GNU General Public License (GPL), the
-law of the Commonwealth of Virginia shall govern this License
-Agreement only as to issues arising under or with respect to
-Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
-License Agreement shall be deemed to create any relationship of
-agency, partnership, or joint venture between CNRI and Licensee.  This
-License Agreement does not grant permission to use CNRI trademarks or
-trade name in a trademark sense to endorse or promote products or
-services of Licensee, or any third party.
-
-8. By clicking on the "ACCEPT" button where indicated, or by copying,
-installing or otherwise using Python 1.6.1, Licensee agrees to be
-bound by the terms and conditions of this License Agreement.
-
-        ACCEPT
-
-
-CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
---------------------------------------------------
-
-Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
-The Netherlands.  All rights reserved.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Stichting Mathematisch
-Centrum or CWI not be used in advertising or publicity pertaining to
-distribution of the software without specific, written prior
-permission.
-
-STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
-FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
-----------------------------------------------------------------------
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/METADATA

@@ -1,100 +0,0 @@
-Metadata-Version: 2.1
-Name: Django
-Version: 5.1.2
-Summary: A high-level Python web framework that encourages rapid development and clean, pragmatic design.
-Author-email: Django Software Foundation <foundation@djangoproject.com>
-License: BSD-3-Clause
-Project-URL: Homepage, https://www.djangoproject.com/
-Project-URL: Documentation, https://docs.djangoproject.com/
-Project-URL: Release notes, https://docs.djangoproject.com/en/stable/releases/
-Project-URL: Funding, https://www.djangoproject.com/fundraising/
-Project-URL: Source, https://github.com/django/django
-Project-URL: Tracker, https://code.djangoproject.com/
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Django
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-License-File: LICENSE.python
-License-File: AUTHORS
-Requires-Dist: asgiref<4,>=3.8.1
-Requires-Dist: sqlparse>=0.3.1
-Requires-Dist: tzdata; sys_platform == "win32"
-Provides-Extra: argon2
-Requires-Dist: argon2-cffi>=19.1.0; extra == "argon2"
-Provides-Extra: bcrypt
-Requires-Dist: bcrypt; extra == "bcrypt"
-
-======
-Django
-======
-
-Django is a high-level Python web framework that encourages rapid development
-and clean, pragmatic design. Thanks for checking it out.
-
-All documentation is in the "``docs``" directory and online at
-https://docs.djangoproject.com/en/stable/. If you're just getting started,
-here's how we recommend you read the docs:
-
-* First, read ``docs/intro/install.txt`` for instructions on installing Django.
-
-* Next, work through the tutorials in order (``docs/intro/tutorial01.txt``,
-  ``docs/intro/tutorial02.txt``, etc.).
-
-* If you want to set up an actual deployment server, read
-  ``docs/howto/deployment/index.txt`` for instructions.
-
-* You'll probably want to read through the topical guides (in ``docs/topics``)
-  next; from there you can jump to the HOWTOs (in ``docs/howto``) for specific
-  problems, and check out the reference (``docs/ref``) for gory details.
-
-* See ``docs/README`` for instructions on building an HTML version of the docs.
-
-Docs are updated rigorously. If you find any problems in the docs, or think
-they should be clarified in any way, please take 30 seconds to fill out a
-ticket here: https://code.djangoproject.com/newticket
-
-To get more help:
-
-* Join the ``#django`` channel on ``irc.libera.chat``. Lots of helpful people
-  hang out there. `Webchat is available <https://web.libera.chat/#django>`_.
-
-* Join the django-users mailing list, or read the archives, at
-  https://groups.google.com/group/django-users.
-
-* Join the `Django Discord community <https://discord.gg/xcRH6mN4fa>`_.
-
-* Join the community on the `Django Forum <https://forum.djangoproject.com/>`_.
-
-To contribute to Django:
-
-* Check out https://docs.djangoproject.com/en/dev/internals/contributing/ for
-  information about getting involved.
-
-To run Django's test suite:
-
-* Follow the instructions in the "Unit tests" section of
-  ``docs/internals/contributing/writing-code/unit-tests.txt``, published online at
-  https://docs.djangoproject.[AWS-SECRET-REMOVED]g-code/unit-tests/#running-the-unit-tests
-
-Supporting the Development of Django
-====================================
-
-Django's development depends on your contributions.
-
-If you depend on Django, remember to support the Django Software Foundation: https://www.djangoproject.com/fundraising/

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/WHEEL

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

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-django-admin = django.core.management:execute_from_command_line

.venv/lib/python3.12/site-packages/Django-5.1.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-django

.venv/lib/python3.12/site-packages/OpenSSL/__init__.py

@@ -1,31 +0,0 @@
-# Copyright (C) AB Strakt
-# See LICENSE for details.
-
-"""
-pyOpenSSL - A simple wrapper around the OpenSSL library
-"""
-
-from OpenSSL import SSL, crypto
-from OpenSSL.version import (
-    __author__,
-    __copyright__,
-    __email__,
-    __license__,
-    __summary__,
-    __title__,
-    __uri__,
-    __version__,
-)
-
-__all__ = [
-    "SSL",
-    "crypto",
-    "__author__",
-    "__copyright__",
-    "__email__",
-    "__license__",
-    "__summary__",
-    "__title__",
-    "__uri__",
-    "__version__",
-]

.venv/lib/python3.12/site-packages/OpenSSL/_util.py

@@ -1,124 +0,0 @@
-import os
-import sys
-import warnings
-from typing import Any, Callable, NoReturn, Type, Union
-
-from cryptography.hazmat.bindings.openssl.binding import Binding
-
-StrOrBytesPath = Union[str, bytes, os.PathLike]
-
-binding = Binding()
-ffi = binding.ffi
-lib = binding.lib
-
-
-# This is a special CFFI allocator that does not bother to zero its memory
-# after allocation. This has vastly better performance on large allocations and
-# so should be used whenever we don't need the memory zeroed out.
-no_zero_allocator = ffi.new_allocator(should_clear_after_alloc=False)
-
-
-def text(charp: Any) -> str:
-    """
-    Get a native string type representing of the given CFFI ``char*`` object.
-
-    :param charp: A C-style string represented using CFFI.
-
-    :return: :class:`str`
-    """
-    if not charp:
-        return ""
-    return ffi.string(charp).decode("utf-8")
-
-
-def exception_from_error_queue(exception_type: Type[Exception]) -> NoReturn:
-    """
-    Convert an OpenSSL library failure into a Python exception.
-
-    When a call to the native OpenSSL library fails, this is usually signalled
-    by the return value, and an error code is stored in an error queue
-    associated with the current thread. The err library provides functions to
-    obtain these error codes and textual error messages.
-    """
-    errors = []
-
-    while True:
-        error = lib.ERR_get_error()
-        if error == 0:
-            break
-        errors.append(
-            (
-                text(lib.ERR_lib_error_string(error)),
-                text(lib.ERR_func_error_string(error)),
-                text(lib.ERR_reason_error_string(error)),
-            )
-        )
-
-    raise exception_type(errors)
-
-
-def make_assert(error: Type[Exception]) -> Callable[[bool], Any]:
-    """
-    Create an assert function that uses :func:`exception_from_error_queue` to
-    raise an exception wrapped by *error*.
-    """
-
-    def openssl_assert(ok: bool) -> None:
-        """
-        If *ok* is not True, retrieve the error from OpenSSL and raise it.
-        """
-        if ok is not True:
-            exception_from_error_queue(error)
-
-    return openssl_assert
-
-
-def path_bytes(s: StrOrBytesPath) -> bytes:
-    """
-    Convert a Python path to a :py:class:`bytes` for the path which can be
-    passed into an OpenSSL API accepting a filename.
-
-    :param s: A path (valid for os.fspath).
-
-    :return: An instance of :py:class:`bytes`.
-    """
-    b = os.fspath(s)
-
-    if isinstance(b, str):
-        return b.encode(sys.getfilesystemencoding())
-    else:
-        return b
-
-
-def byte_string(s: str) -> bytes:
-    return s.encode("charmap")
-
-
-# A marker object to observe whether some optional arguments are passed any
-# value or not.
-UNSPECIFIED = object()
-
-_TEXT_WARNING = "str for {0} is no longer accepted, use bytes"
-
-
-def text_to_bytes_and_warn(label: str, obj: Any) -> Any:
-    """
-    If ``obj`` is text, emit a warning that it should be bytes instead and try
-    to convert it to bytes automatically.
-
-    :param str label: The name of the parameter from which ``obj`` was taken
-        (so a developer can easily find the source of the problem and correct
-        it).
-
-    :return: If ``obj`` is the text string type, a ``bytes`` object giving the
-        UTF-8 encoding of that text is returned.  Otherwise, ``obj`` itself is
-        returned.
-    """
-    if isinstance(obj, str):
-        warnings.warn(
-            _TEXT_WARNING.format(label),
-            category=DeprecationWarning,
-            stacklevel=3,
-        )
-        return obj.encode("utf-8")
-    return obj

.venv/lib/python3.12/site-packages/OpenSSL/debug.py

@@ -1,40 +0,0 @@
-import ssl
-import sys
-
-import cffi
-import cryptography
-
-import OpenSSL.SSL
-
-from . import version
-
-_env_info = """\
-pyOpenSSL: {pyopenssl}
-cryptography: {cryptography}
-cffi: {cffi}
-cryptography's compiled against OpenSSL: {crypto_openssl_compile}
-cryptography's linked OpenSSL: {crypto_openssl_link}
-Python's OpenSSL: {python_openssl}
-Python executable: {python}
-Python version: {python_version}
-Platform: {platform}
-sys.path: {sys_path}""".format(
-    pyopenssl=version.__version__,
-    crypto_openssl_compile=OpenSSL._util.ffi.string(
-        OpenSSL._util.lib.OPENSSL_VERSION_TEXT,
-    ).decode("ascii"),
-    crypto_openssl_link=OpenSSL.SSL.SSLeay_version(
-        OpenSSL.SSL.SSLEAY_VERSION
-    ).decode("ascii"),
-    python_openssl=getattr(ssl, "OPENSSL_VERSION", "n/a"),
-    cryptography=cryptography.__version__,
-    cffi=cffi.__version__,
-    python=sys.executable,
-    python_version=sys.version,
-    platform=sys.platform,
-    sys_path=sys.path,
-)
-
-
-if __name__ == "__main__":
-    print(_env_info)

.venv/lib/python3.12/site-packages/OpenSSL/rand.py

@@ -1,40 +0,0 @@
-"""
-PRNG management routines, thin wrappers.
-"""
-
-from OpenSSL._util import lib as _lib
-
-
-def add(buffer: bytes, entropy: int) -> None:
-    """
-    Mix bytes from *string* into the PRNG state.
-
-    The *entropy* argument is (the lower bound of) an estimate of how much
-    randomness is contained in *string*, measured in bytes.
-
-    For more information, see e.g. :rfc:`1750`.
-
-    This function is only relevant if you are forking Python processes and
-    need to reseed the CSPRNG after fork.
-
-    :param buffer: Buffer with random data.
-    :param entropy: The entropy (in bytes) measurement of the buffer.
-
-    :return: :obj:`None`
-    """
-    if not isinstance(buffer, bytes):
-        raise TypeError("buffer must be a byte string")
-
-    if not isinstance(entropy, int):
-        raise TypeError("entropy must be an integer")
-
-    _lib.RAND_add(buffer, len(buffer), entropy)
-
-
-def status() -> int:
-    """
-    Check whether the PRNG has been seeded with enough data.
-
-    :return: 1 if the PRNG is seeded enough, 0 otherwise.
-    """
-    return _lib.RAND_status()

.venv/lib/python3.12/site-packages/OpenSSL/version.py

@@ -1,28 +0,0 @@
-# Copyright (C) AB Strakt
-# Copyright (C) Jean-Paul Calderone
-# See LICENSE for details.
-
-"""
-pyOpenSSL - A simple wrapper around the OpenSSL library
-"""
-
-__all__ = [
-    "__author__",
-    "__copyright__",
-    "__email__",
-    "__license__",
-    "__summary__",
-    "__title__",
-    "__uri__",
-    "__version__",
-]
-
-__version__ = "24.2.1"
-
-__title__ = "pyOpenSSL"
-__uri__ = "https://pyopenssl.org/"
-__summary__ = "Python wrapper module around the OpenSSL library"
-__author__ = "The pyOpenSSL developers"
-__email__ = "cryptography-dev@python.org"
-__license__ = "Apache License, Version 2.0"
-__copyright__ = f"Copyright 2001-2024 {__author__}"

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

@@ -1,133 +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
-
-bdf_slant = {
-    "R": "Roman",
-    "I": "Italic",
-    "O": "Oblique",
-    "RI": "Reverse Italic",
-    "RO": "Reverse Oblique",
-    "OT": "Other",
-}
-
-bdf_spacing = {"P": "Proportional", "M": "Monospaced", "C": "Cell"}
-
-
-def bdf_char(
-    f: BinaryIO,
-) -> (
-    tuple[
-        str,
-        int,
-        tuple[tuple[int, int], tuple[int, int, int, int], tuple[int, int, int, int]],
-        Image.Image,
-    ]
-    | None
-):
-    # skip to STARTCHAR
-    while True:
-        s = f.readline()
-        if not s:
-            return None
-        if s[:9] == b"STARTCHAR":
-            break
-    id = s[9:].strip().decode("ascii")
-
-    # load symbol properties
-    props = {}
-    while True:
-        s = f.readline()
-        if not s or s[:6] == b"BITMAP":
-            break
-        i = s.find(b" ")
-        props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
-
-    # load bitmap
-    bitmap = bytearray()
-    while True:
-        s = f.readline()
-        if not s or s[:7] == b"ENDCHAR":
-            break
-        bitmap += s[:-1]
-
-    # The word BBX
-    # followed by the width in x (BBw), height in y (BBh),
-    # and x and y displacement (BBxoff0, BByoff0)
-    # of the lower left corner from the origin of the character.
-    width, height, x_disp, y_disp = (int(p) for p in props["BBX"].split())
-
-    # The word DWIDTH
-    # followed by the width in x and y of the character in device pixels.
-    dwx, dwy = (int(p) for p in props["DWIDTH"].split())
-
-    bbox = (
-        (dwx, dwy),
-        (x_disp, -y_disp - height, width + x_disp, -y_disp),
-        (0, 0, width, height),
-    )
-
-    try:
-        im = Image.frombytes("1", (width, height), bitmap, "hex", "1")
-    except ValueError:
-        # deal with zero-width characters
-        im = Image.new("1", (width, height))
-
-    return id, int(props["ENCODING"]), bbox, im
-
-
-class BdfFontFile(FontFile.FontFile):
-    """Font file plugin for the X11 BDF format."""
-
-    def __init__(self, fp: BinaryIO) -> None:
-        super().__init__()
-
-        s = fp.readline()
-        if s[:13] != b"STARTFONT 2.1":
-            msg = "not a valid BDF file"
-            raise SyntaxError(msg)
-
-        props = {}
-        comments = []
-
-        while True:
-            s = fp.readline()
-            if not s or s[:13] == b"ENDPROPERTIES":
-                break
-            i = s.find(b" ")
-            props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
-            if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
-                if s.find(b"LogicalFontDescription") < 0:
-                    comments.append(s[i + 1 : -1].decode("ascii"))
-
-        while True:
-            c = bdf_char(fp)
-            if not c:
-                break
-            id, ch, (xy, dst, src), im = c
-            if 0 <= ch < len(self.glyph):
-                self.glyph[ch] = xy, dst, src, im

.venv/lib/python3.12/site-packages/PIL/BlpImagePlugin.py

@@ -1,493 +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[:4] in (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)
-
-        self.fp.seek(5, os.SEEK_CUR)
-        (self._blp_alpha_depth,) = struct.unpack("<b", self.fp.read(1))
-
-        self.fp.seek(2, os.SEEK_CUR)
-        self._size = struct.unpack("<II", self.fp.read(8))
-
-        if self.magic in (b"BLP1", b"BLP2"):
-            decoder = self.magic.decode()
-        else:
-            msg = f"Bad BLP magic {repr(self.magic)}"
-            raise BLPFormatError(msg)
-
-        self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
-        self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
-
-
-class _BLPBaseDecoder(ImageFile.PyDecoder):
-    _pulls_fd = True
-
-    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
-        try:
-            self._read_blp_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_blp_header(self) -> None:
-        assert self.fd is not None
-        self.fd.seek(4)
-        (self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
-
-        (self._blp_encoding,) = struct.unpack("<b", self._safe_read(1))
-        (self._blp_alpha_depth,) = struct.unpack("<b", self._safe_read(1))
-        (self._blp_alpha_encoding,) = struct.unpack("<b", self._safe_read(1))
-        self.fd.seek(1, os.SEEK_CUR)  # mips
-
-        self.size = struct.unpack("<II", self._safe_read(8))
-
-        if isinstance(self, BLP1Decoder):
-            # Only present for BLP1
-            (self._blp_encoding,) = struct.unpack("<i", self._safe_read(4))
-            self.fd.seek(4, os.SEEK_CUR)  # subtype
-
-        self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
-        self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
-
-    def _safe_read(self, length: 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]]) -> bytearray:
-        data = bytearray()
-        _data = BytesIO(self._safe_read(self._blp_lengths[0]))
-        while True:
-            try:
-                (offset,) = struct.unpack("<B", _data.read(1))
-            except struct.error:
-                break
-            b, g, r, a = palette[offset]
-            d: tuple[int, ...] = (r, g, b)
-            if self._blp_alpha_depth:
-                d += (a,)
-            data.extend(d)
-        return data
-
-
-class BLP1Decoder(_BLPBaseDecoder):
-    def _load(self) -> None:
-        if self._blp_compression == Format.JPEG:
-            self._decode_jpeg_stream()
-
-        elif self._blp_compression == 1:
-            if self._blp_encoding in (4, 5):
-                palette = self._read_palette()
-                data = self._read_bgra(palette)
-                self.set_as_raw(data)
-            else:
-                msg = f"Unsupported BLP encoding {repr(self._blp_encoding)}"
-                raise BLPFormatError(msg)
-        else:
-            msg = f"Unsupported BLP compression {repr(self._blp_encoding)}"
-            raise BLPFormatError(msg)
-
-    def _decode_jpeg_stream(self) -> 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._blp_offsets[0] - self.fd.tell())  # What IS this?
-        data = self._safe_read(self._blp_lengths[0])
-        data = jpeg_header + data
-        image = JpegImageFile(BytesIO(data))
-        Image._decompression_bomb_check(image.size)
-        if image.mode == "CMYK":
-            decoder_name, extents, offset, args = image.tile[0]
-            assert isinstance(args, tuple)
-            image.tile = [
-                ImageFile._Tile(decoder_name, extents, offset, (args[0], "CMYK"))
-            ]
-        r, g, b = image.convert("RGB").split()
-        reversed_image = Image.merge("RGB", (b, g, r))
-        self.set_as_raw(reversed_image.tobytes())
-
-
-class BLP2Decoder(_BLPBaseDecoder):
-    def _load(self) -> None:
-        palette = self._read_palette()
-
-        assert self.fd is not None
-        self.fd.seek(self._blp_offsets[0])
-
-        if self._blp_compression == 1:
-            # Uncompressed or DirectX compression
-
-            if self._blp_encoding == Encoding.UNCOMPRESSED:
-                data = self._read_bgra(palette)
-
-            elif self._blp_encoding == Encoding.DXT:
-                data = bytearray()
-                if self._blp_alpha_encoding == AlphaEncoding.DXT1:
-                    linesize = (self.size[0] + 3) // 4 * 8
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt1(
-                            self._safe_read(linesize), alpha=bool(self._blp_alpha_depth)
-                        ):
-                            data += d
-
-                elif self._blp_alpha_encoding == AlphaEncoding.DXT3:
-                    linesize = (self.size[0] + 3) // 4 * 16
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt3(self._safe_read(linesize)):
-                            data += d
-
-                elif self._blp_alpha_encoding == AlphaEncoding.DXT5:
-                    linesize = (self.size[0] + 3) // 4 * 16
-                    for yb in range((self.size[1] + 3) // 4):
-                        for d in decode_dxt5(self._safe_read(linesize)):
-                            data += d
-                else:
-                    msg = f"Unsupported alpha encoding {repr(self._blp_alpha_encoding)}"
-                    raise BLPFormatError(msg)
-            else:
-                msg = f"Unknown BLP encoding {repr(self._blp_encoding)}"
-                raise BLPFormatError(msg)
-
-        else:
-            msg = f"Unknown BLP compression {repr(self._blp_compression)}"
-            raise BLPFormatError(msg)
-
-        self.set_as_raw(data)
-
-
-class BLPEncoder(ImageFile.PyEncoder):
-    _pushes_fd = True
-
-    def _write_palette(self) -> 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
-    fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
-    fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
-    fp.write(struct.pack("<b", 0))  # alpha encoding
-    fp.write(struct.pack("<b", 0))  # mips
-    fp.write(struct.pack("<II", *im.size))
-    if magic == b"BLP1":
-        fp.write(struct.pack("<i", 5))
-        fp.write(struct.pack("<i", 0))
-
-    ImageFile._save(im, fp, [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.12/site-packages/PIL/BmpImagePlugin.py

@@ -1,511 +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"),
-}
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix[:2] == b"BM"
-
-
-def _dib_accept(prefix: bytes) -> bool:
-    return i32(prefix) in [12, 40, 52, 56, 64, 108, 124]
-
-
-# [AWS-SECRET-REMOVED]=====================================
-# Image plugin for the Windows BMP format.
-# [AWS-SECRET-REMOVED]=====================================
-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:  # 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
-
-
-# [AWS-SECRET-REMOVED]=====================================
-# Image plugin for the DIB format (BMP alias)
-# [AWS-SECRET-REMOVED]=====================================
-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) * 4 for i in (0, 255))
-    elif im.mode == "L":
-        palette = b"".join(o8(i) * 4 for i in range(256))
-    elif im.mode == "P":
-        palette = im.im.getpalette("RGB", "BGRX")
-        colors = len(palette) // 4
-    else:
-        palette = None
-
-    # bitmap header
-    if bitmap_header:
-        offset = 14 + header + colors * 4
-        file_size = offset + image
-        if file_size > 2**32 - 1:
-            msg = "File size is too large for the BMP format"
-            raise ValueError(msg)
-        fp.write(
-            b"BM"  # file type (magic)
-            + o32(file_size)  # file size
-            + o32(0)  # reserved
-            + o32(offset)  # image data offset
-        )
-
-    # bitmap info header
-    fp.write(
-        o32(header)  # info header size
-        + o32(im.size[0])  # width
-        + o32(im.size[1])  # height
-        + o16(1)  # planes
-        + o16(bits)  # depth
-        + o32(0)  # compression (0=uncompressed)
-        + o32(image)  # size of bitmap
-        + o32(ppm[0])  # resolution
-        + o32(ppm[1])  # resolution
-        + o32(colors)  # colors used
-        + o32(colors)  # colors important
-    )
-
-    fp.write(b"\0" * (header - 40))  # padding (for OS/2 format)
-
-    if palette:
-        fp.write(palette)
-
-    ImageFile._save(
-        im, fp, [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.12/site-packages/PIL/BufrStubImagePlugin.py

@@ -1,76 +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
-
-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[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
-
-
-class BufrStubImageFile(ImageFile.StubImageFile):
-    format = "BUFR"
-    format_description = "BUFR"
-
-    def _open(self) -> None:
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(4)):
-            msg = "Not a BUFR file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(offset)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> 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.12/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.12/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[:4] == b"\0\0\2\0"
-
-
-##
-# Image plugin for Windows Cursor files.
-
-
-class CurImageFile(BmpImagePlugin.BmpImageFile):
-    format = "CUR"
-    format_description = "Windows Cursor"
-
-    def _open(self) -> 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.12/site-packages/PIL/DcxImagePlugin.py

@@ -1,80 +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 .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
-        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.12/site-packages/PIL/DdsImagePlugin.py

@@ -1,575 +0,0 @@
-"""
-A Pillow loader for .dds files (S3TC-compressed aka DXTC)
-Jerome Leclanche <jerome@leclan.ch>
-
-Documentation:
-https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
-
-The contents of this file are hereby released in the public domain (CC0)
-Full text of the CC0 license:
-https://creativecommons.org/publicdomain/zero/1.0/
-"""
-
-from __future__ import annotations
-
-import io
-import struct
-import sys
-from enum import IntEnum, IntFlag
-from 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.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)
-
-    alpha = im.mode[-1] == "A"
-    if im.mode[0] == "L":
-        pixel_flags = DDPF.LUMINANCE
-        rawmode = im.mode
-        if alpha:
-            rgba_mask = [0x000000FF, 0x000000FF, 0x000000FF]
-        else:
-            rgba_mask = [0xFF000000, 0xFF000000, 0xFF000000]
-    else:
-        pixel_flags = DDPF.RGB
-        rawmode = im.mode[::-1]
-        rgba_mask = [0x00FF0000, 0x0000FF00, 0x000000FF]
-
-        if alpha:
-            r, g, b, a = im.split()
-            im = Image.merge("RGBA", (a, r, g, b))
-    if alpha:
-        pixel_flags |= DDPF.ALPHAPIXELS
-    rgba_mask.append(0xFF000000 if alpha else 0)
-
-    flags = DDSD.CAPS | DDSD.HEIGHT | DDSD.WIDTH | DDSD.PITCH | DDSD.PIXELFORMAT
-    bitcount = len(im.getbands()) * 8
-    pitch = (im.width * bitcount + 7) // 8
-
-    fp.write(
-        o32(DDS_MAGIC)
-        + struct.pack(
-            "<7I",
-            124,  # header size
-            flags,  # flags
-            im.height,
-            im.width,
-            pitch,
-            0,  # depth
-            0,  # mipmaps
-        )
-        + struct.pack("11I", *((0,) * 11))  # reserved
-        # pfsize, pfflags, fourcc, bitcount
-        + struct.pack("<4I", 32, pixel_flags, 0, bitcount)
-        + struct.pack("<4I", *rgba_mask)  # dwRGBABitMask
-        + struct.pack("<5I", DDSCAPS.TEXTURE, 0, 0, 0, 0)
-    )
-    ImageFile._save(
-        im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))]
-    )
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix[:4] == b"DDS "
-
-
-Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
-Image.register_decoder("dds_rgb", DdsRgbDecoder)
-Image.register_save(DdsImageFile.format, _save)
-Image.register_extension(DdsImageFile.format, ".dds")

.venv/lib/python3.12/site-packages/PIL/EpsImagePlugin.py

@@ -1,474 +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[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
-
-
-##
-# Image plugin for Encapsulated PostScript. This plugin supports only
-# a few variants of this format.
-
-
-class EpsImageFile(ImageFile.ImageFile):
-    """EPS File Parser for the Python Imaging Library"""
-
-    format = "EPS"
-    format_description = "Encapsulated Postscript"
-
-    mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
-
-    def _open(self) -> 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[:8] == "PS-Adobe":
-                            self.info["PS-Adobe"] = k[9:]
-                        else:
-                            self.info[k] = ""
-                    elif s[0] == "%":
-                        # handle non-DSC PostScript comments that some
-                        # tools mistakenly put in the Comments section
-                        pass
-                    else:
-                        msg = "bad EPS header"
-                        raise OSError(msg)
-            elif bytes_mv[:11] == b"%ImageData:":
-                # Check for an "ImageData" descriptor
-                # https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577413_pgfId-1035096
-
-                # 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, 0, None)])
-
-    fp.write(b"\n%%%%EndBinary\n")
-    fp.write(b"grestore end\n")
-    if hasattr(fp, "flush"):
-        fp.flush()
-
-
-# --------------------------------------------------------------------
-
-
-Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
-
-Image.register_save(EpsImageFile.format, _save)
-
-Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
-
-Image.register_mime(EpsImageFile.format, "application/postscript")

.venv/lib/python3.12/site-packages/PIL/ExifTags.py

@@ -1,381 +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 = 0
-    GPSLatitudeRef = 1
-    GPSLatitude = 2
-    GPSLongitudeRef = 3
-    GPSLongitude = 4
-    GPSAltitudeRef = 5
-    GPSAltitude = 6
-    GPSTimeStamp = 7
-    GPSSatellites = 8
-    GPSStatus = 9
-    GPSMeasureMode = 10
-    GPSDOP = 11
-    GPSSpeedRef = 12
-    GPSSpeed = 13
-    GPSTrackRef = 14
-    GPSTrack = 15
-    GPSImgDirectionRef = 16
-    GPSImgDirection = 17
-    GPSMapDatum = 18
-    GPSDestLatitudeRef = 19
-    GPSDestLatitude = 20
-    GPSDestLongitudeRef = 21
-    GPSDestLongitude = 22
-    GPSDestBearingRef = 23
-    GPSDestBearing = 24
-    GPSDestDistanceRef = 25
-    GPSDestDistance = 26
-    GPSProcessingMethod = 27
-    GPSAreaInformation = 28
-    GPSDateStamp = 29
-    GPSDifferential = 30
-    GPSHPositioningError = 31
-
-
-"""Maps EXIF GPS tags to tag names."""
-GPSTAGS = {i.value: i.name for i in GPS}
-
-
-class Interop(IntEnum):
-    InteropIndex = 1
-    InteropVersion = 2
-    RelatedImageFileFormat = 4096
-    RelatedImageWidth = 4097
-    RelatedImageHeight = 4098
-
-
-class IFD(IntEnum):
-    Exif = 34665
-    GPSInfo = 34853
-    Makernote = 37500
-    Interop = 40965
-    IFD1 = -1
-
-
-class LightSource(IntEnum):
-    Unknown = 0
-    Daylight = 1
-    Fluorescent = 2
-    Tungsten = 3
-    Flash = 4
-    Fine = 9
-    Cloudy = 10
-    Shade = 11
-    DaylightFluorescent = 12
-    DayWhiteFluorescent = 13
-    CoolWhiteFluorescent = 14
-    WhiteFluorescent = 15
-    StandardLightA = 17
-    StandardLightB = 18
-    StandardLightC = 19
-    D55 = 20
-    D65 = 21
-    D75 = 22
-    D50 = 23
-    ISO = 24
-    Other = 255

.venv/lib/python3.12/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[:6] == b"SIMPLE"
-
-
-class FitsImageFile(ImageFile.ImageFile):
-    format = "FITS"
-    format_description = "FITS"
-
-    def _open(self) -> None:
-        assert self.fp is not None
-
-        headers: dict[bytes, bytes] = {}
-        header_in_progress = False
-        decoder_name = ""
-        while True:
-            header = self.fp.read(80)
-            if not header:
-                msg = "Truncated FITS file"
-                raise OSError(msg)
-            keyword = header[:8].strip()
-            if keyword in (b"SIMPLE", b"XTENSION"):
-                header_in_progress = True
-            elif headers and not header_in_progress:
-                # This is now a data unit
-                break
-            elif keyword == b"END":
-                # Seek to the end of the header unit
-                self.fp.seek(math.ceil(self.fp.tell() / 2880) * 2880)
-                if not decoder_name:
-                    decoder_name, offset, args = self._parse_headers(headers)
-
-                header_in_progress = False
-                continue
-
-            if decoder_name:
-                # Keep going to read past the headers
-                continue
-
-            value = header[8:].split(b"/")[0].strip()
-            if value.startswith(b"="):
-                value = value[1:].strip()
-            if not headers and (not _accept(keyword) or value != b"T"):
-                msg = "Not a FITS file"
-                raise SyntaxError(msg)
-            headers[keyword] = value
-
-        if not decoder_name:
-            msg = "No image data"
-            raise ValueError(msg)
-
-        offset += self.fp.tell() - 80
-        self.tile = [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.12/site-packages/PIL/FliImagePlugin.py

@@ -1,175 +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
-
-#
-# 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 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, None)]
-
-        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.12/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.12/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[:8] == 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 != "[HEROKU-API-KEY-REMOVED]":
-            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.12/site-packages/PIL/FtexImagePlugin.py

@@ -1,115 +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))
-
-        self._mode = "RGB"
-
-        # Only support single-format files.
-        # I don't know of any multi-format file.
-        assert format_count == 1
-
-        format, where = struct.unpack("<2i", self.fp.read(8))
-        self.fp.seek(where)
-        (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
-
-        data = self.fp.read(mipmap_size)
-
-        if format == Format.DXT1:
-            self._mode = "RGBA"
-            self.tile = [ImageFile._Tile("bcn", (0, 0) + self.size, 0, (1,))]
-        elif format == Format.UNCOMPRESSED:
-            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
-        else:
-            msg = f"Invalid texture compression format: {repr(format)}"
-            raise ValueError(msg)
-
-        self.fp.close()
-        self.fp = BytesIO(data)
-
-    def load_seek(self, pos: int) -> None:
-        pass
-
-
-def _accept(prefix: bytes) -> bool:
-    return prefix[:4] == MAGIC
-
-
-Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
-Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])

.venv/lib/python3.12/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.12/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 = "L"  # FIXME: "P"
-        self._size = i16(s, 2), i16(s, 4)
-
-        true_color = s[6]
-        true_color_offset = 2 if true_color else 0
-
-        # transparency index
-        tindex = i32(s, 7 + true_color_offset)
-        if tindex < 256:
-            self.info["transparency"] = tindex
-
-        self.palette = ImagePalette.raw(
-            "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4]
-        )
-
-        self.tile = [
-            ImageFile._Tile(
-                "raw",
-                (0, 0) + self.size,
-                7 + true_color_offset + 4 + 256 * 4,
-                ("L", 0, 1),
-            )
-        ]
-
-
-def open(fp: StrOrBytesPath | IO[bytes], mode: str = "r") -> GdImageFile:
-    """
-    Load texture from a GD image file.
-
-    :param fp: GD file name, or an opened file handle.
-    :param mode: Optional mode.  In this version, if the mode argument
-        is given, it must be "r".
-    :returns: An image instance.
-    :raises OSError: If the image could not be read.
-    """
-    if mode != "r":
-        msg = "bad mode"
-        raise ValueError(msg)
-
-    try:
-        return GdImageFile(fp)
-    except SyntaxError as e:
-        msg = "cannot identify this image file"
-        raise UnidentifiedImageError(msg) from e

.venv/lib/python3.12/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 fp.readline()[:13] != b"GIMP Gradient":
-            msg = "not a GIMP gradient file"
-            raise SyntaxError(msg)
-
-        line = fp.readline()
-
-        # GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
-        if line.startswith(b"Name: "):
-            line = fp.readline().strip()
-
-        count = int(line)
-
-        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.12/site-packages/PIL/GimpPaletteFile.py

@@ -1,58 +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 typing import IO
-
-from ._binary import o8
-
-
-class GimpPaletteFile:
-    """File handler for GIMP's palette format."""
-
-    rawmode = "RGB"
-
-    def __init__(self, fp: IO[bytes]) -> None:
-        palette = [o8(i) * 3 for i in range(256)]
-
-        if fp.readline()[:12] != b"GIMP Palette":
-            msg = "not a GIMP palette file"
-            raise SyntaxError(msg)
-
-        for i in range(256):
-            s = fp.readline()
-            if not s:
-                break
-
-            # skip fields and comment lines
-            if re.match(rb"\w+:|#", s):
-                continue
-            if len(s) > 100:
-                msg = "bad palette file"
-                raise SyntaxError(msg)
-
-            v = tuple(map(int, s.split()[:3]))
-            if len(v) != 3:
-                msg = "bad palette entry"
-                raise ValueError(msg)
-
-            palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
-
-        self.palette = b"".join(palette)
-
-    def getpalette(self) -> tuple[bytes, str]:
-        return self.palette, self.rawmode

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

@@ -1,76 +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
-
-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[:4] == b"GRIB" and prefix[7] == 1
-
-
-class GribStubImageFile(ImageFile.StubImageFile):
-    format = "GRIB"
-    format_description = "GRIB"
-
-    def _open(self) -> None:
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(8)):
-            msg = "Not a GRIB file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(offset)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> 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.12/site-packages/PIL/Hdf5StubImagePlugin.py

@@ -1,76 +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
-
-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[:8] == b"\x89HDF\r\n\x1a\n"
-
-
-class HDF5StubImageFile(ImageFile.StubImageFile):
-    format = "HDF5"
-    format_description = "HDF5"
-
-    def _open(self) -> None:
-        offset = self.fp.tell()
-
-        if not _accept(self.fp.read(8)):
-            msg = "Not an HDF file"
-            raise SyntaxError(msg)
-
-        self.fp.seek(offset)
-
-        # make something up
-        self._mode = "F"
-        self._size = 1, 1
-
-        loader = self._load()
-        if loader:
-            loader.open(self)
-
-    def _load(self) -> 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.12/site-packages/PIL/IcnsImagePlugin.py

@@ -1,412 +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[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
-        fobj.seek(start)
-        im = PngImagePlugin.PngImageFile(fobj)
-        Image._decompression_bomb_check(im.size)
-        return {"RGBA": im}
-    elif (
-        sig[:4] == b"\xff\x4f\xff\x51"
-        or sig[:4] == b"\x0d\x0a\x87\x0a"
-        or sig == b"\x00\x00\x00\x0cjP  \x0d\x0a\x87\x0a"
-    ):
-        if not enable_jpeg2k:
-            msg = (
-                "Unsupported icon subimage format (rebuild PIL "
-                "with JPEG 2000 support to fix this)"
-            )
-            raise ValueError(msg)
-        # j2k, jpc or j2c
-        fobj.seek(start)
-        jp2kstream = fobj.read(length)
-        f = io.BytesIO(jp2kstream)
-        im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
-        Image._decompression_bomb_check(im.size)
-        if im.mode != "RGBA":
-            im = im.convert("RGBA")
-        return {"RGBA": im}
-    else:
-        msg = "Unsupported icon subimage format"
-        raise ValueError(msg)
-
-
-class IcnsFile:
-    SIZES = {
-        (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
-        (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
-        (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
-        (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
-        (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
-        (128, 128, 1): [
-            (b"ic07", read_png_or_jpeg2000),
-            (b"it32", read_32t),
-            (b"t8mk", read_mk),
-        ],
-        (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
-        (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
-        (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
-        (32, 32, 1): [
-            (b"icp5", read_png_or_jpeg2000),
-            (b"il32", read_32),
-            (b"l8mk", read_mk),
-        ],
-        (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
-        (16, 16, 1): [
-            (b"icp4", read_png_or_jpeg2000),
-            (b"is32", read_32),
-            (b"s8mk", read_mk),
-        ],
-    }
-
-    def __init__(self, fobj: 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[:4] == MAGIC
-
-
-Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
-Image.register_extension(IcnsImageFile.format, ".icns")
-
-Image.register_save(IcnsImageFile.format, _save)
-Image.register_mime(IcnsImageFile.format, "image/icns")
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Syntax: python3 IcnsImagePlugin.py [file]")
-        sys.exit()
-
-    with open(sys.argv[1], "rb") as fp:
-        imf = IcnsImageFile(fp)
-        for size in imf.info["sizes"]:
-            width, height, scale = imf.size = size
-            imf.save(f"out-{width}-{height}-{scale}.png")
-        with Image.open(sys.argv[1]) as im:
-            im.save("out.png")
-        if sys.platform == "windows":
-            os.startfile("out.png")

.venv/lib/python3.12/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.[AWS-SECRET-REMOVED]onImagePlugin.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[:4] == _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.[AWS-SECRET-REMOVED]onImagePlugin.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 None
-
-    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.12/site-packages/PIL/ImImagePlugin.py

@@ -1,386 +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
-
-# --------------------------------------------------------------------
-# 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[-2:] == b"\r\n":
-                s = s[:-2]
-            elif s[-1:] == 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 s[:1] != 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[:2] == "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
-
-        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(("Image size (x*y): %d*%d\r\n" % im.size).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.12/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.12/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",
-}