fix(staging): ensure wpp can write sqlite db during deploy

Merge PR #25: staging deploy policy updates

.gitea/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - "**"
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test-and-quality:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install ruff
+
+      - name: Lint
+        run: ruff check lobby
+
+      - name: Tests
+        run: python manage.py test lobby -v 1

.gitignore

@@ -0,0 +1,30 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg-info/
+.eggs/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtual env
+.venv/
+venv/
+
+# Django
+*.log
+db.sqlite3
+staticfiles/
+media/
+
+# Env/secrets
+.env
+.env.*
+!.env.test.example
+!.env.prod.example
+
+# Editors/OS
+.vscode/
+.idea/
+.DS_Store

.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/coder/repos/weirsoe-party-protocol/.venv)
-else
-    # use the path as-is
-    export VIRTUAL_ENV=/home/coder/repos/weirsoe-party-protocol/.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/coder/repos/weirsoe-party-protocol/.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/coder/repos/weirsoe-party-protocol/.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/django-admin

@@ -1,6 +0,0 @@
-#!/home/coder/repos/weirsoe-party-protocol/.venv/bin/python
-import sys
-from django.core.management import execute_from_command_line
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(execute_from_command_line())

.venv/bin/dotenv

@@ -1,6 +0,0 @@
-#!/home/coder/repos/weirsoe-party-protocol/.venv/bin/python
-import sys
-from dotenv.__main__ import cli
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(cli())

.venv/bin/pip

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

.venv/bin/pip3

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

.venv/bin/pip3.12

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

.venv/bin/python

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

.venv/bin/python3

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

.venv/bin/python3.12

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

.venv/bin/sqlformat

@@ -1,6 +0,0 @@
-#!/home/coder/repos/weirsoe-party-protocol/.venv/bin/python
-import sys
-from sqlparse.__main__ import main
-if __name__ == '__main__':
-    sys.argv[0] = sys.argv[0].removesuffix('.exe')
-    sys.exit(main())

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

@@ -1,168 +0,0 @@
-"""
-MySQLdb - A DB API v2.0 compatible interface to MySQL.
-
-This package is a wrapper around _mysql, which mostly implements the
-MySQL C API.
-
-connect() -- connects to server
-
-See the C API specification and the MySQL documentation for more info
-on other items.
-
-For information on how MySQLdb handles type conversion, see the
-MySQLdb.converters module.
-"""
-
-from .release import version_info
-from . import _mysql
-
-if version_info != _mysql.version_info:
-    raise ImportError(
-        f"this is MySQLdb version {version_info}, "
-        f"but _mysql is version {_mysql.version_info!r}\n"
-        f"_mysql: {_mysql.__file__!r}"
-    )
-
-
-from ._mysql import (
-    NotSupportedError,
-    OperationalError,
-    get_client_info,
-    ProgrammingError,
-    Error,
-    InterfaceError,
-    debug,
-    IntegrityError,
-    string_literal,
-    MySQLError,
-    DataError,
-    DatabaseError,
-    InternalError,
-    Warning,
-)
-from MySQLdb.constants import FIELD_TYPE
-from MySQLdb.times import (
-    Date,
-    Time,
-    Timestamp,
-    DateFromTicks,
-    TimeFromTicks,
-    TimestampFromTicks,
-)
-
-threadsafety = 1
-apilevel = "2.0"
-paramstyle = "format"
-
-
-class DBAPISet(frozenset):
-    """A special type of set for which A == x is true if A is a
-    DBAPISet and x is a member of that set."""
-
-    def __eq__(self, other):
-        if isinstance(other, DBAPISet):
-            return not self.difference(other)
-        return other in self
-
-
-STRING = DBAPISet([FIELD_TYPE.ENUM, FIELD_TYPE.STRING, FIELD_TYPE.VAR_STRING])
-BINARY = DBAPISet(
-    [
-        FIELD_TYPE.BLOB,
-        FIELD_TYPE.LONG_BLOB,
-        FIELD_TYPE.MEDIUM_BLOB,
-        FIELD_TYPE.TINY_BLOB,
-    ]
-)
-NUMBER = DBAPISet(
-    [
-        FIELD_TYPE.DECIMAL,
-        FIELD_TYPE.DOUBLE,
-        FIELD_TYPE.FLOAT,
-        FIELD_TYPE.INT24,
-        FIELD_TYPE.LONG,
-        FIELD_TYPE.LONGLONG,
-        FIELD_TYPE.TINY,
-        FIELD_TYPE.YEAR,
-        FIELD_TYPE.NEWDECIMAL,
-    ]
-)
-DATE = DBAPISet([FIELD_TYPE.DATE])
-TIME = DBAPISet([FIELD_TYPE.TIME])
-TIMESTAMP = DBAPISet([FIELD_TYPE.TIMESTAMP, FIELD_TYPE.DATETIME])
-DATETIME = TIMESTAMP
-ROWID = DBAPISet()
-
-
-def test_DBAPISet_set_equality():
-    assert STRING == STRING
-
-
-def test_DBAPISet_set_inequality():
-    assert STRING != NUMBER
-
-
-def test_DBAPISet_set_equality_membership():
-    assert FIELD_TYPE.VAR_STRING == STRING
-
-
-def test_DBAPISet_set_inequality_membership():
-    assert FIELD_TYPE.DATE != STRING
-
-
-def Binary(x):
-    return bytes(x)
-
-
-def Connect(*args, **kwargs):
-    """Factory function for connections.Connection."""
-    from MySQLdb.connections import Connection
-
-    return Connection(*args, **kwargs)
-
-
-connect = Connection = Connect
-
-__all__ = [
-    "BINARY",
-    "Binary",
-    "Connect",
-    "Connection",
-    "DATE",
-    "Date",
-    "Time",
-    "Timestamp",
-    "DateFromTicks",
-    "TimeFromTicks",
-    "TimestampFromTicks",
-    "DataError",
-    "DatabaseError",
-    "Error",
-    "FIELD_TYPE",
-    "IntegrityError",
-    "InterfaceError",
-    "InternalError",
-    "MySQLError",
-    "NUMBER",
-    "NotSupportedError",
-    "DBAPISet",
-    "OperationalError",
-    "ProgrammingError",
-    "ROWID",
-    "STRING",
-    "TIME",
-    "TIMESTAMP",
-    "Warning",
-    "apilevel",
-    "connect",
-    "connections",
-    "constants",
-    "converters",
-    "cursors",
-    "debug",
-    "get_client_info",
-    "paramstyle",
-    "string_literal",
-    "threadsafety",
-    "version_info",
-]

.venv/lib/python3.12/site-packages/MySQLdb/_exceptions.py

@@ -1,91 +0,0 @@
-"""Exception classes for _mysql and MySQLdb.
-
-These classes are dictated by the DB API v2.0:
-
-    https://www.python.org/dev/peps/pep-0249/
-"""
-
-
-class MySQLError(Exception):
-    """Exception related to operation with MySQL."""
-
-    __module__ = "MySQLdb"
-
-
-class Warning(Warning, MySQLError):
-    """Exception raised for important warnings like data truncations
-    while inserting, etc."""
-
-    __module__ = "MySQLdb"
-
-
-class Error(MySQLError):
-    """Exception that is the base class of all other error exceptions
-    (not Warning)."""
-
-    __module__ = "MySQLdb"
-
-
-class InterfaceError(Error):
-    """Exception raised for errors that are related to the database
-    interface rather than the database itself."""
-
-    __module__ = "MySQLdb"
-
-
-class DatabaseError(Error):
-    """Exception raised for errors that are related to the
-    database."""
-
-    __module__ = "MySQLdb"
-
-
-class DataError(DatabaseError):
-    """Exception raised for errors that are due to problems with the
-    processed data like division by zero, numeric value out of range,
-    etc."""
-
-    __module__ = "MySQLdb"
-
-
-class OperationalError(DatabaseError):
-    """Exception raised for errors that are related to the database's
-    operation and not necessarily under the control of the programmer,
-    e.g. an unexpected disconnect occurs, the data source name is not
-    found, a transaction could not be processed, a memory allocation
-    error occurred during processing, etc."""
-
-    __module__ = "MySQLdb"
-
-
-class IntegrityError(DatabaseError):
-    """Exception raised when the relational integrity of the database
-    is affected, e.g. a foreign key check fails, duplicate key,
-    etc."""
-
-    __module__ = "MySQLdb"
-
-
-class InternalError(DatabaseError):
-    """Exception raised when the database encounters an internal
-    error, e.g. the cursor is not valid anymore, the transaction is
-    out of sync, etc."""
-
-    __module__ = "MySQLdb"
-
-
-class ProgrammingError(DatabaseError):
-    """Exception raised for programming errors, e.g. table not found
-    or already exists, syntax error in the SQL statement, wrong number
-    of parameters specified, etc."""
-
-    __module__ = "MySQLdb"
-
-
-class NotSupportedError(DatabaseError):
-    """Exception raised in case a method or database API was used
-    which is not supported by the database, e.g. requesting a
-    .rollback() on a connection that does not support transaction or
-    has transactions turned off."""
-
-    __module__ = "MySQLdb"

.venv/lib/python3.12/site-packages/MySQLdb/connections.py

@@ -1,368 +0,0 @@
-"""
-This module implements connections for MySQLdb. Presently there is
-only one class: Connection. Others are unlikely. However, you might
-want to make your own subclasses. In most cases, you will probably
-override Connection.default_cursor with a non-standard Cursor class.
-"""
-import re
-
-from . import cursors, _mysql
-from ._exceptions import (
-    Warning,
-    Error,
-    InterfaceError,
-    DataError,
-    DatabaseError,
-    OperationalError,
-    IntegrityError,
-    InternalError,
-    NotSupportedError,
-    ProgrammingError,
-)
-
-# Mapping from MySQL charset name to Python codec name
-_charset_to_encoding = {
-    "utf8mb4": "utf8",
-    "utf8mb3": "utf8",
-    "latin1": "cp1252",
-    "koi8r": "koi8_r",
-    "koi8u": "koi8_u",
-}
-
-re_numeric_part = re.compile(r"^(\d+)")
-
-
-def numeric_part(s):
-    """Returns the leading numeric part of a string.
-
-    >>> numeric_part("20-alpha")
-    20
-    >>> numeric_part("foo")
-    >>> numeric_part("16b")
-    16
-    """
-
-    m = re_numeric_part.match(s)
-    if m:
-        return int(m.group(1))
-    return None
-
-
-class Connection(_mysql.connection):
-    """MySQL Database Connection Object"""
-
-    default_cursor = cursors.Cursor
-
-    def __init__(self, *args, **kwargs):
-        """
-        Create a connection to the database. It is strongly recommended
-        that you only use keyword parameters. Consult the MySQL C API
-        documentation for more information.
-
-        :param str host:        host to connect
-        :param str user:        user to connect as
-        :param str password:    password to use
-        :param str passwd:      alias of password (deprecated)
-        :param str database:    database to use
-        :param str db:          alias of database (deprecated)
-        :param int port:        TCP/IP port to connect to
-        :param str unix_socket: location of unix_socket to use
-        :param dict conv:       conversion dictionary, see MySQLdb.converters
-        :param int connect_timeout:
-            number of seconds to wait before the connection attempt fails.
-
-        :param bool compress:   if set, compression is enabled
-        :param str named_pipe:  if set, a named pipe is used to connect (Windows only)
-        :param str init_command:
-            command which is run once the connection is created
-
-        :param str read_default_file:
-            file from which default client values are read
-
-        :param str read_default_group:
-            configuration group to use from the default file
-
-        :param type cursorclass:
-            class object, used to create cursors (keyword only)
-
-        :param bool use_unicode:
-            If True, text-like columns are returned as unicode objects
-            using the connection's character set. Otherwise, text-like
-            columns are returned as bytes. Unicode objects will always
-            be encoded to the connection's character set regardless of
-            this setting.
-            Default to True.
-
-        :param str charset:
-            If supplied, the connection character set will be changed
-            to this character set.
-
-        :param str collation:
-            If ``charset`` and ``collation`` are both supplied, the
-            character set and collation for the current connection
-            will be set.
-
-            If omitted, empty string, or None, the default collation
-            for the ``charset`` is implied.
-
-        :param str auth_plugin:
-            If supplied, the connection default authentication plugin will be
-            changed to this value. Example values:
-            `mysql_native_password` or `caching_sha2_password`
-
-        :param str sql_mode:
-            If supplied, the session SQL mode will be changed to this
-            setting.
-            For more details and legal values, see the MySQL documentation.
-
-        :param int client_flag:
-            flags to use or 0 (see MySQL docs or constants/CLIENTS.py)
-
-        :param bool multi_statements:
-            If True, enable multi statements for clients >= 4.1.
-            Defaults to True.
-
-        :param str ssl_mode:
-            specify the security settings for connection to the server;
-            see the MySQL documentation for more details
-            (mysql_option(), MYSQL_OPT_SSL_MODE).
-            Only one of 'DISABLED', 'PREFERRED', 'REQUIRED',
-            'VERIFY_CA', 'VERIFY_IDENTITY' can be specified.
-
-        :param dict ssl:
-            dictionary or mapping contains SSL connection parameters;
-            see the MySQL documentation for more details
-            (mysql_ssl_set()).  If this is set, and the client does not
-            support SSL, NotSupportedError will be raised.
-            Since mysqlclient 2.2.4, ssl=True is alias of ssl_mode=REQUIRED
-            for better compatibility with PyMySQL and MariaDB.
-
-        :param str server_public_key_path:
-            specify the path to a file RSA public key file for caching_sha2_password.
-            See https://dev.mysql.com/doc/refman/9.0/en/caching-sha2-pluggable-authentication.html
-
-        :param bool local_infile:
-            sets ``MYSQL_OPT_LOCAL_INFILE`` in ``mysql_options()`` enabling LOAD LOCAL INFILE from any path; zero disables;
-            
-        :param str local_infile_dir:
-            sets ``MYSQL_OPT_LOAD_DATA_LOCAL_DIR`` in ``mysql_options()`` enabling LOAD LOCAL INFILE from any path; 
-            if ``local_infile`` is set to ``True`` then this is ignored;
-            
-            supported for mysql version >= 8.0.21
-
-        :param bool autocommit:
-            If False (default), autocommit is disabled.
-            If True, autocommit is enabled.
-            If None, autocommit isn't set and server default is used.
-
-        :param bool binary_prefix:
-            If set, the '_binary' prefix will be used for raw byte query
-            arguments (e.g. Binary). This is disabled by default.
-
-        There are a number of undocumented, non-standard methods. See the
-        documentation for the MySQL C API for some hints on what they do.
-        """
-        from MySQLdb.constants import CLIENT, FIELD_TYPE
-        from MySQLdb.converters import conversions, _bytes_or_str
-
-        kwargs2 = kwargs.copy()
-
-        if "db" in kwargs2:
-            kwargs2["database"] = kwargs2.pop("db")
-        if "passwd" in kwargs2:
-            kwargs2["password"] = kwargs2.pop("passwd")
-
-        if "conv" in kwargs:
-            conv = kwargs["conv"]
-        else:
-            conv = conversions
-
-        conv2 = {}
-        for k, v in conv.items():
-            if isinstance(k, int) and isinstance(v, list):
-                conv2[k] = v[:]
-            else:
-                conv2[k] = v
-        kwargs2["conv"] = conv2
-
-        cursorclass = kwargs2.pop("cursorclass", self.default_cursor)
-        charset = kwargs2.get("charset", "")
-        collation = kwargs2.pop("collation", "")
-        use_unicode = kwargs2.pop("use_unicode", True)
-        sql_mode = kwargs2.pop("sql_mode", "")
-        self._binary_prefix = kwargs2.pop("binary_prefix", False)
-
-        client_flag = kwargs.get("client_flag", 0)
-        client_flag |= CLIENT.MULTI_RESULTS
-        multi_statements = kwargs2.pop("multi_statements", True)
-        if multi_statements:
-            client_flag |= CLIENT.MULTI_STATEMENTS
-        kwargs2["client_flag"] = client_flag
-
-        # PEP-249 requires autocommit to be initially off
-        autocommit = kwargs2.pop("autocommit", False)
-
-        self._set_attributes(*args, **kwargs2)
-        super().__init__(*args, **kwargs2)
-
-        self.cursorclass = cursorclass
-        self.encoders = {
-            k: v
-            for k, v in conv.items()
-            if type(k) is not int  # noqa: E721
-        }
-        self._server_version = tuple(
-            [numeric_part(n) for n in self.get_server_info().split(".")[:2]]
-        )
-        self.encoding = "ascii"  # overridden in set_character_set()
-
-        if not charset:
-            charset = self.character_set_name()
-        self.set_character_set(charset, collation)
-
-        if sql_mode:
-            self.set_sql_mode(sql_mode)
-
-        if use_unicode:
-            for t in (
-                FIELD_TYPE.STRING,
-                FIELD_TYPE.VAR_STRING,
-                FIELD_TYPE.VARCHAR,
-                FIELD_TYPE.TINY_BLOB,
-                FIELD_TYPE.MEDIUM_BLOB,
-                FIELD_TYPE.LONG_BLOB,
-                FIELD_TYPE.BLOB,
-            ):
-                self.converter[t] = _bytes_or_str
-            # Unlike other string/blob types, JSON is always text.
-            # MySQL may return JSON with charset==binary.
-            self.converter[FIELD_TYPE.JSON] = str
-
-        self._transactional = self.server_capabilities & CLIENT.TRANSACTIONS
-        if self._transactional:
-            if autocommit is not None:
-                self.autocommit(autocommit)
-        self.messages = []
-
-    def _set_attributes(self, host=None, user=None, password=None, database="", port=3306,
-                        unix_socket=None, **kwargs):
-        """set some attributes for otel"""
-        if unix_socket and not host:
-            host = "localhost"
-        # support opentelemetry-instrumentation-dbapi
-        self.host = host
-        # _mysql.Connection provides self.port
-        self.user = user
-        self.database = database
-        # otel-inst-mysqlclient uses db instead of database.
-        self.db = database
-        # NOTE: We have not supported semantic conventions yet.
-        # https://opentelemetry.io/docs/specs/semconv/database/sql/
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.close()
-
-    def autocommit(self, on):
-        on = bool(on)
-        if self.get_autocommit() != on:
-            _mysql.connection.autocommit(self, on)
-
-    def cursor(self, cursorclass=None):
-        """
-        Create a cursor on which queries may be performed. The
-        optional cursorclass parameter is used to create the
-        Cursor. By default, self.cursorclass=cursors.Cursor is
-        used.
-        """
-        return (cursorclass or self.cursorclass)(self)
-
-    def query(self, query):
-        # Since _mysql releases GIL while querying, we need immutable buffer.
-        if isinstance(query, bytearray):
-            query = bytes(query)
-        _mysql.connection.query(self, query)
-
-    def _bytes_literal(self, bs):
-        assert isinstance(bs, (bytes, bytearray))
-        x = self.string_literal(bs)  # x is escaped and quoted bytes
-        if self._binary_prefix:
-            return b"_binary" + x
-        return x
-
-    def _tuple_literal(self, t):
-        return b"(%s)" % (b",".join(map(self.literal, t)))
-
-    def literal(self, o):
-        """If o is a single object, returns an SQL literal as a string.
-        If o is a non-string sequence, the items of the sequence are
-        converted and returned as a sequence.
-
-        Non-standard. For internal use; do not use this in your
-        applications.
-        """
-        if isinstance(o, str):
-            s = self.string_literal(o.encode(self.encoding))
-        elif isinstance(o, bytearray):
-            s = self._bytes_literal(o)
-        elif isinstance(o, bytes):
-            s = self._bytes_literal(o)
-        elif isinstance(o, (tuple, list)):
-            s = self._tuple_literal(o)
-        else:
-            s = self.escape(o, self.encoders)
-            if isinstance(s, str):
-                s = s.encode(self.encoding)
-        assert isinstance(s, bytes)
-        return s
-
-    def begin(self):
-        """Explicitly begin a connection.
-
-        This method is not used when autocommit=False (default).
-        """
-        self.query(b"BEGIN")
-
-    def set_character_set(self, charset, collation=None):
-        """Set the connection character set to charset."""
-        super().set_character_set(charset)
-        self.encoding = _charset_to_encoding.get(charset, charset)
-        if collation:
-            self.query(f"SET NAMES {charset} COLLATE {collation}")
-            self.store_result()
-
-    def set_sql_mode(self, sql_mode):
-        """Set the connection sql_mode. See MySQL documentation for
-        legal values."""
-        if self._server_version < (4, 1):
-            raise NotSupportedError("server is too old to set sql_mode")
-        self.query("SET SESSION sql_mode='%s'" % sql_mode)
-        self.store_result()
-
-    def show_warnings(self):
-        """Return detailed information about warnings as a
-        sequence of tuples of (Level, Code, Message). This
-        is only supported in MySQL-4.1 and up. If your server
-        is an earlier version, an empty sequence is returned."""
-        if self._server_version < (4, 1):
-            return ()
-        self.query("SHOW WARNINGS")
-        r = self.store_result()
-        warnings = r.fetch_row(0)
-        return warnings
-
-    Warning = Warning
-    Error = Error
-    InterfaceError = InterfaceError
-    DatabaseError = DatabaseError
-    DataError = DataError
-    OperationalError = OperationalError
-    IntegrityError = IntegrityError
-    InternalError = InternalError
-    ProgrammingError = ProgrammingError
-    NotSupportedError = NotSupportedError
-
-
-# vim: colorcolumn=100

.venv/lib/python3.12/site-packages/MySQLdb/constants/CLIENT.py

@@ -1,27 +0,0 @@
-"""MySQL CLIENT constants
-
-These constants are used when creating the connection. Use bitwise-OR
-(|) to combine options together, and pass them as the client_flags
-parameter to MySQLdb.Connection. For more information on these flags,
-see the MySQL C API documentation for mysql_real_connect().
-
-"""
-
-LONG_PASSWORD = 1
-FOUND_ROWS = 2
-LONG_FLAG = 4
-CONNECT_WITH_DB = 8
-NO_SCHEMA = 16
-COMPRESS = 32
-ODBC = 64
-LOCAL_FILES = 128
-IGNORE_SPACE = 256
-CHANGE_USER = 512
-INTERACTIVE = 1024
-SSL = 2048
-IGNORE_SIGPIPE = 4096
-TRANSACTIONS = 8192  # mysql_com.h was WRONG prior to 3.23.35
-RESERVED = 16384
-SECURE_CONNECTION = 32768
-MULTI_STATEMENTS = 65536
-MULTI_RESULTS = 131072

.venv/lib/python3.12/site-packages/MySQLdb/constants/CR.py

@@ -1,105 +0,0 @@
-"""MySQL Connection Errors
-
-Nearly all of these raise OperationalError. COMMANDS_OUT_OF_SYNC
-raises ProgrammingError.
-
-"""
-
-if __name__ == "__main__":
-    """
-    Usage: python CR.py [/path/to/mysql/errmsg.h ...] >> CR.py
-    """
-    import fileinput
-    import re
-
-    data = {}
-    error_last = None
-    for line in fileinput.input():
-        line = re.sub(r"/\*.*?\*/", "", line)
-        m = re.match(r"^\s*#define\s+CR_([A-Z0-9_]+)\s+(\d+)(\s.*|$)", line)
-        if m:
-            name = m.group(1)
-            value = int(m.group(2))
-            if name == "ERROR_LAST":
-                if error_last is None or error_last < value:
-                    error_last = value
-                continue
-            if value not in data:
-                data[value] = set()
-            data[value].add(name)
-    for value, names in sorted(data.items()):
-        for name in sorted(names):
-            print(f"{name} = {value}")
-    if error_last is not None:
-        print("ERROR_LAST = %s" % error_last)
-
-
-ERROR_FIRST = 2000
-MIN_ERROR = 2000
-UNKNOWN_ERROR = 2000
-SOCKET_CREATE_ERROR = 2001
-CONNECTION_ERROR = 2002
-CONN_HOST_ERROR = 2003
-IPSOCK_ERROR = 2004
-UNKNOWN_HOST = 2005
-SERVER_GONE_ERROR = 2006
-VERSION_ERROR = 2007
-OUT_OF_MEMORY = 2008
-WRONG_HOST_INFO = 2009
-LOCALHOST_CONNECTION = 2010
-TCP_CONNECTION = 2011
-SERVER_HANDSHAKE_ERR = 2012
-SERVER_LOST = 2013
-COMMANDS_OUT_OF_SYNC = 2014
-NAMEDPIPE_CONNECTION = 2015
-NAMEDPIPEWAIT_ERROR = 2016
-NAMEDPIPEOPEN_ERROR = 2017
-NAMEDPIPESETSTATE_ERROR = 2018
-CANT_READ_CHARSET = 2019
-NET_PACKET_TOO_LARGE = 2020
-EMBEDDED_CONNECTION = 2021
-PROBE_SLAVE_STATUS = 2022
-PROBE_SLAVE_HOSTS = 2023
-PROBE_SLAVE_CONNECT = 2024
-PROBE_MASTER_CONNECT = 2025
-SSL_CONNECTION_ERROR = 2026
-MALFORMED_PACKET = 2027
-WRONG_LICENSE = 2028
-NULL_POINTER = 2029
-NO_PREPARE_STMT = 2030
-PARAMS_NOT_BOUND = 2031
-DATA_TRUNCATED = 2032
-NO_PARAMETERS_EXISTS = 2033
-INVALID_PARAMETER_NO = 2034
-INVALID_BUFFER_USE = 2035
-UNSUPPORTED_PARAM_TYPE = 2036
-SHARED_MEMORY_CONNECTION = 2037
-SHARED_MEMORY_CONNECT_REQUEST_ERROR = 2038
-SHARED_MEMORY_CONNECT_ANSWER_ERROR = 2039
-SHARED_MEMORY_CONNECT_FILE_MAP_ERROR = 2040
-SHARED_MEMORY_CONNECT_MAP_ERROR = 2041
-SHARED_MEMORY_FILE_MAP_ERROR = 2042
-SHARED_MEMORY_MAP_ERROR = 2043
-SHARED_MEMORY_EVENT_ERROR = 2044
-SHARED_MEMORY_CONNECT_ABANDONED_ERROR = 2045
-SHARED_MEMORY_CONNECT_SET_ERROR = 2046
-CONN_UNKNOW_PROTOCOL = 2047
-INVALID_CONN_HANDLE = 2048
-UNUSED_1 = 2049
-FETCH_CANCELED = 2050
-NO_DATA = 2051
-NO_STMT_METADATA = 2052
-NO_RESULT_SET = 2053
-NOT_IMPLEMENTED = 2054
-SERVER_LOST_EXTENDED = 2055
-STMT_CLOSED = 2056
-NEW_STMT_METADATA = 2057
-ALREADY_CONNECTED = 2058
-AUTH_PLUGIN_CANNOT_LOAD = 2059
-DUPLICATE_CONNECTION_ATTR = 2060
-AUTH_PLUGIN_ERR = 2061
-INSECURE_API_ERR = 2062
-FILE_NAME_TOO_LONG = 2063
-SSL_FIPS_MODE_ERR = 2064
-MAX_ERROR = 2999
-ERROR_LAST = 2064

.venv/lib/python3.12/site-packages/MySQLdb/constants/ER.py

@@ -1,827 +0,0 @@
-"""MySQL ER Constants
-
-These constants are error codes for the bulk of the error conditions
-that may occur.
-"""
-
-if __name__ == "__main__":
-    """
-    Usage: python ER.py [/path/to/mysql/mysqld_error.h ...] >> ER.py
-    """
-    import fileinput
-    import re
-
-    data = {}
-    error_last = None
-    for line in fileinput.input():
-        line = re.sub(r"/\*.*?\*/", "", line)
-        m = re.match(r"^\s*#define\s+((ER|WARN)_[A-Z0-9_]+)\s+(\d+)\s*", line)
-        if m:
-            name = m.group(1)
-            if name.startswith("ER_"):
-                name = name[3:]
-            value = int(m.group(3))
-            if name == "ERROR_LAST":
-                if error_last is None or error_last < value:
-                    error_last = value
-                continue
-            if value not in data:
-                data[value] = set()
-            data[value].add(name)
-    for value, names in sorted(data.items()):
-        for name in sorted(names):
-            print(f"{name} = {value}")
-    if error_last is not None:
-        print("ERROR_LAST = %s" % error_last)
-
-
-ERROR_FIRST = 1000
-NO = 1002
-YES = 1003
-CANT_CREATE_FILE = 1004
-CANT_CREATE_TABLE = 1005
-CANT_CREATE_DB = 1006
-DB_CREATE_EXISTS = 1007
-DB_DROP_EXISTS = 1008
-DB_DROP_RMDIR = 1010
-CANT_FIND_SYSTEM_REC = 1012
-CANT_GET_STAT = 1013
-CANT_LOCK = 1015
-CANT_OPEN_FILE = 1016
-FILE_NOT_FOUND = 1017
-CANT_READ_DIR = 1018
-CHECKREAD = 1020
-DUP_KEY = 1022
-ERROR_ON_READ = 1024
-ERROR_ON_RENAME = 1025
-ERROR_ON_WRITE = 1026
-FILE_USED = 1027
-FILSORT_ABORT = 1028
-GET_ERRNO = 1030
-ILLEGAL_HA = 1031
-KEY_NOT_FOUND = 1032
-NOT_FORM_FILE = 1033
-NOT_KEYFILE = 1034
-OLD_KEYFILE = 1035
-OPEN_AS_READONLY = 1036
-OUTOFMEMORY = 1037
-OUT_OF_SORTMEMORY = 1038
-CON_COUNT_ERROR = 1040
-OUT_OF_RESOURCES = 1041
-BAD_HOST_ERROR = 1042
-HANDSHAKE_ERROR = 1043
-DBACCESS_DENIED_ERROR = 1044
-ACCESS_DENIED_ERROR = 1045
-NO_DB_ERROR = 1046
-UNKNOWN_COM_ERROR = 1047
-BAD_NULL_ERROR = 1048
-BAD_DB_ERROR = 1049
-TABLE_EXISTS_ERROR = 1050
-BAD_TABLE_ERROR = 1051
-NON_UNIQ_ERROR = 1052
-SERVER_SHUTDOWN = 1053
-BAD_FIELD_ERROR = 1054
-WRONG_FIELD_WITH_GROUP = 1055
-WRONG_GROUP_FIELD = 1056
-WRONG_SUM_SELECT = 1057
-WRONG_VALUE_COUNT = 1058
-TOO_LONG_IDENT = 1059
-DUP_FIELDNAME = 1060
-DUP_KEYNAME = 1061
-DUP_ENTRY = 1062
-WRONG_FIELD_SPEC = 1063
-PARSE_ERROR = 1064
-EMPTY_QUERY = 1065
-NONUNIQ_TABLE = 1066
-INVALID_DEFAULT = 1067
-MULTIPLE_PRI_KEY = 1068
-TOO_MANY_KEYS = 1069
-TOO_MANY_KEY_PARTS = 1070
-TOO_LONG_KEY = 1071
-KEY_COLUMN_DOES_NOT_EXITS = 1072
-BLOB_USED_AS_KEY = 1073
-TOO_BIG_FIELDLENGTH = 1074
-WRONG_AUTO_KEY = 1075
-READY = 1076
-SHUTDOWN_COMPLETE = 1079
-FORCING_CLOSE = 1080
-IPSOCK_ERROR = 1081
-NO_SUCH_INDEX = 1082
-WRONG_FIELD_TERMINATORS = 1083
-BLOBS_AND_NO_TERMINATED = 1084
-TEXTFILE_NOT_READABLE = 1085
-FILE_EXISTS_ERROR = 1086
-LOAD_INFO = 1087
-ALTER_INFO = 1088
-WRONG_SUB_KEY = 1089
-CANT_REMOVE_ALL_FIELDS = 1090
-CANT_DROP_FIELD_OR_KEY = 1091
-INSERT_INFO = 1092
-UPDATE_TABLE_USED = 1093
-NO_SUCH_THREAD = 1094
-KILL_DENIED_ERROR = 1095
-NO_TABLES_USED = 1096
-TOO_BIG_SET = 1097
-NO_UNIQUE_LOGFILE = 1098
-TABLE_NOT_LOCKED_FOR_WRITE = 1099
-TABLE_NOT_LOCKED = 1100
-BLOB_CANT_HAVE_DEFAULT = 1101
-WRONG_DB_NAME = 1102
-WRONG_TABLE_NAME = 1103
-TOO_BIG_SELECT = 1104
-UNKNOWN_ERROR = 1105
-UNKNOWN_PROCEDURE = 1106
-WRONG_PARAMCOUNT_TO_PROCEDURE = 1107
-WRONG_PARAMETERS_TO_PROCEDURE = 1108
-UNKNOWN_TABLE = 1109
-FIELD_SPECIFIED_TWICE = 1110
-INVALID_GROUP_FUNC_USE = 1111
-UNSUPPORTED_EXTENSION = 1112
-TABLE_MUST_HAVE_COLUMNS = 1113
-RECORD_FILE_FULL = 1114
-UNKNOWN_CHARACTER_SET = 1115
-TOO_MANY_TABLES = 1116
-TOO_MANY_FIELDS = 1117
-TOO_BIG_ROWSIZE = 1118
-STACK_OVERRUN = 1119
-WRONG_OUTER_JOIN_UNUSED = 1120
-NULL_COLUMN_IN_INDEX = 1121
-CANT_FIND_UDF = 1122
-CANT_INITIALIZE_UDF = 1123
-UDF_NO_PATHS = 1124
-UDF_EXISTS = 1125
-CANT_OPEN_LIBRARY = 1126
-CANT_FIND_DL_ENTRY = 1127
-FUNCTION_NOT_DEFINED = 1128
-HOST_IS_BLOCKED = 1129
-HOST_NOT_PRIVILEGED = 1130
-PASSWORD_ANONYMOUS_USER = 1131
-PASSWORD_NOT_ALLOWED = 1132
-PASSWORD_NO_MATCH = 1133
-UPDATE_INFO = 1134
-CANT_CREATE_THREAD = 1135
-WRONG_VALUE_COUNT_ON_ROW = 1136
-CANT_REOPEN_TABLE = 1137
-INVALID_USE_OF_NULL = 1138
-REGEXP_ERROR = 1139
-MIX_OF_GROUP_FUNC_AND_FIELDS = 1140
-NONEXISTING_GRANT = 1141
-TABLEACCESS_DENIED_ERROR = 1142
-COLUMNACCESS_DENIED_ERROR = 1143
-ILLEGAL_GRANT_FOR_TABLE = 1144
-GRANT_WRONG_HOST_OR_USER = 1145
-NO_SUCH_TABLE = 1146
-NONEXISTING_TABLE_GRANT = 1147
-NOT_ALLOWED_COMMAND = 1148
-SYNTAX_ERROR = 1149
-ABORTING_CONNECTION = 1152
-NET_PACKET_TOO_LARGE = 1153
-NET_READ_ERROR_FROM_PIPE = 1154
-NET_FCNTL_ERROR = 1155
-NET_PACKETS_OUT_OF_ORDER = 1156
-NET_UNCOMPRESS_ERROR = 1157
-NET_READ_ERROR = 1158
-NET_READ_INTERRUPTED = 1159
-NET_ERROR_ON_WRITE = 1160
-NET_WRITE_INTERRUPTED = 1161
-TOO_LONG_STRING = 1162
-TABLE_CANT_HANDLE_BLOB = 1163
-TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164
-WRONG_COLUMN_NAME = 1166
-WRONG_KEY_COLUMN = 1167
-WRONG_MRG_TABLE = 1168
-DUP_UNIQUE = 1169
-BLOB_KEY_WITHOUT_LENGTH = 1170
-PRIMARY_CANT_HAVE_NULL = 1171
-TOO_MANY_ROWS = 1172
-REQUIRES_PRIMARY_KEY = 1173
-UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175
-KEY_DOES_NOT_EXITS = 1176
-CHECK_NO_SUCH_TABLE = 1177
-CHECK_NOT_IMPLEMENTED = 1178
-CANT_DO_THIS_DURING_AN_TRANSACTION = 1179
-ERROR_DURING_COMMIT = 1180
-ERROR_DURING_ROLLBACK = 1181
-ERROR_DURING_FLUSH_LOGS = 1182
-NEW_ABORTING_CONNECTION = 1184
-MASTER = 1188
-MASTER_NET_READ = 1189
-MASTER_NET_WRITE = 1190
-FT_MATCHING_KEY_NOT_FOUND = 1191
-LOCK_OR_ACTIVE_TRANSACTION = 1192
-UNKNOWN_SYSTEM_VARIABLE = 1193
-CRASHED_ON_USAGE = 1194
-CRASHED_ON_REPAIR = 1195
-WARNING_NOT_COMPLETE_ROLLBACK = 1196
-TRANS_CACHE_FULL = 1197
-SLAVE_NOT_RUNNING = 1199
-BAD_SLAVE = 1200
-MASTER_INFO = 1201
-SLAVE_THREAD = 1202
-TOO_MANY_USER_CONNECTIONS = 1203
-SET_CONSTANTS_ONLY = 1204
-LOCK_WAIT_TIMEOUT = 1205
-LOCK_TABLE_FULL = 1206
-READ_ONLY_TRANSACTION = 1207
-WRONG_ARGUMENTS = 1210
-NO_PERMISSION_TO_CREATE_USER = 1211
-LOCK_DEADLOCK = 1213
-TABLE_CANT_HANDLE_FT = 1214
-CANNOT_ADD_FOREIGN = 1215
-NO_REFERENCED_ROW = 1216
-ROW_IS_REFERENCED = 1217
-CONNECT_TO_MASTER = 1218
-ERROR_WHEN_EXECUTING_COMMAND = 1220
-WRONG_USAGE = 1221
-WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222
-CANT_UPDATE_WITH_READLOCK = 1223
-MIXING_NOT_ALLOWED = 1224
-DUP_ARGUMENT = 1225
-USER_LIMIT_REACHED = 1226
-SPECIFIC_ACCESS_DENIED_ERROR = 1227
-LOCAL_VARIABLE = 1228
-GLOBAL_VARIABLE = 1229
-NO_DEFAULT = 1230
-WRONG_VALUE_FOR_VAR = 1231
-WRONG_TYPE_FOR_VAR = 1232
-VAR_CANT_BE_READ = 1233
-CANT_USE_OPTION_HERE = 1234
-NOT_SUPPORTED_YET = 1235
-MASTER_FATAL_ERROR_READING_BINLOG = 1236
-SLAVE_IGNORED_TABLE = 1237
-INCORRECT_GLOBAL_LOCAL_VAR = 1238
-WRONG_FK_DEF = 1239
-KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240
-OPERAND_COLUMNS = 1241
-SUBQUERY_NO_1_ROW = 1242
-UNKNOWN_STMT_HANDLER = 1243
-CORRUPT_HELP_DB = 1244
-AUTO_CONVERT = 1246
-ILLEGAL_REFERENCE = 1247
-DERIVED_MUST_HAVE_ALIAS = 1248
-SELECT_REDUCED = 1249
-TABLENAME_NOT_ALLOWED_HERE = 1250
-NOT_SUPPORTED_AUTH_MODE = 1251
-SPATIAL_CANT_HAVE_NULL = 1252
-COLLATION_CHARSET_MISMATCH = 1253
-TOO_BIG_FOR_UNCOMPRESS = 1256
-ZLIB_Z_MEM_ERROR = 1257
-ZLIB_Z_BUF_ERROR = 1258
-ZLIB_Z_DATA_ERROR = 1259
-CUT_VALUE_GROUP_CONCAT = 1260
-WARN_TOO_FEW_RECORDS = 1261
-WARN_TOO_MANY_RECORDS = 1262
-WARN_NULL_TO_NOTNULL = 1263
-WARN_DATA_OUT_OF_RANGE = 1264
-WARN_DATA_TRUNCATED = 1265
-WARN_USING_OTHER_HANDLER = 1266
-CANT_AGGREGATE_2COLLATIONS = 1267
-REVOKE_GRANTS = 1269
-CANT_AGGREGATE_3COLLATIONS = 1270
-CANT_AGGREGATE_NCOLLATIONS = 1271
-VARIABLE_IS_NOT_STRUCT = 1272
-UNKNOWN_COLLATION = 1273
-SLAVE_IGNORED_SSL_PARAMS = 1274
-SERVER_IS_IN_SECURE_AUTH_MODE = 1275
-WARN_FIELD_RESOLVED = 1276
-BAD_SLAVE_UNTIL_COND = 1277
-MISSING_SKIP_SLAVE = 1278
-UNTIL_COND_IGNORED = 1279
-WRONG_NAME_FOR_INDEX = 1280
-WRONG_NAME_FOR_CATALOG = 1281
-BAD_FT_COLUMN = 1283
-UNKNOWN_KEY_CACHE = 1284
-WARN_HOSTNAME_WONT_WORK = 1285
-UNKNOWN_STORAGE_ENGINE = 1286
-WARN_DEPRECATED_SYNTAX = 1287
-NON_UPDATABLE_TABLE = 1288
-FEATURE_DISABLED = 1289
-OPTION_PREVENTS_STATEMENT = 1290
-DUPLICATED_VALUE_IN_TYPE = 1291
-TRUNCATED_WRONG_VALUE = 1292
-INVALID_ON_UPDATE = 1294
-UNSUPPORTED_PS = 1295
-GET_ERRMSG = 1296
-GET_TEMPORARY_ERRMSG = 1297
-UNKNOWN_TIME_ZONE = 1298
-WARN_INVALID_TIMESTAMP = 1299
-INVALID_CHARACTER_STRING = 1300
-WARN_ALLOWED_PACKET_OVERFLOWED = 1301
-CONFLICTING_DECLARATIONS = 1302
-SP_NO_RECURSIVE_CREATE = 1303
-SP_ALREADY_EXISTS = 1304
-SP_DOES_NOT_EXIST = 1305
-SP_DROP_FAILED = 1306
-SP_STORE_FAILED = 1307
-SP_LILABEL_MISMATCH = 1308
-SP_LABEL_REDEFINE = 1309
-SP_LABEL_MISMATCH = 1310
-SP_UNINIT_VAR = 1311
-SP_BADSELECT = 1312
-SP_BADRETURN = 1313
-SP_BADSTATEMENT = 1314
-UPDATE_LOG_DEPRECATED_IGNORED = 1315
-UPDATE_LOG_DEPRECATED_TRANSLATED = 1316
-QUERY_INTERRUPTED = 1317
-SP_WRONG_NO_OF_ARGS = 1318
-SP_COND_MISMATCH = 1319
-SP_NORETURN = 1320
-SP_NORETURNEND = 1321
-SP_BAD_CURSOR_QUERY = 1322
-SP_BAD_CURSOR_SELECT = 1323
-SP_CURSOR_MISMATCH = 1324
-SP_CURSOR_ALREADY_OPEN = 1325
-SP_CURSOR_NOT_OPEN = 1326
-SP_UNDECLARED_VAR = 1327
-SP_WRONG_NO_OF_FETCH_ARGS = 1328
-SP_FETCH_NO_DATA = 1329
-SP_DUP_PARAM = 1330
-SP_DUP_VAR = 1331
-SP_DUP_COND = 1332
-SP_DUP_CURS = 1333
-SP_CANT_ALTER = 1334
-SP_SUBSELECT_NYI = 1335
-STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336
-SP_VARCOND_AFTER_CURSHNDLR = 1337
-SP_CURSOR_AFTER_HANDLER = 1338
-SP_CASE_NOT_FOUND = 1339
-FPARSER_TOO_BIG_FILE = 1340
-FPARSER_BAD_HEADER = 1341
-FPARSER_EOF_IN_COMMENT = 1342
-FPARSER_ERROR_IN_PARAMETER = 1343
-FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344
-VIEW_NO_EXPLAIN = 1345
-WRONG_OBJECT = 1347
-NONUPDATEABLE_COLUMN = 1348
-VIEW_SELECT_CLAUSE = 1350
-VIEW_SELECT_VARIABLE = 1351
-VIEW_SELECT_TMPTABLE = 1352
-VIEW_WRONG_LIST = 1353
-WARN_VIEW_MERGE = 1354
-WARN_VIEW_WITHOUT_KEY = 1355
-VIEW_INVALID = 1356
-SP_NO_DROP_SP = 1357
-TRG_ALREADY_EXISTS = 1359
-TRG_DOES_NOT_EXIST = 1360
-TRG_ON_VIEW_OR_TEMP_TABLE = 1361
-TRG_CANT_CHANGE_ROW = 1362
-TRG_NO_SUCH_ROW_IN_TRG = 1363
-NO_DEFAULT_FOR_FIELD = 1364
-DIVISION_BY_ZERO = 1365
-TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366
-ILLEGAL_VALUE_FOR_TYPE = 1367
-VIEW_NONUPD_CHECK = 1368
-VIEW_CHECK_FAILED = 1369
-PROCACCESS_DENIED_ERROR = 1370
-RELAY_LOG_FAIL = 1371
-UNKNOWN_TARGET_BINLOG = 1373
-IO_ERR_LOG_INDEX_READ = 1374
-BINLOG_PURGE_PROHIBITED = 1375
-FSEEK_FAIL = 1376
-BINLOG_PURGE_FATAL_ERR = 1377
-LOG_IN_USE = 1378
-LOG_PURGE_UNKNOWN_ERR = 1379
-RELAY_LOG_INIT = 1380
-NO_BINARY_LOGGING = 1381
-RESERVED_SYNTAX = 1382
-PS_MANY_PARAM = 1390
-KEY_PART_0 = 1391
-VIEW_CHECKSUM = 1392
-VIEW_MULTIUPDATE = 1393
-VIEW_NO_INSERT_FIELD_LIST = 1394
-VIEW_DELETE_MERGE_VIEW = 1395
-CANNOT_USER = 1396
-XAER_NOTA = 1397
-XAER_INVAL = 1398
-XAER_RMFAIL = 1399
-XAER_OUTSIDE = 1400
-XAER_RMERR = 1401
-XA_RBROLLBACK = 1402
-NONEXISTING_PROC_GRANT = 1403
-PROC_AUTO_GRANT_FAIL = 1404
-PROC_AUTO_REVOKE_FAIL = 1405
-DATA_TOO_LONG = 1406
-SP_BAD_SQLSTATE = 1407
-STARTUP = 1408
-LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409
-CANT_CREATE_USER_WITH_GRANT = 1410
-WRONG_VALUE_FOR_TYPE = 1411
-TABLE_DEF_CHANGED = 1412
-SP_DUP_HANDLER = 1413
-SP_NOT_VAR_ARG = 1414
-SP_NO_RETSET = 1415
-CANT_CREATE_GEOMETRY_OBJECT = 1416
-BINLOG_UNSAFE_ROUTINE = 1418
-BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419
-STMT_HAS_NO_OPEN_CURSOR = 1421
-COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422
-NO_DEFAULT_FOR_VIEW_FIELD = 1423
-SP_NO_RECURSION = 1424
-TOO_BIG_SCALE = 1425
-TOO_BIG_PRECISION = 1426
-M_BIGGER_THAN_D = 1427
-WRONG_LOCK_OF_SYSTEM_TABLE = 1428
-CONNECT_TO_FOREIGN_DATA_SOURCE = 1429
-QUERY_ON_FOREIGN_DATA_SOURCE = 1430
-FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431
-FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432
-FOREIGN_DATA_STRING_INVALID = 1433
-TRG_IN_WRONG_SCHEMA = 1435
-STACK_OVERRUN_NEED_MORE = 1436
-TOO_LONG_BODY = 1437
-WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438
-TOO_BIG_DISPLAYWIDTH = 1439
-XAER_DUPID = 1440
-DATETIME_FUNCTION_OVERFLOW = 1441
-CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442
-VIEW_PREVENT_UPDATE = 1443
-PS_NO_RECURSION = 1444
-SP_CANT_SET_AUTOCOMMIT = 1445
-VIEW_FRM_NO_USER = 1447
-VIEW_OTHER_USER = 1448
-NO_SUCH_USER = 1449
-FORBID_SCHEMA_CHANGE = 1450
-ROW_IS_REFERENCED_2 = 1451
-NO_REFERENCED_ROW_2 = 1452
-SP_BAD_VAR_SHADOW = 1453
-TRG_NO_DEFINER = 1454
-OLD_FILE_FORMAT = 1455
-SP_RECURSION_LIMIT = 1456
-SP_WRONG_NAME = 1458
-TABLE_NEEDS_UPGRADE = 1459
-SP_NO_AGGREGATE = 1460
-MAX_PREPARED_STMT_COUNT_REACHED = 1461
-VIEW_RECURSIVE = 1462
-NON_GROUPING_FIELD_USED = 1463
-TABLE_CANT_HANDLE_SPKEYS = 1464
-NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465
-REMOVED_SPACES = 1466
-AUTOINC_READ_FAILED = 1467
-USERNAME = 1468
-HOSTNAME = 1469
-WRONG_STRING_LENGTH = 1470
-NON_INSERTABLE_TABLE = 1471
-ADMIN_WRONG_MRG_TABLE = 1472
-TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT = 1473
-NAME_BECOMES_EMPTY = 1474
-AMBIGUOUS_FIELD_TERM = 1475
-FOREIGN_SERVER_EXISTS = 1476
-FOREIGN_SERVER_DOESNT_EXIST = 1477
-ILLEGAL_HA_CREATE_OPTION = 1478
-PARTITION_REQUIRES_VALUES_ERROR = 1479
-PARTITION_WRONG_VALUES_ERROR = 1480
-PARTITION_MAXVALUE_ERROR = 1481
-PARTITION_WRONG_NO_PART_ERROR = 1484
-PARTITION_WRONG_NO_SUBPART_ERROR = 1485
-WRONG_EXPR_IN_PARTITION_FUNC_ERROR = 1486
-FIELD_NOT_FOUND_PART_ERROR = 1488
-INCONSISTENT_PARTITION_INFO_ERROR = 1490
-PARTITION_FUNC_NOT_ALLOWED_ERROR = 1491
-PARTITIONS_MUST_BE_DEFINED_ERROR = 1492
-RANGE_NOT_INCREASING_ERROR = 1493
-INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR = 1494
-MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR = 1495
-PARTITION_ENTRY_ERROR = 1496
-MIX_HANDLER_ERROR = 1497
-PARTITION_NOT_DEFINED_ERROR = 1498
-TOO_MANY_PARTITIONS_ERROR = 1499
-SUBPARTITION_ERROR = 1500
-CANT_CREATE_HANDLER_FILE = 1501
-BLOB_FIELD_IN_PART_FUNC_ERROR = 1502
-UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF = 1503
-NO_PARTS_ERROR = 1504
-PARTITION_MGMT_ON_NONPARTITIONED = 1505
-FOREIGN_KEY_ON_PARTITIONED = 1506
-DROP_PARTITION_NON_EXISTENT = 1507
-DROP_LAST_PARTITION = 1508
-COALESCE_ONLY_ON_HASH_PARTITION = 1509
-REORG_HASH_ONLY_ON_SAME_NO = 1510
-REORG_NO_PARAM_ERROR = 1511
-ONLY_ON_RANGE_LIST_PARTITION = 1512
-ADD_PARTITION_SUBPART_ERROR = 1513
-ADD_PARTITION_NO_NEW_PARTITION = 1514
-COALESCE_PARTITION_NO_PARTITION = 1515
-REORG_PARTITION_NOT_EXIST = 1516
-SAME_NAME_PARTITION = 1517
-NO_BINLOG_ERROR = 1518
-CONSECUTIVE_REORG_PARTITIONS = 1519
-REORG_OUTSIDE_RANGE = 1520
-PARTITION_FUNCTION_FAILURE = 1521
-LIMITED_PART_RANGE = 1523
-PLUGIN_IS_NOT_LOADED = 1524
-WRONG_VALUE = 1525
-NO_PARTITION_FOR_GIVEN_VALUE = 1526
-FILEGROUP_OPTION_ONLY_ONCE = 1527
-CREATE_FILEGROUP_FAILED = 1528
-DROP_FILEGROUP_FAILED = 1529
-TABLESPACE_AUTO_EXTEND_ERROR = 1530
-WRONG_SIZE_NUMBER = 1531
-SIZE_OVERFLOW_ERROR = 1532
-ALTER_FILEGROUP_FAILED = 1533
-BINLOG_ROW_LOGGING_FAILED = 1534
-EVENT_ALREADY_EXISTS = 1537
-EVENT_DOES_NOT_EXIST = 1539
-EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG = 1542
-EVENT_ENDS_BEFORE_STARTS = 1543
-EVENT_EXEC_TIME_IN_THE_PAST = 1544
-EVENT_SAME_NAME = 1551
-DROP_INDEX_FK = 1553
-WARN_DEPRECATED_SYNTAX_WITH_VER = 1554
-CANT_LOCK_LOG_TABLE = 1556
-FOREIGN_DUPLICATE_KEY_OLD_UNUSED = 1557
-COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE = 1558
-TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR = 1559
-STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1560
-PARTITION_NO_TEMPORARY = 1562
-PARTITION_CONST_DOMAIN_ERROR = 1563
-PARTITION_FUNCTION_IS_NOT_ALLOWED = 1564
-NULL_IN_VALUES_LESS_THAN = 1566
-WRONG_PARTITION_NAME = 1567
-CANT_CHANGE_TX_CHARACTERISTICS = 1568
-DUP_ENTRY_AUTOINCREMENT_CASE = 1569
-EVENT_SET_VAR_ERROR = 1571
-PARTITION_MERGE_ERROR = 1572
-BASE64_DECODE_ERROR = 1575
-EVENT_RECURSION_FORBIDDEN = 1576
-ONLY_INTEGERS_ALLOWED = 1578
-UNSUPORTED_LOG_ENGINE = 1579
-BAD_LOG_STATEMENT = 1580
-CANT_RENAME_LOG_TABLE = 1581
-WRONG_PARAMCOUNT_TO_NATIVE_FCT = 1582
-WRONG_PARAMETERS_TO_NATIVE_FCT = 1583
-WRONG_PARAMETERS_TO_STORED_FCT = 1584
-NATIVE_FCT_NAME_COLLISION = 1585
-DUP_ENTRY_WITH_KEY_NAME = 1586
-BINLOG_PURGE_EMFILE = 1587
-EVENT_CANNOT_CREATE_IN_THE_PAST = 1588
-EVENT_CANNOT_ALTER_IN_THE_PAST = 1589
-NO_PARTITION_FOR_GIVEN_VALUE_SILENT = 1591
-BINLOG_UNSAFE_STATEMENT = 1592
-BINLOG_FATAL_ERROR = 1593
-BINLOG_LOGGING_IMPOSSIBLE = 1598
-VIEW_NO_CREATION_CTX = 1599
-VIEW_INVALID_CREATION_CTX = 1600
-TRG_CORRUPTED_FILE = 1602
-TRG_NO_CREATION_CTX = 1603
-TRG_INVALID_CREATION_CTX = 1604
-EVENT_INVALID_CREATION_CTX = 1605
-TRG_CANT_OPEN_TABLE = 1606
-NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT = 1609
-SLAVE_CORRUPT_EVENT = 1610
-LOG_PURGE_NO_FILE = 1612
-XA_RBTIMEOUT = 1613
-XA_RBDEADLOCK = 1614
-NEED_REPREPARE = 1615
-WARN_NO_MASTER_INFO = 1617
-WARN_OPTION_IGNORED = 1618
-PLUGIN_DELETE_BUILTIN = 1619
-WARN_PLUGIN_BUSY = 1620
-VARIABLE_IS_READONLY = 1621
-WARN_ENGINE_TRANSACTION_ROLLBACK = 1622
-SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624
-NDB_REPLICATION_SCHEMA_ERROR = 1625
-CONFLICT_FN_PARSE_ERROR = 1626
-EXCEPTIONS_WRITE_ERROR = 1627
-TOO_LONG_TABLE_COMMENT = 1628
-TOO_LONG_FIELD_COMMENT = 1629
-FUNC_INEXISTENT_NAME_COLLISION = 1630
-DATABASE_NAME = 1631
-TABLE_NAME = 1632
-PARTITION_NAME = 1633
-SUBPARTITION_NAME = 1634
-TEMPORARY_NAME = 1635
-RENAMED_NAME = 1636
-TOO_MANY_CONCURRENT_TRXS = 1637
-WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED = 1638
-DEBUG_SYNC_TIMEOUT = 1639
-DEBUG_SYNC_HIT_LIMIT = 1640
-DUP_SIGNAL_SET = 1641
-SIGNAL_WARN = 1642
-SIGNAL_NOT_FOUND = 1643
-SIGNAL_EXCEPTION = 1644
-RESIGNAL_WITHOUT_ACTIVE_HANDLER = 1645
-SIGNAL_BAD_CONDITION_TYPE = 1646
-WARN_COND_ITEM_TRUNCATED = 1647
-COND_ITEM_TOO_LONG = 1648
-UNKNOWN_LOCALE = 1649
-SLAVE_IGNORE_SERVER_IDS = 1650
-SAME_NAME_PARTITION_FIELD = 1652
-PARTITION_COLUMN_LIST_ERROR = 1653
-WRONG_TYPE_COLUMN_VALUE_ERROR = 1654
-TOO_MANY_PARTITION_FUNC_FIELDS_ERROR = 1655
-MAXVALUE_IN_VALUES_IN = 1656
-TOO_MANY_VALUES_ERROR = 1657
-ROW_SINGLE_PARTITION_FIELD_ERROR = 1658
-FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD = 1659
-PARTITION_FIELDS_TOO_LONG = 1660
-BINLOG_ROW_ENGINE_AND_STMT_ENGINE = 1661
-BINLOG_ROW_MODE_AND_STMT_ENGINE = 1662
-BINLOG_UNSAFE_AND_STMT_ENGINE = 1663
-BINLOG_ROW_INJECTION_AND_STMT_ENGINE = 1664
-BINLOG_STMT_MODE_AND_ROW_ENGINE = 1665
-BINLOG_ROW_INJECTION_AND_STMT_MODE = 1666
-BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1667
-BINLOG_UNSAFE_LIMIT = 1668
-BINLOG_UNSAFE_SYSTEM_TABLE = 1670
-BINLOG_UNSAFE_AUTOINC_COLUMNS = 1671
-BINLOG_UNSAFE_UDF = 1672
-BINLOG_UNSAFE_SYSTEM_VARIABLE = 1673
-BINLOG_UNSAFE_SYSTEM_FUNCTION = 1674
-BINLOG_UNSAFE_NONTRANS_AFTER_TRANS = 1675
-MESSAGE_AND_STATEMENT = 1676
-SLAVE_CANT_CREATE_CONVERSION = 1678
-INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1679
-PATH_LENGTH = 1680
-WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT = 1681
-WRONG_NATIVE_TABLE_STRUCTURE = 1682
-WRONG_PERFSCHEMA_USAGE = 1683
-WARN_I_S_SKIPPED_TABLE = 1684
-INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1685
-STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1686
-SPATIAL_MUST_HAVE_GEOM_COL = 1687
-TOO_LONG_INDEX_COMMENT = 1688
-LOCK_ABORTED = 1689
-DATA_OUT_OF_RANGE = 1690
-WRONG_SPVAR_TYPE_IN_LIMIT = 1691
-BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1692
-BINLOG_UNSAFE_MIXED_STATEMENT = 1693
-INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1694
-STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1695
-FAILED_READ_FROM_PAR_FILE = 1696
-VALUES_IS_NOT_INT_TYPE_ERROR = 1697
-ACCESS_DENIED_NO_PASSWORD_ERROR = 1698
-SET_PASSWORD_AUTH_PLUGIN = 1699
-TRUNCATE_ILLEGAL_FK = 1701
-PLUGIN_IS_PERMANENT = 1702
-SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703
-SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704
-STMT_CACHE_FULL = 1705
-MULTI_UPDATE_KEY_CONFLICT = 1706
-TABLE_NEEDS_REBUILD = 1707
-WARN_OPTION_BELOW_LIMIT = 1708
-INDEX_COLUMN_TOO_LONG = 1709
-ERROR_IN_TRIGGER_BODY = 1710
-ERROR_IN_UNKNOWN_TRIGGER_BODY = 1711
-INDEX_CORRUPT = 1712
-UNDO_RECORD_TOO_BIG = 1713
-BINLOG_UNSAFE_INSERT_IGNORE_SELECT = 1714
-BINLOG_UNSAFE_INSERT_SELECT_UPDATE = 1715
-BINLOG_UNSAFE_REPLACE_SELECT = 1716
-BINLOG_UNSAFE_CREATE_IGNORE_SELECT = 1717
-BINLOG_UNSAFE_CREATE_REPLACE_SELECT = 1718
-BINLOG_UNSAFE_UPDATE_IGNORE = 1719
-PLUGIN_NO_UNINSTALL = 1720
-PLUGIN_NO_INSTALL = 1721
-BINLOG_UNSAFE_WRITE_AUTOINC_SELECT = 1722
-BINLOG_UNSAFE_CREATE_SELECT_AUTOINC = 1723
-BINLOG_UNSAFE_INSERT_TWO_KEYS = 1724
-TABLE_IN_FK_CHECK = 1725
-UNSUPPORTED_ENGINE = 1726
-BINLOG_UNSAFE_AUTOINC_NOT_FIRST = 1727
-CANNOT_LOAD_FROM_TABLE_V2 = 1728
-MASTER_DELAY_VALUE_OUT_OF_RANGE = 1729
-ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT = 1730
-PARTITION_EXCHANGE_DIFFERENT_OPTION = 1731
-PARTITION_EXCHANGE_PART_TABLE = 1732
-PARTITION_EXCHANGE_TEMP_TABLE = 1733
-PARTITION_INSTEAD_OF_SUBPARTITION = 1734
-UNKNOWN_PARTITION = 1735
-TABLES_DIFFERENT_METADATA = 1736
-ROW_DOES_NOT_MATCH_PARTITION = 1737
-BINLOG_CACHE_SIZE_GREATER_THAN_MAX = 1738
-WARN_INDEX_NOT_APPLICABLE = 1739
-PARTITION_EXCHANGE_FOREIGN_KEY = 1740
-RPL_INFO_DATA_TOO_LONG = 1742
-BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX = 1745
-CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT = 1746
-PARTITION_CLAUSE_ON_NONPARTITIONED = 1747
-ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET = 1748
-CHANGE_RPL_INFO_REPOSITORY_FAILURE = 1750
-WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE = 1751
-WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE = 1752
-MTS_FEATURE_IS_NOT_SUPPORTED = 1753
-MTS_UPDATED_DBS_GREATER_MAX = 1754
-MTS_CANT_PARALLEL = 1755
-MTS_INCONSISTENT_DATA = 1756
-FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING = 1757
-DA_INVALID_CONDITION_NUMBER = 1758
-INSECURE_PLAIN_TEXT = 1759
-INSECURE_CHANGE_MASTER = 1760
-FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO = 1761
-FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO = 1762
-SQLTHREAD_WITH_SECURE_SLAVE = 1763
-TABLE_HAS_NO_FT = 1764
-VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER = 1765
-VARIABLE_NOT_SETTABLE_IN_TRANSACTION = 1766
-SET_STATEMENT_CANNOT_INVOKE_FUNCTION = 1769
-GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL = 1770
-MALFORMED_GTID_SET_SPECIFICATION = 1772
-MALFORMED_GTID_SET_ENCODING = 1773
-MALFORMED_GTID_SPECIFICATION = 1774
-GNO_EXHAUSTED = 1775
-BAD_SLAVE_AUTO_POSITION = 1776
-AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF = 1777
-CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET = 1778
-GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON = 1779
-CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF = 1781
-CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON = 1782
-CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF = 1783
-GTID_UNSAFE_NON_TRANSACTIONAL_TABLE = 1785
-GTID_UNSAFE_CREATE_SELECT = 1786
-GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION = 1787
-GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME = 1788
-MASTER_HAS_PURGED_REQUIRED_GTIDS = 1789
-CANT_SET_GTID_NEXT_WHEN_OWNING_GTID = 1790
-UNKNOWN_EXPLAIN_FORMAT = 1791
-CANT_EXECUTE_IN_READ_ONLY_TRANSACTION = 1792
-TOO_LONG_TABLE_PARTITION_COMMENT = 1793
-SLAVE_CONFIGURATION = 1794
-INNODB_FT_LIMIT = 1795
-INNODB_NO_FT_TEMP_TABLE = 1796
-INNODB_FT_WRONG_DOCID_COLUMN = 1797
-INNODB_FT_WRONG_DOCID_INDEX = 1798
-INNODB_ONLINE_LOG_TOO_BIG = 1799
-UNKNOWN_ALTER_ALGORITHM = 1800
-UNKNOWN_ALTER_LOCK = 1801
-MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS = 1802
-MTS_RECOVERY_FAILURE = 1803
-MTS_RESET_WORKERS = 1804
-COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 = 1805
-SLAVE_SILENT_RETRY_TRANSACTION = 1806
-DISCARD_FK_CHECKS_RUNNING = 1807
-TABLE_SCHEMA_MISMATCH = 1808
-TABLE_IN_SYSTEM_TABLESPACE = 1809
-IO_READ_ERROR = 1810
-IO_WRITE_ERROR = 1811
-TABLESPACE_MISSING = 1812
-TABLESPACE_EXISTS = 1813
-TABLESPACE_DISCARDED = 1814
-INTERNAL_ERROR = 1815
-INNODB_IMPORT_ERROR = 1816
-INNODB_INDEX_CORRUPT = 1817
-INVALID_YEAR_COLUMN_LENGTH = 1818
-NOT_VALID_PASSWORD = 1819
-MUST_CHANGE_PASSWORD = 1820
-FK_NO_INDEX_CHILD = 1821
-FK_NO_INDEX_PARENT = 1822
-FK_FAIL_ADD_SYSTEM = 1823
-FK_CANNOT_OPEN_PARENT = 1824
-FK_INCORRECT_OPTION = 1825
-FK_DUP_NAME = 1826
-PASSWORD_FORMAT = 1827
-FK_COLUMN_CANNOT_DROP = 1828
-FK_COLUMN_CANNOT_DROP_CHILD = 1829
-FK_COLUMN_NOT_NULL = 1830
-DUP_INDEX = 1831
-FK_COLUMN_CANNOT_CHANGE = 1832
-FK_COLUMN_CANNOT_CHANGE_CHILD = 1833
-MALFORMED_PACKET = 1835
-READ_ONLY_MODE = 1836
-GTID_NEXT_TYPE_UNDEFINED_GTID = 1837
-VARIABLE_NOT_SETTABLE_IN_SP = 1838
-CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY = 1840
-CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY = 1841
-GTID_PURGED_WAS_CHANGED = 1842
-GTID_EXECUTED_WAS_CHANGED = 1843
-BINLOG_STMT_MODE_AND_NO_REPL_TABLES = 1844
-ALTER_OPERATION_NOT_SUPPORTED = 1845
-ALTER_OPERATION_NOT_SUPPORTED_REASON = 1846
-ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY = 1847
-ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION = 1848
-ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME = 1849
-ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE = 1850
-ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK = 1851
-ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK = 1853
-ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC = 1854
-ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS = 1855
-ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS = 1856
-ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS = 1857
-SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858
-DUP_UNKNOWN_IN_INDEX = 1859
-IDENT_CAUSES_TOO_LONG_PATH = 1860
-ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL = 1861
-MUST_CHANGE_PASSWORD_LOGIN = 1862
-ROW_IN_WRONG_PARTITION = 1863
-MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX = 1864
-BINLOG_LOGICAL_CORRUPTION = 1866
-WARN_PURGE_LOG_IN_USE = 1867
-WARN_PURGE_LOG_IS_ACTIVE = 1868
-AUTO_INCREMENT_CONFLICT = 1869
-WARN_ON_BLOCKHOLE_IN_RBR = 1870
-SLAVE_MI_INIT_REPOSITORY = 1871
-SLAVE_RLI_INIT_REPOSITORY = 1872
-ACCESS_DENIED_CHANGE_USER_ERROR = 1873
-INNODB_READ_ONLY = 1874
-STOP_SLAVE_SQL_THREAD_TIMEOUT = 1875
-STOP_SLAVE_IO_THREAD_TIMEOUT = 1876
-TABLE_CORRUPT = 1877
-TEMP_FILE_WRITE_FAILURE = 1878
-INNODB_FT_AUX_NOT_HEX_ID = 1879
-OLD_TEMPORALS_UPGRADED = 1880
-INNODB_FORCED_RECOVERY = 1881
-AES_INVALID_IV = 1882
-PLUGIN_CANNOT_BE_UNINSTALLED = 1883
-GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_ASSIGNED_GTID = 1884
-SLAVE_HAS_MORE_GTIDS_THAN_MASTER = 1885
-MISSING_KEY = 1886
-ERROR_LAST = 1973

.venv/lib/python3.12/site-packages/MySQLdb/constants/FIELD_TYPE.py

@@ -1,40 +0,0 @@
-"""MySQL FIELD_TYPE Constants
-
-These constants represent the various column (field) types that are
-supported by MySQL.
-"""
-
-DECIMAL = 0
-TINY = 1
-SHORT = 2
-LONG = 3
-FLOAT = 4
-DOUBLE = 5
-NULL = 6
-TIMESTAMP = 7
-LONGLONG = 8
-INT24 = 9
-DATE = 10
-TIME = 11
-DATETIME = 12
-YEAR = 13
-# NEWDATE = 14  # Internal to MySQL.
-VARCHAR = 15
-BIT = 16
-# TIMESTAMP2 = 17
-# DATETIME2 = 18
-# TIME2 = 19
-JSON = 245
-NEWDECIMAL = 246
-ENUM = 247
-SET = 248
-TINY_BLOB = 249
-MEDIUM_BLOB = 250
-LONG_BLOB = 251
-BLOB = 252
-VAR_STRING = 253
-STRING = 254
-GEOMETRY = 255
-
-CHAR = TINY
-INTERVAL = ENUM

.venv/lib/python3.12/site-packages/MySQLdb/constants/FLAG.py

@@ -1,23 +0,0 @@
-"""MySQL FLAG Constants
-
-These flags are used along with the FIELD_TYPE to indicate various
-properties of columns in a result set.
-
-"""
-
-NOT_NULL = 1
-PRI_KEY = 2
-UNIQUE_KEY = 4
-MULTIPLE_KEY = 8
-BLOB = 16
-UNSIGNED = 32
-ZEROFILL = 64
-BINARY = 128
-ENUM = 256
-AUTO_INCREMENT = 512
-TIMESTAMP = 1024
-SET = 2048
-NUM = 32768
-PART_KEY = 16384
-GROUP = 32768
-UNIQUE = 65536

.venv/lib/python3.12/site-packages/MySQLdb/constants/__init__.py

@@ -1 +0,0 @@
-__all__ = ["CR", "FIELD_TYPE", "CLIENT", "ER", "FLAG"]

.venv/lib/python3.12/site-packages/MySQLdb/converters.py

@@ -1,139 +0,0 @@
-"""MySQLdb type conversion module
-
-This module handles all the type conversions for MySQL. If the default
-type conversions aren't what you need, you can make your own. The
-dictionary conversions maps some kind of type to a conversion function
-which returns the corresponding value:
-
-Key: FIELD_TYPE.* (from MySQLdb.constants)
-
-Conversion function:
-
-    Arguments: string
-
-    Returns: Python object
-
-Key: Python type object (from types) or class
-
-Conversion function:
-
-    Arguments: Python object of indicated type or class AND
-               conversion dictionary
-
-    Returns: SQL literal value
-
-    Notes: Most conversion functions can ignore the dictionary, but
-           it is a required parameter. It is necessary for converting
-           things like sequences and instances.
-
-Don't modify conversions if you can avoid it. Instead, make copies
-(with the copy() method), modify the copies, and then pass them to
-MySQL.connect().
-"""
-from decimal import Decimal
-
-from MySQLdb._mysql import string_literal
-from MySQLdb.constants import FIELD_TYPE, FLAG
-from MySQLdb.times import (
-    Date,
-    DateTimeType,
-    DateTime2literal,
-    DateTimeDeltaType,
-    DateTimeDelta2literal,
-    DateTime_or_None,
-    TimeDelta_or_None,
-    Date_or_None,
-)
-from MySQLdb._exceptions import ProgrammingError
-
-import array
-
-NoneType = type(None)
-
-try:
-    ArrayType = array.ArrayType
-except AttributeError:
-    ArrayType = array.array
-
-
-def Bool2Str(s, d):
-    return b"1" if s else b"0"
-
-
-def Set2Str(s, d):
-    # Only support ascii string.  Not tested.
-    return string_literal(",".join(s))
-
-
-def Thing2Str(s, d):
-    """Convert something into a string via str()."""
-    return str(s)
-
-
-def Float2Str(o, d):
-    s = repr(o)
-    if s in ("inf", "-inf", "nan"):
-        raise ProgrammingError("%s can not be used with MySQL" % s)
-    if "e" not in s:
-        s += "e0"
-    return s
-
-
-def None2NULL(o, d):
-    """Convert None to NULL."""
-    return b"NULL"
-
-
-def Thing2Literal(o, d):
-    """Convert something into a SQL string literal.  If using
-    MySQL-3.23 or newer, string_literal() is a method of the
-    _mysql.MYSQL object, and this function will be overridden with
-    that method when the connection is created."""
-    return string_literal(o)
-
-
-def Decimal2Literal(o, d):
-    return format(o, "f")
-
-
-def array2Str(o, d):
-    return Thing2Literal(o.tostring(), d)
-
-
-# bytes or str regarding to BINARY_FLAG.
-_bytes_or_str = ((FLAG.BINARY, bytes), (None, str))
-
-conversions = {
-    int: Thing2Str,
-    float: Float2Str,
-    NoneType: None2NULL,
-    ArrayType: array2Str,
-    bool: Bool2Str,
-    Date: Thing2Literal,
-    DateTimeType: DateTime2literal,
-    DateTimeDeltaType: DateTimeDelta2literal,
-    set: Set2Str,
-    Decimal: Decimal2Literal,
-    FIELD_TYPE.TINY: int,
-    FIELD_TYPE.SHORT: int,
-    FIELD_TYPE.LONG: int,
-    FIELD_TYPE.FLOAT: float,
-    FIELD_TYPE.DOUBLE: float,
-    FIELD_TYPE.DECIMAL: Decimal,
-    FIELD_TYPE.NEWDECIMAL: Decimal,
-    FIELD_TYPE.LONGLONG: int,
-    FIELD_TYPE.INT24: int,
-    FIELD_TYPE.YEAR: int,
-    FIELD_TYPE.TIMESTAMP: DateTime_or_None,
-    FIELD_TYPE.DATETIME: DateTime_or_None,
-    FIELD_TYPE.TIME: TimeDelta_or_None,
-    FIELD_TYPE.DATE: Date_or_None,
-    FIELD_TYPE.TINY_BLOB: bytes,
-    FIELD_TYPE.MEDIUM_BLOB: bytes,
-    FIELD_TYPE.LONG_BLOB: bytes,
-    FIELD_TYPE.BLOB: bytes,
-    FIELD_TYPE.STRING: bytes,
-    FIELD_TYPE.VAR_STRING: bytes,
-    FIELD_TYPE.VARCHAR: bytes,
-    FIELD_TYPE.JSON: bytes,
-}

.venv/lib/python3.12/site-packages/MySQLdb/cursors.py

@@ -1,500 +0,0 @@
-"""MySQLdb Cursors
-
-This module implements Cursors of various types for MySQLdb. By
-default, MySQLdb uses the Cursor class.
-"""
-import re
-
-from ._exceptions import ProgrammingError
-
-
-#: Regular expression for ``Cursor.executemany```.
-#: executemany only supports simple bulk insert.
-#: You can use it to load large dataset.
-RE_INSERT_VALUES = re.compile(
-    "".join(
-        [
-            r"\s*((?:INSERT|REPLACE)\b.+\bVALUES?\s*)",
-            r"(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))",
-            r"(\s*(?:ON DUPLICATE.*)?);?\s*\Z",
-        ]
-    ),
-    re.IGNORECASE | re.DOTALL,
-)
-
-
-class BaseCursor:
-    """A base for Cursor classes. Useful attributes:
-
-    description
-        A tuple of DB API 7-tuples describing the columns in
-        the last executed query; see PEP-249 for details.
-
-    description_flags
-        Tuple of column flags for last query, one entry per column
-        in the result set. Values correspond to those in
-        MySQLdb.constants.FLAG. See MySQL documentation (C API)
-        for more information. Non-standard extension.
-
-    arraysize
-        default number of rows fetchmany() will fetch
-    """
-
-    #: Max statement size which :meth:`executemany` generates.
-    #:
-    #: Max size of allowed statement is max_allowed_packet - packet_header_size.
-    #: Default value of max_allowed_packet is 1048576.
-    max_stmt_length = 64 * 1024
-
-    from ._exceptions import (
-        MySQLError,
-        Warning,
-        Error,
-        InterfaceError,
-        DatabaseError,
-        DataError,
-        OperationalError,
-        IntegrityError,
-        InternalError,
-        ProgrammingError,
-        NotSupportedError,
-    )
-
-    connection = None
-
-    def __init__(self, connection):
-        self.connection = connection
-        self.description = None
-        self.description_flags = None
-        self.rowcount = 0
-        self.arraysize = 1
-        self._executed = None
-
-        self.lastrowid = None
-        self._result = None
-        self.rownumber = None
-        self._rows = None
-
-    def _discard(self):
-        self.description = None
-        self.description_flags = None
-        # Django uses some member after __exit__.
-        # So we keep rowcount and lastrowid here. They are cleared in Cursor._query().
-        # self.rowcount = 0
-        # self.lastrowid = None
-        self._rows = None
-        self.rownumber = None
-
-        if self._result:
-            self._result.discard()
-            self._result = None
-
-        con = self.connection
-        if con is None:
-            return
-        while con.next_result() == 0:  # -1 means no more data.
-            con.discard_result()
-
-    def close(self):
-        """Close the cursor. No further queries will be possible."""
-        try:
-            if self.connection is None:
-                return
-            self._discard()
-        finally:
-            self.connection = None
-            self._result = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc_info):
-        del exc_info
-        self.close()
-
-    def _check_executed(self):
-        if not self._executed:
-            raise ProgrammingError("execute() first")
-
-    def nextset(self):
-        """Advance to the next result set.
-
-        Returns None if there are no more result sets.
-        """
-        if self._executed:
-            self.fetchall()
-
-        db = self._get_db()
-        nr = db.next_result()
-        if nr == -1:
-            return None
-        self._do_get_result(db)
-        self._post_get_result()
-        return 1
-
-    def _do_get_result(self, db):
-        self._result = result = self._get_result()
-        if result is None:
-            self.description = self.description_flags = None
-        else:
-            self.description = result.describe()
-            self.description_flags = result.field_flags()
-
-        self.rowcount = db.affected_rows()
-        self.rownumber = 0
-        self.lastrowid = db.insert_id()
-
-    def _post_get_result(self):
-        pass
-
-    def setinputsizes(self, *args):
-        """Does nothing, required by DB API."""
-
-    def setoutputsizes(self, *args):
-        """Does nothing, required by DB API."""
-
-    def _get_db(self):
-        con = self.connection
-        if con is None:
-            raise ProgrammingError("cursor closed")
-        return con
-
-    def execute(self, query, args=None):
-        """Execute a query.
-
-        query -- string, query to execute on server
-        args -- optional sequence or mapping, parameters to use with query.
-
-        Note: If args is a sequence, then %s must be used as the
-        parameter placeholder in the query. If a mapping is used,
-        %(key)s must be used as the placeholder.
-
-        Returns integer represents rows affected, if any
-        """
-        self._discard()
-
-        mogrified_query = self._mogrify(query, args)
-
-        assert isinstance(mogrified_query, (bytes, bytearray))
-        res = self._query(mogrified_query)
-        return res
-
-    def _mogrify(self, query, args=None):
-        """Return query after binding args."""
-        db = self._get_db()
-
-        if isinstance(query, str):
-            query = query.encode(db.encoding)
-
-        if args is not None:
-            if isinstance(args, dict):
-                nargs = {}
-                for key, item in args.items():
-                    if isinstance(key, str):
-                        key = key.encode(db.encoding)
-                    nargs[key] = db.literal(item)
-                args = nargs
-            else:
-                args = tuple(map(db.literal, args))
-            try:
-                query = query % args
-            except TypeError as m:
-                raise ProgrammingError(str(m))
-
-        return query
-
-    def mogrify(self, query, args=None):
-        """Return query after binding args.
-
-        query -- string, query to mogrify
-        args -- optional sequence or mapping, parameters to use with query.
-
-        Note: If args is a sequence, then %s must be used as the
-        parameter placeholder in the query. If a mapping is used,
-        %(key)s must be used as the placeholder.
-
-        Returns string representing query that would be executed by the server
-        """
-        return self._mogrify(query, args).decode(self._get_db().encoding)
-
-    def executemany(self, query, args):
-        # type: (str, list) -> int
-        """Execute a multi-row query.
-
-        :param query: query to execute on server
-        :param args:  Sequence of sequences or mappings.  It is used as parameter.
-        :return: Number of rows affected, if any.
-
-        This method improves performance on multiple-row INSERT and
-        REPLACE. Otherwise it is equivalent to looping over args with
-        execute().
-        """
-        if not args:
-            return
-
-        m = RE_INSERT_VALUES.match(query)
-        if m:
-            q_prefix = m.group(1) % ()
-            q_values = m.group(2).rstrip()
-            q_postfix = m.group(3) or ""
-            assert q_values[0] == "(" and q_values[-1] == ")"
-            return self._do_execute_many(
-                q_prefix,
-                q_values,
-                q_postfix,
-                args,
-                self.max_stmt_length,
-                self._get_db().encoding,
-            )
-
-        self.rowcount = sum(self.execute(query, arg) for arg in args)
-        return self.rowcount
-
-    def _do_execute_many(
-        self, prefix, values, postfix, args, max_stmt_length, encoding
-    ):
-        if isinstance(prefix, str):
-            prefix = prefix.encode(encoding)
-        if isinstance(values, str):
-            values = values.encode(encoding)
-        if isinstance(postfix, str):
-            postfix = postfix.encode(encoding)
-        sql = bytearray(prefix)
-        args = iter(args)
-        v = self._mogrify(values, next(args))
-        sql += v
-        rows = 0
-        for arg in args:
-            v = self._mogrify(values, arg)
-            if len(sql) + len(v) + len(postfix) + 1 > max_stmt_length:
-                rows += self.execute(sql + postfix)
-                sql = bytearray(prefix)
-            else:
-                sql += b","
-            sql += v
-        rows += self.execute(sql + postfix)
-        self.rowcount = rows
-        return rows
-
-    def callproc(self, procname, args=()):
-        """Execute stored procedure procname with args
-
-        procname -- string, name of procedure to execute on server
-
-        args -- Sequence of parameters to use with procedure
-
-        Returns the original args.
-
-        Compatibility warning: PEP-249 specifies that any modified
-        parameters must be returned. This is currently impossible
-        as they are only available by storing them in a server
-        variable and then retrieved by a query. Since stored
-        procedures return zero or more result sets, there is no
-        reliable way to get at OUT or INOUT parameters via callproc.
-        The server variables are named @_procname_n, where procname
-        is the parameter above and n is the position of the parameter
-        (from zero). Once all result sets generated by the procedure
-        have been fetched, you can issue a SELECT @_procname_0, ...
-        query using .execute() to get any OUT or INOUT values.
-
-        Compatibility warning: The act of calling a stored procedure
-        itself creates an empty result set. This appears after any
-        result sets generated by the procedure. This is non-standard
-        behavior with respect to the DB-API. Be sure to use nextset()
-        to advance through all result sets; otherwise you may get
-        disconnected.
-        """
-        db = self._get_db()
-        if isinstance(procname, str):
-            procname = procname.encode(db.encoding)
-        if args:
-            fmt = b"@_" + procname + b"_%d=%s"
-            q = b"SET %s" % b",".join(
-                fmt % (index, db.literal(arg)) for index, arg in enumerate(args)
-            )
-            self._query(q)
-            self.nextset()
-
-        q = b"CALL %s(%s)" % (
-            procname,
-            b",".join([b"@_%s_%d" % (procname, i) for i in range(len(args))]),
-        )
-        self._query(q)
-        return args
-
-    def _query(self, q):
-        db = self._get_db()
-        self._result = None
-        self.rowcount = None
-        self.lastrowid = None
-        db.query(q)
-        self._do_get_result(db)
-        self._post_get_result()
-        self._executed = q
-        return self.rowcount
-
-    def _fetch_row(self, size=1):
-        if not self._result:
-            return ()
-        return self._result.fetch_row(size, self._fetch_type)
-
-    def __iter__(self):
-        return iter(self.fetchone, None)
-
-    Warning = Warning
-    Error = Error
-    InterfaceError = InterfaceError
-    DatabaseError = DatabaseError
-    DataError = DataError
-    OperationalError = OperationalError
-    IntegrityError = IntegrityError
-    InternalError = InternalError
-    ProgrammingError = ProgrammingError
-    NotSupportedError = NotSupportedError
-
-
-class CursorStoreResultMixIn:
-    """This is a MixIn class which causes the entire result set to be
-    stored on the client side, i.e. it uses mysql_store_result(). If the
-    result set can be very large, consider adding a LIMIT clause to your
-    query, or using CursorUseResultMixIn instead."""
-
-    def _get_result(self):
-        return self._get_db().store_result()
-
-    def _post_get_result(self):
-        self._rows = self._fetch_row(0)
-        self._result = None
-
-    def fetchone(self):
-        """Fetches a single row from the cursor. None indicates that
-        no more rows are available."""
-        self._check_executed()
-        if self.rownumber >= len(self._rows):
-            return None
-        result = self._rows[self.rownumber]
-        self.rownumber = self.rownumber + 1
-        return result
-
-    def fetchmany(self, size=None):
-        """Fetch up to size rows from the cursor. Result set may be smaller
-        than size. If size is not defined, cursor.arraysize is used."""
-        self._check_executed()
-        end = self.rownumber + (size or self.arraysize)
-        result = self._rows[self.rownumber : end]
-        self.rownumber = min(end, len(self._rows))
-        return result
-
-    def fetchall(self):
-        """Fetches all available rows from the cursor."""
-        self._check_executed()
-        if self.rownumber:
-            result = self._rows[self.rownumber :]
-        else:
-            result = self._rows
-        self.rownumber = len(self._rows)
-        return result
-
-    def scroll(self, value, mode="relative"):
-        """Scroll the cursor in the result set to a new position according
-        to mode.
-
-        If mode is 'relative' (default), value is taken as offset to
-        the current position in the result set, if set to 'absolute',
-        value states an absolute target position."""
-        self._check_executed()
-        if mode == "relative":
-            r = self.rownumber + value
-        elif mode == "absolute":
-            r = value
-        else:
-            raise ProgrammingError("unknown scroll mode %s" % repr(mode))
-        if r < 0 or r >= len(self._rows):
-            raise IndexError("out of range")
-        self.rownumber = r
-
-    def __iter__(self):
-        self._check_executed()
-        result = self.rownumber and self._rows[self.rownumber :] or self._rows
-        return iter(result)
-
-
-class CursorUseResultMixIn:
-
-    """This is a MixIn class which causes the result set to be stored
-    in the server and sent row-by-row to client side, i.e. it uses
-    mysql_use_result(). You MUST retrieve the entire result set and
-    close() the cursor before additional queries can be performed on
-    the connection."""
-
-    def _get_result(self):
-        return self._get_db().use_result()
-
-    def fetchone(self):
-        """Fetches a single row from the cursor."""
-        self._check_executed()
-        r = self._fetch_row(1)
-        if not r:
-            return None
-        self.rownumber = self.rownumber + 1
-        return r[0]
-
-    def fetchmany(self, size=None):
-        """Fetch up to size rows from the cursor. Result set may be smaller
-        than size. If size is not defined, cursor.arraysize is used."""
-        self._check_executed()
-        r = self._fetch_row(size or self.arraysize)
-        self.rownumber = self.rownumber + len(r)
-        return r
-
-    def fetchall(self):
-        """Fetches all available rows from the cursor."""
-        self._check_executed()
-        r = self._fetch_row(0)
-        self.rownumber = self.rownumber + len(r)
-        return r
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        row = self.fetchone()
-        if row is None:
-            raise StopIteration
-        return row
-
-    __next__ = next
-
-
-class CursorTupleRowsMixIn:
-    """This is a MixIn class that causes all rows to be returned as tuples,
-    which is the standard form required by DB API."""
-
-    _fetch_type = 0
-
-
-class CursorDictRowsMixIn:
-    """This is a MixIn class that causes all rows to be returned as
-    dictionaries. This is a non-standard feature."""
-
-    _fetch_type = 1
-
-
-class Cursor(CursorStoreResultMixIn, CursorTupleRowsMixIn, BaseCursor):
-    """This is the standard Cursor class that returns rows as tuples
-    and stores the result set in the client."""
-
-
-class DictCursor(CursorStoreResultMixIn, CursorDictRowsMixIn, BaseCursor):
-    """This is a Cursor class that returns rows as dictionaries and
-    stores the result set in the client."""
-
-
-class SSCursor(CursorUseResultMixIn, CursorTupleRowsMixIn, BaseCursor):
-    """This is a Cursor class that returns rows as tuples and stores
-    the result set in the server."""
-
-
-class SSDictCursor(CursorUseResultMixIn, CursorDictRowsMixIn, BaseCursor):
-    """This is a Cursor class that returns rows as dictionaries and
-    stores the result set in the server."""

.venv/lib/python3.12/site-packages/MySQLdb/release.py

@@ -1,3 +0,0 @@
-__author__ = "Inada Naoki <songofacandy@gmail.com>"
-__version__ = "2.2.8"
-version_info = (2, 2, 8, "final", 0)

.venv/lib/python3.12/site-packages/MySQLdb/times.py

@@ -1,150 +0,0 @@
-"""times module
-
-This module provides some Date and Time classes for dealing with MySQL data.
-
-Use Python datetime module to handle date and time columns.
-"""
-from time import localtime
-from datetime import date, datetime, time, timedelta
-from MySQLdb._mysql import string_literal
-
-Date = date
-Time = time
-TimeDelta = timedelta
-Timestamp = datetime
-
-DateTimeDeltaType = timedelta
-DateTimeType = datetime
-
-
-def DateFromTicks(ticks):
-    """Convert UNIX ticks into a date instance."""
-    return date(*localtime(ticks)[:3])
-
-
-def TimeFromTicks(ticks):
-    """Convert UNIX ticks into a time instance."""
-    return time(*localtime(ticks)[3:6])
-
-
-def TimestampFromTicks(ticks):
-    """Convert UNIX ticks into a datetime instance."""
-    return datetime(*localtime(ticks)[:6])
-
-
-format_TIME = format_DATE = str
-
-
-def format_TIMEDELTA(v):
-    seconds = int(v.seconds) % 60
-    minutes = int(v.seconds // 60) % 60
-    hours = int(v.seconds // 3600) % 24
-    return "%d %d:%d:%d" % (v.days, hours, minutes, seconds)
-
-
-def format_TIMESTAMP(d):
-    """
-    :type d: datetime.datetime
-    """
-    if d.microsecond:
-        fmt = " ".join(
-            [
-                "{0.year:04}-{0.month:02}-{0.day:02}",
-                "{0.hour:02}:{0.minute:02}:{0.second:02}.{0.microsecond:06}",
-            ]
-        )
-    else:
-        fmt = " ".join(
-            [
-                "{0.year:04}-{0.month:02}-{0.day:02}",
-                "{0.hour:02}:{0.minute:02}:{0.second:02}",
-            ]
-        )
-    return fmt.format(d)
-
-
-def DateTime_or_None(s):
-    try:
-        if len(s) < 11:
-            return Date_or_None(s)
-
-        micros = s[20:]
-
-        if len(micros) == 0:
-            # 12:00:00
-            micros = 0
-        elif len(micros) < 7:
-            # 12:00:00.123456
-            micros = int(micros) * 10 ** (6 - len(micros))
-        else:
-            return None
-
-        return datetime(
-            int(s[:4]),  # year
-            int(s[5:7]),  # month
-            int(s[8:10]),  # day
-            int(s[11:13] or 0),  # hour
-            int(s[14:16] or 0),  # minute
-            int(s[17:19] or 0),  # second
-            micros,  # microsecond
-        )
-    except ValueError:
-        return None
-
-
-def TimeDelta_or_None(s):
-    try:
-        h, m, s = s.split(":")
-        if "." in s:
-            s, ms = s.split(".")
-            ms = ms.ljust(6, "0")
-        else:
-            ms = 0
-        if h[0] == "-":
-            negative = True
-        else:
-            negative = False
-        h, m, s, ms = abs(int(h)), int(m), int(s), int(ms)
-        td = timedelta(hours=h, minutes=m, seconds=s, microseconds=ms)
-        if negative:
-            return -td
-        else:
-            return td
-    except ValueError:
-        # unpacking or int/float conversion failed
-        return None
-
-
-def Time_or_None(s):
-    try:
-        h, m, s = s.split(":")
-        if "." in s:
-            s, ms = s.split(".")
-            ms = ms.ljust(6, "0")
-        else:
-            ms = 0
-        h, m, s, ms = int(h), int(m), int(s), int(ms)
-        return time(hour=h, minute=m, second=s, microsecond=ms)
-    except ValueError:
-        return None
-
-
-def Date_or_None(s):
-    try:
-        return date(
-            int(s[:4]),
-            int(s[5:7]),
-            int(s[8:10]),
-        )  # year  # month  # day
-    except ValueError:
-        return None
-
-
-def DateTime2literal(d, c):
-    """Format a DateTime object as an ISO timestamp."""
-    return string_literal(format_TIMESTAMP(d))
-
-
-def DateTimeDelta2literal(d, c):
-    """Format a DateTimeDelta object as a time."""
-    return string_literal(format_TIMEDELTA(d))

.venv/lib/python3.12/site-packages/asgiref-3.11.1.dist-info/INSTALLER

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

.venv/lib/python3.12/site-packages/asgiref-3.11.1.dist-info/METADATA

@@ -1,247 +0,0 @@
-Metadata-Version: 2.4
-Name: asgiref
-Version: 3.11.1
-Summary: ASGI specs, helper code, and adapters
-Home-page: https://github.com/django/asgiref/
-Author: Django Software Foundation
-Author-email: foundation@djangoproject.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://asgi.readthedocs.io/
-Project-URL: Further Documentation, https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions
-Project-URL: Changelog, https://github.com/django/asgiref/blob/master/CHANGELOG.txt
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.9
-License-File: LICENSE
-Requires-Dist: typing_extensions>=4; python_version < "3.11"
-Provides-Extra: tests
-Requires-Dist: pytest; extra == "tests"
-Requires-Dist: pytest-asyncio; extra == "tests"
-Requires-Dist: mypy>=1.14.0; extra == "tests"
-Dynamic: license-file
-
-asgiref
-=======
-
-.. image:: https://github.com/django/asgiref/actions/workflows/tests.yml/badge.svg
-    :target: https://github.com/django/asgiref/actions/workflows/tests.yml
-
-.. image:: https://img.shields.io/pypi/v/asgiref.svg
-    :target: https://pypi.python.org/pypi/asgiref
-
-ASGI is a standard for Python asynchronous web apps and servers to communicate
-with each other, and positioned as an asynchronous successor to WSGI. You can
-read more at https://asgi.readthedocs.io/en/latest/
-
-This package includes ASGI base libraries, such as:
-
-* Sync-to-async and async-to-sync function wrappers, ``asgiref.sync``
-* Server base classes, ``asgiref.server``
-* A WSGI-to-ASGI adapter, in ``asgiref.wsgi``
-
-
-Function wrappers
------------------
-
-These allow you to wrap or decorate async or sync functions to call them from
-the other style (so you can call async functions from a synchronous thread,
-or vice-versa).
-
-In particular:
-
-* AsyncToSync lets a synchronous subthread stop and wait while the async
-  function is called on the main thread's event loop, and then control is
-  returned to the thread when the async function is finished.
-
-* SyncToAsync lets async code call a synchronous function, which is run in
-  a threadpool and control returned to the async coroutine when the synchronous
-  function completes.
-
-The idea is to make it easier to call synchronous APIs from async code and
-asynchronous APIs from synchronous code so it's easier to transition code from
-one style to the other. In the case of Channels, we wrap the (synchronous)
-Django view system with SyncToAsync to allow it to run inside the (asynchronous)
-ASGI server.
-
-Note that exactly what threads things run in is very specific, and aimed to
-keep maximum compatibility with old synchronous code. See
-"Synchronous code & Threads" below for a full explanation. By default,
-``sync_to_async`` will run all synchronous code in the program in the same
-thread for safety reasons; you can disable this for more performance with
-``@sync_to_async(thread_sensitive=False)``, but make sure that your code does
-not rely on anything bound to threads (like database connections) when you do.
-
-
-Threadlocal replacement
------------------------
-
-This is a drop-in replacement for ``threading.local`` that works with both
-threads and asyncio Tasks. Even better, it will proxy values through from a
-task-local context to a thread-local context when you use ``sync_to_async``
-to run things in a threadpool, and vice-versa for ``async_to_sync``.
-
-If you instead want true thread- and task-safety, you can set
-``thread_critical`` on the Local object to ensure this instead.
-
-
-Server base classes
--------------------
-
-Includes a ``StatelessServer`` class which provides all the hard work of
-writing a stateless server (as in, does not handle direct incoming sockets
-but instead consumes external streams or sockets to work out what is happening).
-
-An example of such a server would be a chatbot server that connects out to
-a central chat server and provides a "connection scope" per user chatting to
-it. There's only one actual connection, but the server has to separate things
-into several scopes for easier writing of the code.
-
-You can see an example of this being used in `frequensgi <https://github.com/andrewgodwin/frequensgi>`_.
-
-
-WSGI-to-ASGI adapter
---------------------
-
-Allows you to wrap a WSGI application so it appears as a valid ASGI application.
-
-Simply wrap it around your WSGI application like so::
-
-    asgi_application = WsgiToAsgi(wsgi_application)
-
-The WSGI application will be run in a synchronous threadpool, and the wrapped
-ASGI application will be one that accepts ``http`` class messages.
-
-Please note that not all extended features of WSGI may be supported (such as
-file handles for incoming POST bodies).
-
-
-Dependencies
-------------
-
-``asgiref`` requires Python 3.9 or higher.
-
-
-Contributing
-------------
-
-Please refer to the
-`main Channels contributing docs <https://github.com/django/channels/blob/master/CONTRIBUTING.rst>`_.
-
-
-Testing
-'''''''
-
-To run tests, make sure you have installed the ``tests`` extra with the package::
-
-    cd asgiref/
-    pip install -e .[tests]
-    pytest
-
-
-Building the documentation
-''''''''''''''''''''''''''
-
-The documentation uses `Sphinx <http://www.sphinx-doc.org>`_::
-
-    cd asgiref/docs/
-    pip install sphinx
-
-To build the docs, you can use the default tools::
-
-    sphinx-build -b html . _build/html  # or `make html`, if you've got make set up
-    cd _build/html
-    python -m http.server
-
-...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload
-your documentation changes automatically::
-
-    pip install sphinx-autobuild
-    sphinx-autobuild . _build/html
-
-
-Releasing
-'''''''''
-
-To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``.
-
-Then, build and push the packages::
-
-    python -m build
-    twine upload dist/*
-    rm -r asgiref.egg-info dist
-
-
-Implementation Details
-----------------------
-
-Synchronous code & threads
-''''''''''''''''''''''''''
-
-The ``asgiref.sync`` module provides two wrappers that let you go between
-asynchronous and synchronous code at will, while taking care of the rough edges
-for you.
-
-Unfortunately, the rough edges are numerous, and the code has to work especially
-hard to keep things in the same thread as much as possible. Notably, the
-restrictions we are working with are:
-
-* All synchronous code called through ``SyncToAsync`` and marked with
-  ``thread_sensitive`` should run in the same thread as each other (and if the
-  outer layer of the program is synchronous, the main thread)
-
-* If a thread already has a running async loop, ``AsyncToSync`` can't run things
-  on that loop if it's blocked on synchronous code that is above you in the
-  call stack.
-
-The first compromise you get to might be that ``thread_sensitive`` code should
-just run in the same thread and not spawn in a sub-thread, fulfilling the first
-restriction, but that immediately runs you into the second restriction.
-
-The only real solution is to essentially have a variant of ThreadPoolExecutor
-that executes any ``thread_sensitive`` code on the outermost synchronous
-thread - either the main thread, or a single spawned subthread.
-
-This means you now have two basic states:
-
-* If the outermost layer of your program is synchronous, then all async code
-  run through ``AsyncToSync`` will run in a per-call event loop in arbitrary
-  sub-threads, while all ``thread_sensitive`` code will run in the main thread.
-
-* If the outermost layer of your program is asynchronous, then all async code
-  runs on the main thread's event loop, and all ``thread_sensitive`` synchronous
-  code will run in a single shared sub-thread.
-
-Crucially, this means that in both cases there is a thread which is a shared
-resource that all ``thread_sensitive`` code must run on, and there is a chance
-that this thread is currently blocked on its own ``AsyncToSync`` call. Thus,
-``AsyncToSync`` needs to act as an executor for thread code while it's blocking.
-
-The ``CurrentThreadExecutor`` class provides this functionality; rather than
-simply waiting on a Future, you can call its ``run_until_future`` method and
-it will run submitted code until that Future is done. This means that code
-inside the call can then run code on your thread.
-
-
-Maintenance and Security
-------------------------
-
-To report security issues, please contact security@djangoproject.com. For GPG
-signatures and more security process information, see
-https://docs.djangoproject.com/en/dev/internals/security/.
-
-To report bugs or request new features, please open a new GitHub issue.
-
-This repository is part of the Channels project. For the shepherd and maintenance team, please see the
-`main Channels readme <https://github.com/django/channels/blob/master/README.rst>`_.

.venv/lib/python3.12/site-packages/asgiref-3.11.1.dist-info/RECORD

@@ -1,27 +0,0 @@
-asgiref-3.11.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-asgiref-3.11.1.dist-info/METADATA,sha256=aLePcJP6N7HpneCbacTmO_4Gc4b0PRSo2fWPwsWLeYQ,9287
-asgiref-3.11.1.dist-info/RECORD,,
-asgiref-3.11.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-asgiref-3.11.1.dist-info/licenses/LICENSE,sha256=uEZBXRtRTpwd_xSiLeuQbXlLxUbKYSn5UKGM0JHipmk,1552
-asgiref-3.11.1.dist-info/top_level.txt,sha256=bokQjCzwwERhdBiPdvYEZa4cHxT4NCeAffQNUqJ8ssg,8
-asgiref/__init__.py,sha256=UuKR3QjWk9sJtn2huDFsPdSgtx1CgiEl2B4BUtVRd58,23
-asgiref/__pycache__/__init__.cpython-312.pyc,,
-asgiref/__pycache__/compatibility.cpython-312.pyc,,
-asgiref/__pycache__/current_thread_executor.cpython-312.pyc,,
-asgiref/__pycache__/local.cpython-312.pyc,,
-asgiref/__pycache__/server.cpython-312.pyc,,
-asgiref/__pycache__/sync.cpython-312.pyc,,
-asgiref/__pycache__/testing.cpython-312.pyc,,
-asgiref/__pycache__/timeout.cpython-312.pyc,,
-asgiref/__pycache__/typing.cpython-312.pyc,,
-asgiref/__pycache__/wsgi.cpython-312.pyc,,
-asgiref/compatibility.py,sha256=DhY1SOpOvOw0Y1lSEjCqg-znRUQKecG3LTaV48MZi68,1606
-asgiref/current_thread_executor.py,sha256=42CU1VODLTk-_PYise-cP1XgyAvI5Djc8f97owFzdrs,4157
-asgiref/local.py,sha256=ZZeWWIXptVU4GbNApMMWQ-skuglvodcQA5WpzJDMxh4,4912
-asgiref/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-asgiref/server.py,sha256=3A68169Nuh2sTY_2O5JzRd_opKObWvvrEFcrXssq3kA,6311
-asgiref/sync.py,sha256=KHjSkYRZKIJ1cmBvxcloGrcnhvAuEfXCWCZAoxN8grg,22929
-asgiref/testing.py,sha256=U5wcs_-ZYTO5SIGfl80EqRAGv_T8BHrAhvAKRuuztT4,4421
-asgiref/timeout.py,sha256=LtGL-xQpG8JHprdsEUCMErJ0kNWj4qwWZhEHJ3iKu4s,3627
-asgiref/typing.py,sha256=Zi72AZlOyF1C7N14LLZnpAdfUH4ljoBqFdQo_bBKMq0,6290
-asgiref/wsgi.py,sha256=OSxanm5Qf-VfrOkAx62mYW0mOnh8pwaTz1099HbJzM0,7941

.venv/lib/python3.12/site-packages/asgiref-3.11.1.dist-info/WHEEL

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

.venv/lib/python3.12/site-packages/asgiref-3.11.1.dist-info/licenses/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/asgiref-3.11.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-asgiref

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

@@ -1 +0,0 @@
-__version__ = "3.11.1"

.venv/lib/python3.12/site-packages/asgiref/compatibility.py

@@ -1,48 +0,0 @@
-import inspect
-
-from .sync import iscoroutinefunction
-
-
-def is_double_callable(application):
-    """
-    Tests to see if an application is a legacy-style (double-callable) application.
-    """
-    # Look for a hint on the object first
-    if getattr(application, "_asgi_single_callable", False):
-        return False
-    if getattr(application, "_asgi_double_callable", False):
-        return True
-    # Uninstanted classes are double-callable
-    if inspect.isclass(application):
-        return True
-    # Instanted classes depend on their __call__
-    if hasattr(application, "__call__"):
-        # We only check to see if its __call__ is a coroutine function -
-        # if it's not, it still might be a coroutine function itself.
-        if iscoroutinefunction(application.__call__):
-            return False
-    # Non-classes we just check directly
-    return not iscoroutinefunction(application)
-
-
-def double_to_single_callable(application):
-    """
-    Transforms a double-callable ASGI application into a single-callable one.
-    """
-
-    async def new_application(scope, receive, send):
-        instance = application(scope)
-        return await instance(receive, send)
-
-    return new_application
-
-
-def guarantee_single_callable(application):
-    """
-    Takes either a single- or double-callable application and always returns it
-    in single-callable style. Use this to add backwards compatibility for ASGI
-    2.0 applications to your server/test harness/etc.
-    """
-    if is_double_callable(application):
-        application = double_to_single_callable(application)
-    return application

.venv/lib/python3.12/site-packages/asgiref/current_thread_executor.py

@@ -1,123 +0,0 @@
-import sys
-import threading
-from collections import deque
-from concurrent.futures import Executor, Future
-from typing import Any, Callable, TypeVar
-
-if sys.version_info >= (3, 10):
-    from typing import ParamSpec
-else:
-    from typing_extensions import ParamSpec
-
-_T = TypeVar("_T")
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-class _WorkItem:
-    """
-    Represents an item needing to be run in the executor.
-    Copied from ThreadPoolExecutor (but it's private, so we're not going to rely on importing it)
-    """
-
-    def __init__(
-        self,
-        future: "Future[_R]",
-        fn: Callable[_P, _R],
-        *args: _P.args,
-        **kwargs: _P.kwargs,
-    ):
-        self.future = future
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-
-    def run(self) -> None:
-        __traceback_hide__ = True  # noqa: F841
-        if not self.future.set_running_or_notify_cancel():
-            return
-        try:
-            result = self.fn(*self.args, **self.kwargs)
-        except BaseException as exc:
-            self.future.set_exception(exc)
-            # Break a reference cycle with the exception 'exc'
-            self = None  # type: ignore[assignment]
-        else:
-            self.future.set_result(result)
-
-
-class CurrentThreadExecutor(Executor):
-    """
-    An Executor that actually runs code in the thread it is instantiated in.
-    Passed to other threads running async code, so they can run sync code in
-    the thread they came from.
-    """
-
-    def __init__(self, old_executor: "CurrentThreadExecutor | None") -> None:
-        self._work_thread = threading.current_thread()
-        self._work_ready = threading.Condition(threading.Lock())
-        self._work_items = deque[_WorkItem]()  # synchronized by _work_ready
-        self._broken = False  # synchronized by _work_ready
-        self._old_executor = old_executor
-
-    def run_until_future(self, future: "Future[Any]") -> None:
-        """
-        Runs the code in the work queue until a result is available from the future.
-        Should be run from the thread the executor is initialised in.
-        """
-        # Check we're in the right thread
-        if threading.current_thread() != self._work_thread:
-            raise RuntimeError(
-                "You cannot run CurrentThreadExecutor from a different thread"
-            )
-
-        def done(future: "Future[Any]") -> None:
-            with self._work_ready:
-                self._broken = True
-                self._work_ready.notify()
-
-        future.add_done_callback(done)
-        # Keep getting and running work items until the future we're waiting for
-        # is done and the queue is empty.
-        while True:
-            with self._work_ready:
-                while not self._work_items and not self._broken:
-                    self._work_ready.wait()
-                if not self._work_items:
-                    break
-                # Get a work item and run it
-                work_item = self._work_items.popleft()
-            work_item.run()
-            del work_item
-
-    def submit(
-        self,
-        fn: Callable[_P, _R],
-        /,
-        *args: _P.args,
-        **kwargs: _P.kwargs,
-    ) -> "Future[_R]":
-        # Check they're not submitting from the same thread
-        if threading.current_thread() == self._work_thread:
-            raise RuntimeError(
-                "You cannot submit onto CurrentThreadExecutor from its own thread"
-            )
-        f: "Future[_R]" = Future()
-        work_item = _WorkItem(f, fn, *args, **kwargs)
-
-        # Walk up the CurrentThreadExecutor stack to find the closest one still
-        # running
-        executor = self
-        while True:
-            with executor._work_ready:
-                if not executor._broken:
-                    # Add to work queue
-                    executor._work_items.append(work_item)
-                    executor._work_ready.notify()
-                    break
-            if executor._old_executor is None:
-                raise RuntimeError("CurrentThreadExecutor already quit or is broken")
-            executor = executor._old_executor
-
-        # Return the future
-        return f

.venv/lib/python3.12/site-packages/asgiref/local.py

@@ -1,131 +0,0 @@
-import asyncio
-import contextlib
-import contextvars
-import threading
-from typing import Any, Dict, Union
-
-
-class _CVar:
-    """Storage utility for Local."""
-
-    def __init__(self) -> None:
-        self._data: "contextvars.ContextVar[Dict[str, Any]]" = contextvars.ContextVar(
-            "asgiref.local"
-        )
-
-    def __getattr__(self, key):
-        storage_object = self._data.get({})
-        try:
-            return storage_object[key]
-        except KeyError:
-            raise AttributeError(f"{self!r} object has no attribute {key!r}")
-
-    def __setattr__(self, key: str, value: Any) -> None:
-        if key == "_data":
-            return super().__setattr__(key, value)
-
-        storage_object = self._data.get({}).copy()
-        storage_object[key] = value
-        self._data.set(storage_object)
-
-    def __delattr__(self, key: str) -> None:
-        storage_object = self._data.get({}).copy()
-        if key in storage_object:
-            del storage_object[key]
-            self._data.set(storage_object)
-        else:
-            raise AttributeError(f"{self!r} object has no attribute {key!r}")
-
-
-class Local:
-    """Local storage for async tasks.
-
-    This is a namespace object (similar to `threading.local`) where data is
-    also local to the current async task (if there is one).
-
-    In async threads, local means in the same sense as the `contextvars`
-    module - i.e. a value set in an async frame will be visible:
-
-    - to other async code `await`-ed from this frame.
-    - to tasks spawned using `asyncio` utilities (`create_task`, `wait_for`,
-      `gather` and probably others).
-    - to code scheduled in a sync thread using `sync_to_async`
-
-    In "sync" threads (a thread with no async event loop running), the
-    data is thread-local, but additionally shared with async code executed
-    via the `async_to_sync` utility, which schedules async code in a new thread
-    and copies context across to that thread.
-
-    If `thread_critical` is True, then the local will only be visible per-thread,
-    behaving exactly like `threading.local` if the thread is sync, and as
-    `contextvars` if the thread is async. This allows genuinely thread-sensitive
-    code (such as DB handles) to be kept stricly to their initial thread and
-    disable the sharing across `sync_to_async` and `async_to_sync` wrapped calls.
-
-    Unlike plain `contextvars` objects, this utility is threadsafe.
-    """
-
-    def __init__(self, thread_critical: bool = False) -> None:
-        self._thread_critical = thread_critical
-        self._thread_lock = threading.RLock()
-
-        self._storage: "Union[threading.local, _CVar]"
-
-        if thread_critical:
-            # Thread-local storage
-            self._storage = threading.local()
-        else:
-            # Contextvar storage
-            self._storage = _CVar()
-
-    @contextlib.contextmanager
-    def _lock_storage(self):
-        # Thread safe access to storage
-        if self._thread_critical:
-            is_async = True
-            try:
-                # this is a test for are we in a async or sync
-                # thread - will raise RuntimeError if there is
-                # no current loop
-                asyncio.get_running_loop()
-            except RuntimeError:
-                is_async = False
-            if not is_async:
-                # We are in a sync thread, the storage is
-                # just the plain thread local (i.e, "global within
-                # this thread" - it doesn't matter where you are
-                # in a call stack you see the same storage)
-                yield self._storage
-            else:
-                # We are in an async thread - storage is still
-                # local to this thread, but additionally should
-                # behave like a context var (is only visible with
-                # the same async call stack)
-
-                # Ensure context exists in the current thread
-                if not hasattr(self._storage, "cvar"):
-                    self._storage.cvar = _CVar()
-
-                # self._storage is a thread local, so the members
-                # can't be accessed in another thread (we don't
-                # need any locks)
-                yield self._storage.cvar
-        else:
-            # Lock for thread_critical=False as other threads
-            # can access the exact same storage object
-            with self._thread_lock:
-                yield self._storage
-
-    def __getattr__(self, key):
-        with self._lock_storage() as storage:
-            return getattr(storage, key)
-
-    def __setattr__(self, key, value):
-        if key in ("_local", "_storage", "_thread_critical", "_thread_lock"):
-            return super().__setattr__(key, value)
-        with self._lock_storage() as storage:
-            setattr(storage, key, value)
-
-    def __delattr__(self, key):
-        with self._lock_storage() as storage:
-            delattr(storage, key)

.venv/lib/python3.12/site-packages/asgiref/server.py

@@ -1,173 +0,0 @@
-import asyncio
-import logging
-import time
-import traceback
-
-from .compatibility import guarantee_single_callable
-
-logger = logging.getLogger(__name__)
-
-
-class StatelessServer:
-    """
-    Base server class that handles basic concepts like application instance
-    creation/pooling, exception handling, and similar, for stateless protocols
-    (i.e. ones without actual incoming connections to the process)
-
-    Your code should override the handle() method, doing whatever it needs to,
-    and calling get_or_create_application_instance with a unique `scope_id`
-    and `scope` for the scope it wants to get.
-
-    If an application instance is found with the same `scope_id`, you are
-    given its input queue, otherwise one is made for you with the scope provided
-    and you are given that fresh new input queue. Either way, you should do
-    something like:
-
-    input_queue = self.get_or_create_application_instance(
-        "user-123456",
-        {"type": "testprotocol", "user_id": "123456", "username": "andrew"},
-    )
-    input_queue.put_nowait(message)
-
-    If you try and create an application instance and there are already
-    `max_application` instances, the oldest/least recently used one will be
-    reclaimed and shut down to make space.
-
-    Application coroutines that error will be found periodically (every 100ms
-    by default) and have their exceptions printed to the console. Override
-    application_exception() if you want to do more when this happens.
-
-    If you override run(), make sure you handle things like launching the
-    application checker.
-    """
-
-    application_checker_interval = 0.1
-
-    def __init__(self, application, max_applications=1000):
-        # Parameters
-        self.application = application
-        self.max_applications = max_applications
-        # Initialisation
-        self.application_instances = {}
-
-    ### Mainloop and handling
-
-    def run(self):
-        """
-        Runs the asyncio event loop with our handler loop.
-        """
-        event_loop = asyncio.get_event_loop()
-        try:
-            event_loop.run_until_complete(self.arun())
-        except KeyboardInterrupt:
-            logger.info("Exiting due to Ctrl-C/interrupt")
-
-    async def arun(self):
-        """
-        Runs the asyncio event loop with our handler loop.
-        """
-
-        class Done(Exception):
-            pass
-
-        async def handle():
-            await self.handle()
-            raise Done
-
-        try:
-            await asyncio.gather(self.application_checker(), handle())
-        except Done:
-            pass
-
-    async def handle(self):
-        raise NotImplementedError("You must implement handle()")
-
-    async def application_send(self, scope, message):
-        """
-        Receives outbound sends from applications and handles them.
-        """
-        raise NotImplementedError("You must implement application_send()")
-
-    ### Application instance management
-
-    def get_or_create_application_instance(self, scope_id, scope):
-        """
-        Creates an application instance and returns its queue.
-        """
-        if scope_id in self.application_instances:
-            self.application_instances[scope_id]["last_used"] = time.time()
-            return self.application_instances[scope_id]["input_queue"]
-        # See if we need to delete an old one
-        while len(self.application_instances) > self.max_applications:
-            self.delete_oldest_application_instance()
-        # Make an instance of the application
-        input_queue = asyncio.Queue()
-        application_instance = guarantee_single_callable(self.application)
-        # Run it, and stash the future for later checking
-        future = asyncio.ensure_future(
-            application_instance(
-                scope=scope,
-                receive=input_queue.get,
-                send=lambda message: self.application_send(scope, message),
-            ),
-        )
-        self.application_instances[scope_id] = {
-            "input_queue": input_queue,
-            "future": future,
-            "scope": scope,
-            "last_used": time.time(),
-        }
-        return input_queue
-
-    def delete_oldest_application_instance(self):
-        """
-        Finds and deletes the oldest application instance
-        """
-        oldest_time = min(
-            details["last_used"] for details in self.application_instances.values()
-        )
-        for scope_id, details in self.application_instances.items():
-            if details["last_used"] == oldest_time:
-                self.delete_application_instance(scope_id)
-                # Return to make sure we only delete one in case two have
-                # the same oldest time
-                return
-
-    def delete_application_instance(self, scope_id):
-        """
-        Removes an application instance (makes sure its task is stopped,
-        then removes it from the current set)
-        """
-        details = self.application_instances[scope_id]
-        del self.application_instances[scope_id]
-        if not details["future"].done():
-            details["future"].cancel()
-
-    async def application_checker(self):
-        """
-        Goes through the set of current application instance Futures and cleans up
-        any that are done/prints exceptions for any that errored.
-        """
-        while True:
-            await asyncio.sleep(self.application_checker_interval)
-            for scope_id, details in list(self.application_instances.items()):
-                if details["future"].done():
-                    exception = details["future"].exception()
-                    if exception:
-                        await self.application_exception(exception, details)
-                    try:
-                        del self.application_instances[scope_id]
-                    except KeyError:
-                        # Exception handling might have already got here before us. That's fine.
-                        pass
-
-    async def application_exception(self, exception, application_details):
-        """
-        Called whenever an application coroutine has an exception.
-        """
-        logging.error(
-            "Exception inside application: %s\n%s%s",
-            exception,
-            "".join(traceback.format_tb(exception.__traceback__)),
-            f"  {exception}",
-        )

.venv/lib/python3.12/site-packages/asgiref/sync.py

@@ -1,657 +0,0 @@
-import asyncio
-import asyncio.coroutines
-import contextvars
-import functools
-import inspect
-import os
-import sys
-import threading
-import warnings
-import weakref
-from concurrent.futures import Future, ThreadPoolExecutor
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    Coroutine,
-    Dict,
-    Generic,
-    List,
-    Optional,
-    TypeVar,
-    Union,
-    overload,
-)
-
-from .current_thread_executor import CurrentThreadExecutor
-from .local import Local
-
-if sys.version_info >= (3, 10):
-    from typing import ParamSpec
-else:
-    from typing_extensions import ParamSpec
-
-if TYPE_CHECKING:
-    # This is not available to import at runtime
-    from _typeshed import OptExcInfo
-
-_F = TypeVar("_F", bound=Callable[..., Any])
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
-def _restore_context(context: contextvars.Context) -> None:
-    # Check for changes in contextvars, and set them to the current
-    # context for downstream consumers
-    for cvar in context:
-        cvalue = context.get(cvar)
-        try:
-            if cvar.get() != cvalue:
-                cvar.set(cvalue)
-        except LookupError:
-            cvar.set(cvalue)
-
-
-# Python 3.12 deprecates asyncio.iscoroutinefunction() as an alias for
-# inspect.iscoroutinefunction(), whilst also removing the _is_coroutine marker.
-# The latter is replaced with the inspect.markcoroutinefunction decorator.
-# Until 3.12 is the minimum supported Python version, provide a shim.
-
-if hasattr(inspect, "markcoroutinefunction"):
-    iscoroutinefunction = inspect.iscoroutinefunction
-    markcoroutinefunction: Callable[[_F], _F] = inspect.markcoroutinefunction
-else:
-    iscoroutinefunction = asyncio.iscoroutinefunction  # type: ignore[assignment]
-
-    def markcoroutinefunction(func: _F) -> _F:
-        func._is_coroutine = asyncio.coroutines._is_coroutine  # type: ignore
-        return func
-
-
-class AsyncSingleThreadContext:
-    """Context manager to run async code inside the same thread.
-
-    Normally, AsyncToSync functions run either inside a separate ThreadPoolExecutor or
-    the main event loop if it exists. This context manager ensures that all AsyncToSync
-    functions execute within the same thread.
-
-    This context manager is re-entrant, so only the outer-most call to
-    AsyncSingleThreadContext will set the context.
-
-    Usage:
-
-    >>> import asyncio
-    >>> with AsyncSingleThreadContext():
-    ...     async_to_sync(asyncio.sleep(1))()
-    """
-
-    def __init__(self):
-        self.token = None
-
-    def __enter__(self):
-        try:
-            AsyncToSync.async_single_thread_context.get()
-        except LookupError:
-            self.token = AsyncToSync.async_single_thread_context.set(self)
-
-        return self
-
-    def __exit__(self, exc, value, tb):
-        if not self.token:
-            return
-
-        executor = AsyncToSync.context_to_thread_executor.pop(self, None)
-        if executor:
-            executor.shutdown()
-
-        AsyncToSync.async_single_thread_context.reset(self.token)
-
-
-class ThreadSensitiveContext:
-    """Async context manager to manage context for thread sensitive mode
-
-    This context manager controls which thread pool executor is used when in
-    thread sensitive mode. By default, a single thread pool executor is shared
-    within a process.
-
-    The ThreadSensitiveContext() context manager may be used to specify a
-    thread pool per context.
-
-    This context manager is re-entrant, so only the outer-most call to
-    ThreadSensitiveContext will set the context.
-
-    Usage:
-
-    >>> import time
-    >>> async with ThreadSensitiveContext():
-    ...     await sync_to_async(time.sleep, 1)()
-    """
-
-    def __init__(self):
-        self.token = None
-
-    async def __aenter__(self):
-        try:
-            SyncToAsync.thread_sensitive_context.get()
-        except LookupError:
-            self.token = SyncToAsync.thread_sensitive_context.set(self)
-
-        return self
-
-    async def __aexit__(self, exc, value, tb):
-        if not self.token:
-            return
-
-        executor = SyncToAsync.context_to_thread_executor.pop(self, None)
-        if executor:
-            executor.shutdown()
-        SyncToAsync.thread_sensitive_context.reset(self.token)
-
-
-class AsyncToSync(Generic[_P, _R]):
-    """
-    Utility class which turns an awaitable that only works on the thread with
-    the event loop into a synchronous callable that works in a subthread.
-
-    If the call stack contains an async loop, the code runs there.
-    Otherwise, the code runs in a new loop in a new thread.
-
-    Either way, this thread then pauses and waits to run any thread_sensitive
-    code called from further down the call stack using SyncToAsync, before
-    finally exiting once the async task returns.
-    """
-
-    # Keeps a reference to the CurrentThreadExecutor in local context, so that
-    # any sync_to_async inside the wrapped code can find it.
-    executors: "Local" = Local()
-
-    # When we can't find a CurrentThreadExecutor from the context, such as
-    # inside create_task, we'll look it up here from the running event loop.
-    loop_thread_executors: "Dict[asyncio.AbstractEventLoop, CurrentThreadExecutor]" = {}
-
-    async_single_thread_context: "contextvars.ContextVar[AsyncSingleThreadContext]" = (
-        contextvars.ContextVar("async_single_thread_context")
-    )
-
-    context_to_thread_executor: "weakref.WeakKeyDictionary[AsyncSingleThreadContext, ThreadPoolExecutor]" = (
-        weakref.WeakKeyDictionary()
-    )
-
-    def __init__(
-        self,
-        awaitable: Union[
-            Callable[_P, Coroutine[Any, Any, _R]],
-            Callable[_P, Awaitable[_R]],
-        ],
-        force_new_loop: bool = False,
-    ):
-        if not callable(awaitable) or (
-            not iscoroutinefunction(awaitable)
-            and not iscoroutinefunction(getattr(awaitable, "__call__", awaitable))
-        ):
-            # Python does not have very reliable detection of async functions
-            # (lots of false negatives) so this is just a warning.
-            warnings.warn(
-                "async_to_sync was passed a non-async-marked callable", stacklevel=2
-            )
-        self.awaitable = awaitable
-        try:
-            self.__self__ = self.awaitable.__self__  # type: ignore[union-attr]
-        except AttributeError:
-            pass
-        self.force_new_loop = force_new_loop
-        self.main_event_loop = None
-        try:
-            self.main_event_loop = asyncio.get_running_loop()
-        except RuntimeError:
-            # There's no event loop in this thread.
-            pass
-
-    def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R:
-        __traceback_hide__ = True  # noqa: F841
-
-        if not self.force_new_loop and not self.main_event_loop:
-            # There's no event loop in this thread. Look for the threadlocal if
-            # we're inside SyncToAsync
-            main_event_loop_pid = getattr(
-                SyncToAsync.threadlocal, "main_event_loop_pid", None
-            )
-            # We make sure the parent loop is from the same process - if
-            # they've forked, this is not going to be valid any more (#194)
-            if main_event_loop_pid and main_event_loop_pid == os.getpid():
-                self.main_event_loop = getattr(
-                    SyncToAsync.threadlocal, "main_event_loop", None
-                )
-
-        # You can't call AsyncToSync from a thread with a running event loop
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            pass
-        else:
-            raise RuntimeError(
-                "You cannot use AsyncToSync in the same thread as an async event loop - "
-                "just await the async function directly."
-            )
-
-        # Make a future for the return information
-        call_result: "Future[_R]" = Future()
-
-        # Make a CurrentThreadExecutor we'll use to idle in this thread - we
-        # need one for every sync frame, even if there's one above us in the
-        # same thread.
-        old_executor = getattr(self.executors, "current", None)
-        current_executor = CurrentThreadExecutor(old_executor)
-        self.executors.current = current_executor
-
-        # Wrapping context in list so it can be reassigned from within
-        # `main_wrap`.
-        context = [contextvars.copy_context()]
-
-        # Get task context so that parent task knows which task to propagate
-        # an asyncio.CancelledError to.
-        task_context = getattr(SyncToAsync.threadlocal, "task_context", None)
-
-        # Use call_soon_threadsafe to schedule a synchronous callback on the
-        # main event loop's thread if it's there, otherwise make a new loop
-        # in this thread.
-        try:
-            awaitable = self.main_wrap(
-                call_result,
-                sys.exc_info(),
-                task_context,
-                context,
-                # prepare an awaitable which can be passed as is to self.main_wrap,
-                # so that `args` and `kwargs` don't need to be
-                # destructured when passed to self.main_wrap
-                # (which is required by `ParamSpec`)
-                # as that may cause overlapping arguments
-                self.awaitable(*args, **kwargs),
-            )
-
-            async def new_loop_wrap() -> None:
-                loop = asyncio.get_running_loop()
-                self.loop_thread_executors[loop] = current_executor
-                try:
-                    await awaitable
-                finally:
-                    del self.loop_thread_executors[loop]
-
-            if self.main_event_loop is not None:
-                try:
-                    self.main_event_loop.call_soon_threadsafe(
-                        self.main_event_loop.create_task, awaitable
-                    )
-                except RuntimeError:
-                    running_in_main_event_loop = False
-                else:
-                    running_in_main_event_loop = True
-                    # Run the CurrentThreadExecutor until the future is done.
-                    current_executor.run_until_future(call_result)
-            else:
-                running_in_main_event_loop = False
-
-            if not running_in_main_event_loop:
-                loop_executor = None
-
-                if self.async_single_thread_context.get(None):
-                    single_thread_context = self.async_single_thread_context.get()
-
-                    if single_thread_context in self.context_to_thread_executor:
-                        loop_executor = self.context_to_thread_executor[
-                            single_thread_context
-                        ]
-                    else:
-                        loop_executor = ThreadPoolExecutor(max_workers=1)
-                        self.context_to_thread_executor[
-                            single_thread_context
-                        ] = loop_executor
-                else:
-                    # Make our own event loop - in a new thread - and run inside that.
-                    loop_executor = ThreadPoolExecutor(max_workers=1)
-
-                loop_future = loop_executor.submit(asyncio.run, new_loop_wrap())
-                # Run the CurrentThreadExecutor until the future is done.
-                current_executor.run_until_future(loop_future)
-                # Wait for future and/or allow for exception propagation
-                loop_future.result()
-        finally:
-            _restore_context(context[0])
-            # Restore old current thread executor state
-            self.executors.current = old_executor
-
-        # Wait for results from the future.
-        return call_result.result()
-
-    def __get__(self, parent: Any, objtype: Any) -> Callable[_P, _R]:
-        """
-        Include self for methods
-        """
-        func = functools.partial(self.__call__, parent)
-        return functools.update_wrapper(func, self.awaitable)
-
-    async def main_wrap(
-        self,
-        call_result: "Future[_R]",
-        exc_info: "OptExcInfo",
-        task_context: "Optional[List[asyncio.Task[Any]]]",
-        context: List[contextvars.Context],
-        awaitable: Union[Coroutine[Any, Any, _R], Awaitable[_R]],
-    ) -> None:
-        """
-        Wraps the awaitable with something that puts the result into the
-        result/exception future.
-        """
-
-        __traceback_hide__ = True  # noqa: F841
-
-        if context is not None:
-            _restore_context(context[0])
-
-        current_task = asyncio.current_task()
-        if current_task is not None and task_context is not None:
-            task_context.append(current_task)
-
-        try:
-            # If we have an exception, run the function inside the except block
-            # after raising it so exc_info is correctly populated.
-            if exc_info[1]:
-                try:
-                    raise exc_info[1]
-                except BaseException:
-                    result = await awaitable
-            else:
-                result = await awaitable
-        except BaseException as e:
-            call_result.set_exception(e)
-        else:
-            call_result.set_result(result)
-        finally:
-            if current_task is not None and task_context is not None:
-                task_context.remove(current_task)
-            context[0] = contextvars.copy_context()
-
-
-class SyncToAsync(Generic[_P, _R]):
-    """
-    Utility class which turns a synchronous callable into an awaitable that
-    runs in a threadpool. It also sets a threadlocal inside the thread so
-    calls to AsyncToSync can escape it.
-
-    If thread_sensitive is passed, the code will run in the same thread as any
-    outer code. This is needed for underlying Python code that is not
-    threadsafe (for example, code which handles SQLite database connections).
-
-    If the outermost program is async (i.e. SyncToAsync is outermost), then
-    this will be a dedicated single sub-thread that all sync code runs in,
-    one after the other. If the outermost program is sync (i.e. AsyncToSync is
-    outermost), this will just be the main thread. This is achieved by idling
-    with a CurrentThreadExecutor while AsyncToSync is blocking its sync parent,
-    rather than just blocking.
-
-    If executor is passed in, that will be used instead of the loop's default executor.
-    In order to pass in an executor, thread_sensitive must be set to False, otherwise
-    a TypeError will be raised.
-    """
-
-    # Storage for main event loop references
-    threadlocal = threading.local()
-
-    # Single-thread executor for thread-sensitive code
-    single_thread_executor = ThreadPoolExecutor(max_workers=1)
-
-    # Maintain a contextvar for the current execution context. Optionally used
-    # for thread sensitive mode.
-    thread_sensitive_context: "contextvars.ContextVar[ThreadSensitiveContext]" = (
-        contextvars.ContextVar("thread_sensitive_context")
-    )
-
-    # Contextvar that is used to detect if the single thread executor
-    # would be awaited on while already being used in the same context
-    deadlock_context: "contextvars.ContextVar[bool]" = contextvars.ContextVar(
-        "deadlock_context"
-    )
-
-    # Maintaining a weak reference to the context ensures that thread pools are
-    # erased once the context goes out of scope. This terminates the thread pool.
-    context_to_thread_executor: "weakref.WeakKeyDictionary[ThreadSensitiveContext, ThreadPoolExecutor]" = (
-        weakref.WeakKeyDictionary()
-    )
-
-    def __init__(
-        self,
-        func: Callable[_P, _R],
-        thread_sensitive: bool = True,
-        executor: Optional["ThreadPoolExecutor"] = None,
-        context: Optional[contextvars.Context] = None,
-    ) -> None:
-        if (
-            not callable(func)
-            or iscoroutinefunction(func)
-            or iscoroutinefunction(getattr(func, "__call__", func))
-        ):
-            raise TypeError("sync_to_async can only be applied to sync functions.")
-
-        functools.update_wrapper(self, func)
-        self.func = func
-        self.context = context
-
-        self._thread_sensitive = thread_sensitive
-        markcoroutinefunction(self)
-        if thread_sensitive and executor is not None:
-            raise TypeError("executor must not be set when thread_sensitive is True")
-        self._executor = executor
-        try:
-            self.__self__ = func.__self__  # type: ignore
-        except AttributeError:
-            pass
-
-    async def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R:
-        __traceback_hide__ = True  # noqa: F841
-        loop = asyncio.get_running_loop()
-
-        # Work out what thread to run the code in
-        if self._thread_sensitive:
-            current_thread_executor = getattr(AsyncToSync.executors, "current", None)
-            if current_thread_executor:
-                # If we have a parent sync thread above somewhere, use that
-                executor = current_thread_executor
-            elif self.thread_sensitive_context.get(None):
-                # If we have a way of retrieving the current context, attempt
-                # to use a per-context thread pool executor
-                thread_sensitive_context = self.thread_sensitive_context.get()
-
-                if thread_sensitive_context in self.context_to_thread_executor:
-                    # Re-use thread executor in current context
-                    executor = self.context_to_thread_executor[thread_sensitive_context]
-                else:
-                    # Create new thread executor in current context
-                    executor = ThreadPoolExecutor(max_workers=1)
-                    self.context_to_thread_executor[thread_sensitive_context] = executor
-            elif loop in AsyncToSync.loop_thread_executors:
-                # Re-use thread executor for running loop
-                executor = AsyncToSync.loop_thread_executors[loop]
-            elif self.deadlock_context.get(False):
-                raise RuntimeError(
-                    "Single thread executor already being used, would deadlock"
-                )
-            else:
-                # Otherwise, we run it in a fixed single thread
-                executor = self.single_thread_executor
-                self.deadlock_context.set(True)
-        else:
-            # Use the passed in executor, or the loop's default if it is None
-            executor = self._executor
-
-        context = contextvars.copy_context() if self.context is None else self.context
-        child = functools.partial(self.func, *args, **kwargs)
-        func = context.run
-        task_context: List[asyncio.Task[Any]] = []
-
-        # Run the code in the right thread
-        exec_coro = loop.run_in_executor(
-            executor,
-            functools.partial(
-                self.thread_handler,
-                loop,
-                sys.exc_info(),
-                task_context,
-                func,
-                child,
-            ),
-        )
-        ret: _R
-        try:
-            ret = await asyncio.shield(exec_coro)
-        except asyncio.CancelledError:
-            cancel_parent = True
-            try:
-                task = task_context[0]
-                task.cancel()
-                try:
-                    await task
-                    cancel_parent = False
-                except asyncio.CancelledError:
-                    pass
-            except IndexError:
-                pass
-            if exec_coro.done():
-                raise
-            if cancel_parent:
-                exec_coro.cancel()
-            ret = await exec_coro
-        finally:
-            if self.context is None:
-                _restore_context(context)
-            self.deadlock_context.set(False)
-
-        return ret
-
-    def __get__(
-        self, parent: Any, objtype: Any
-    ) -> Callable[_P, Coroutine[Any, Any, _R]]:
-        """
-        Include self for methods
-        """
-        func = functools.partial(self.__call__, parent)
-        return functools.update_wrapper(func, self.func)
-
-    def thread_handler(self, loop, exc_info, task_context, func, *args, **kwargs):
-        """
-        Wraps the sync application with exception handling.
-        """
-
-        __traceback_hide__ = True  # noqa: F841
-
-        # Set the threadlocal for AsyncToSync
-        self.threadlocal.main_event_loop = loop
-        self.threadlocal.main_event_loop_pid = os.getpid()
-        self.threadlocal.task_context = task_context
-
-        # Run the function
-        # If we have an exception, run the function inside the except block
-        # after raising it so exc_info is correctly populated.
-        if exc_info[1]:
-            try:
-                raise exc_info[1]
-            except BaseException:
-                return func(*args, **kwargs)
-        else:
-            return func(*args, **kwargs)
-
-
-@overload
-def async_to_sync(
-    *,
-    force_new_loop: bool = False,
-) -> Callable[
-    [Union[Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]]]],
-    Callable[_P, _R],
-]:
-    ...
-
-
-@overload
-def async_to_sync(
-    awaitable: Union[
-        Callable[_P, Coroutine[Any, Any, _R]],
-        Callable[_P, Awaitable[_R]],
-    ],
-    *,
-    force_new_loop: bool = False,
-) -> Callable[_P, _R]:
-    ...
-
-
-def async_to_sync(
-    awaitable: Optional[
-        Union[
-            Callable[_P, Coroutine[Any, Any, _R]],
-            Callable[_P, Awaitable[_R]],
-        ]
-    ] = None,
-    *,
-    force_new_loop: bool = False,
-) -> Union[
-    Callable[
-        [Union[Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]]]],
-        Callable[_P, _R],
-    ],
-    Callable[_P, _R],
-]:
-    if awaitable is None:
-        return lambda f: AsyncToSync(
-            f,
-            force_new_loop=force_new_loop,
-        )
-    return AsyncToSync(
-        awaitable,
-        force_new_loop=force_new_loop,
-    )
-
-
-@overload
-def sync_to_async(
-    *,
-    thread_sensitive: bool = True,
-    executor: Optional["ThreadPoolExecutor"] = None,
-    context: Optional[contextvars.Context] = None,
-) -> Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]]:
-    ...
-
-
-@overload
-def sync_to_async(
-    func: Callable[_P, _R],
-    *,
-    thread_sensitive: bool = True,
-    executor: Optional["ThreadPoolExecutor"] = None,
-    context: Optional[contextvars.Context] = None,
-) -> Callable[_P, Coroutine[Any, Any, _R]]:
-    ...
-
-
-def sync_to_async(
-    func: Optional[Callable[_P, _R]] = None,
-    *,
-    thread_sensitive: bool = True,
-    executor: Optional["ThreadPoolExecutor"] = None,
-    context: Optional[contextvars.Context] = None,
-) -> Union[
-    Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]],
-    Callable[_P, Coroutine[Any, Any, _R]],
-]:
-    if func is None:
-        return lambda f: SyncToAsync(
-            f,
-            thread_sensitive=thread_sensitive,
-            executor=executor,
-            context=context,
-        )
-    return SyncToAsync(
-        func,
-        thread_sensitive=thread_sensitive,
-        executor=executor,
-        context=context,
-    )

.venv/lib/python3.12/site-packages/asgiref/testing.py

@@ -1,137 +0,0 @@
-import asyncio
-import contextvars
-import time
-
-from .compatibility import guarantee_single_callable
-from .timeout import timeout as async_timeout
-
-
-class ApplicationCommunicator:
-    """
-    Runs an ASGI application in a test mode, allowing sending of
-    messages to it and retrieval of messages it sends.
-    """
-
-    def __init__(self, application, scope):
-        self._future = None
-        self.application = guarantee_single_callable(application)
-        self.scope = scope
-        self._input_queue = None
-        self._output_queue = None
-
-    # For Python 3.9 we need to lazily bind the queues, on 3.10+ they bind the
-    # event loop lazily.
-    @property
-    def input_queue(self):
-        if self._input_queue is None:
-            self._input_queue = asyncio.Queue()
-        return self._input_queue
-
-    @property
-    def output_queue(self):
-        if self._output_queue is None:
-            self._output_queue = asyncio.Queue()
-        return self._output_queue
-
-    @property
-    def future(self):
-        if self._future is None:
-            # Clear context - this ensures that context vars set in the testing scope
-            # are not "leaked" into the application which would normally begin with
-            # an empty context. In Python >= 3.11 this could also be written as:
-            # asyncio.create_task(..., context=contextvars.Context())
-            self._future = contextvars.Context().run(
-                asyncio.create_task,
-                self.application(
-                    self.scope, self.input_queue.get, self.output_queue.put
-                ),
-            )
-        return self._future
-
-    async def wait(self, timeout=1):
-        """
-        Waits for the application to stop itself and returns any exceptions.
-        """
-        try:
-            async with async_timeout(timeout):
-                try:
-                    await self.future
-                    self.future.result()
-                except asyncio.CancelledError:
-                    pass
-        finally:
-            if not self.future.done():
-                self.future.cancel()
-                try:
-                    await self.future
-                except asyncio.CancelledError:
-                    pass
-
-    def stop(self, exceptions=True):
-        future = self._future
-        if future is None:
-            return
-
-        if not future.done():
-            future.cancel()
-        elif exceptions:
-            # Give a chance to raise any exceptions
-            future.result()
-
-    def __del__(self):
-        # Clean up on deletion
-        try:
-            self.stop(exceptions=False)
-        except RuntimeError:
-            # Event loop already stopped
-            pass
-
-    async def send_input(self, message):
-        """
-        Sends a single message to the application
-        """
-        # Make sure there's not an exception to raise from the task
-        if self.future.done():
-            self.future.result()
-
-        # Give it the message
-        await self.input_queue.put(message)
-
-    async def receive_output(self, timeout=1):
-        """
-        Receives a single message from the application, with optional timeout.
-        """
-        # Make sure there's not an exception to raise from the task
-        if self.future.done():
-            self.future.result()
-        # Wait and receive the message
-        try:
-            async with async_timeout(timeout):
-                return await self.output_queue.get()
-        except asyncio.TimeoutError as e:
-            # See if we have another error to raise inside
-            if self.future.done():
-                self.future.result()
-            else:
-                self.future.cancel()
-                try:
-                    await self.future
-                except asyncio.CancelledError:
-                    pass
-            raise e
-
-    async def receive_nothing(self, timeout=0.1, interval=0.01):
-        """
-        Checks that there is no message to receive in the given time.
-        """
-        # Make sure there's not an exception to raise from the task
-        if self.future.done():
-            self.future.result()
-
-        # `interval` has precedence over `timeout`
-        start = time.monotonic()
-        while time.monotonic() - start < timeout:
-            if not self.output_queue.empty():
-                return False
-            await asyncio.sleep(interval)
-        return self.output_queue.empty()

.venv/lib/python3.12/site-packages/asgiref/timeout.py

@@ -1,118 +0,0 @@
-# This code is originally sourced from the aio-libs project "async_timeout",
-# under the Apache 2.0 license. You may see the original project at
-# https://github.com/aio-libs/async-timeout
-
-# It is vendored here to reduce chain-dependencies on this library, and
-# modified slightly to remove some features we don't use.
-
-
-import asyncio
-import warnings
-from types import TracebackType
-from typing import Any  # noqa
-from typing import Optional, Type
-
-
-class timeout:
-    """timeout context manager.
-
-    Useful in cases when you want to apply timeout logic around block
-    of code or in cases when asyncio.wait_for is not suitable. For example:
-
-    >>> with timeout(0.001):
-    ...     async with aiohttp.get('https://github.com') as r:
-    ...         await r.text()
-
-
-    timeout - value in seconds or None to disable timeout logic
-    loop - asyncio compatible event loop
-    """
-
-    def __init__(
-        self,
-        timeout: Optional[float],
-        *,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> None:
-        self._timeout = timeout
-        if loop is None:
-            loop = asyncio.get_running_loop()
-        else:
-            warnings.warn(
-                """The loop argument to timeout() is deprecated.""", DeprecationWarning
-            )
-        self._loop = loop
-        self._task = None  # type: Optional[asyncio.Task[Any]]
-        self._cancelled = False
-        self._cancel_handler = None  # type: Optional[asyncio.Handle]
-        self._cancel_at = None  # type: Optional[float]
-
-    def __enter__(self) -> "timeout":
-        return self._do_enter()
-
-    def __exit__(
-        self,
-        exc_type: Type[BaseException],
-        exc_val: BaseException,
-        exc_tb: TracebackType,
-    ) -> Optional[bool]:
-        self._do_exit(exc_type)
-        return None
-
-    async def __aenter__(self) -> "timeout":
-        return self._do_enter()
-
-    async def __aexit__(
-        self,
-        exc_type: Type[BaseException],
-        exc_val: BaseException,
-        exc_tb: TracebackType,
-    ) -> None:
-        self._do_exit(exc_type)
-
-    @property
-    def expired(self) -> bool:
-        return self._cancelled
-
-    @property
-    def remaining(self) -> Optional[float]:
-        if self._cancel_at is not None:
-            return max(self._cancel_at - self._loop.time(), 0.0)
-        else:
-            return None
-
-    def _do_enter(self) -> "timeout":
-        # Support Tornado 5- without timeout
-        # Details: https://github.com/python/asyncio/issues/392
-        if self._timeout is None:
-            return self
-
-        self._task = asyncio.current_task(self._loop)
-        if self._task is None:
-            raise RuntimeError(
-                "Timeout context manager should be used " "inside a task"
-            )
-
-        if self._timeout <= 0:
-            self._loop.call_soon(self._cancel_task)
-            return self
-
-        self._cancel_at = self._loop.time() + self._timeout
-        self._cancel_handler = self._loop.call_at(self._cancel_at, self._cancel_task)
-        return self
-
-    def _do_exit(self, exc_type: Type[BaseException]) -> None:
-        if exc_type is asyncio.CancelledError and self._cancelled:
-            self._cancel_handler = None
-            self._task = None
-            raise asyncio.TimeoutError
-        if self._timeout is not None and self._cancel_handler is not None:
-            self._cancel_handler.cancel()
-            self._cancel_handler = None
-        self._task = None
-        return None
-
-    def _cancel_task(self) -> None:
-        if self._task is not None:
-            self._task.cancel()
-            self._cancelled = True

.venv/lib/python3.12/site-packages/asgiref/typing.py

@@ -1,279 +0,0 @@
-import sys
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Dict,
-    Iterable,
-    Literal,
-    Optional,
-    Protocol,
-    Tuple,
-    Type,
-    TypedDict,
-    Union,
-)
-
-if sys.version_info >= (3, 11):
-    from typing import NotRequired
-else:
-    from typing_extensions import NotRequired
-
-__all__ = (
-    "ASGIVersions",
-    "HTTPScope",
-    "WebSocketScope",
-    "LifespanScope",
-    "WWWScope",
-    "Scope",
-    "HTTPRequestEvent",
-    "HTTPResponseStartEvent",
-    "HTTPResponseBodyEvent",
-    "HTTPResponseTrailersEvent",
-    "HTTPResponsePathsendEvent",
-    "HTTPServerPushEvent",
-    "HTTPDisconnectEvent",
-    "WebSocketConnectEvent",
-    "WebSocketAcceptEvent",
-    "WebSocketReceiveEvent",
-    "WebSocketSendEvent",
-    "WebSocketResponseStartEvent",
-    "WebSocketResponseBodyEvent",
-    "WebSocketDisconnectEvent",
-    "WebSocketCloseEvent",
-    "LifespanStartupEvent",
-    "LifespanShutdownEvent",
-    "LifespanStartupCompleteEvent",
-    "LifespanStartupFailedEvent",
-    "LifespanShutdownCompleteEvent",
-    "LifespanShutdownFailedEvent",
-    "ASGIReceiveEvent",
-    "ASGISendEvent",
-    "ASGIReceiveCallable",
-    "ASGISendCallable",
-    "ASGI2Protocol",
-    "ASGI2Application",
-    "ASGI3Application",
-    "ASGIApplication",
-)
-
-
-class ASGIVersions(TypedDict):
-    spec_version: str
-    version: Union[Literal["2.0"], Literal["3.0"]]
-
-
-class HTTPScope(TypedDict):
-    type: Literal["http"]
-    asgi: ASGIVersions
-    http_version: str
-    method: str
-    scheme: str
-    path: str
-    raw_path: bytes
-    query_string: bytes
-    root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: Optional[Tuple[str, int]]
-    server: Optional[Tuple[str, Optional[int]]]
-    state: NotRequired[Dict[str, Any]]
-    extensions: Optional[Dict[str, Dict[object, object]]]
-
-
-class WebSocketScope(TypedDict):
-    type: Literal["websocket"]
-    asgi: ASGIVersions
-    http_version: str
-    scheme: str
-    path: str
-    raw_path: bytes
-    query_string: bytes
-    root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: Optional[Tuple[str, int]]
-    server: Optional[Tuple[str, Optional[int]]]
-    subprotocols: Iterable[str]
-    state: NotRequired[Dict[str, Any]]
-    extensions: Optional[Dict[str, Dict[object, object]]]
-
-
-class LifespanScope(TypedDict):
-    type: Literal["lifespan"]
-    asgi: ASGIVersions
-    state: NotRequired[Dict[str, Any]]
-
-
-WWWScope = Union[HTTPScope, WebSocketScope]
-Scope = Union[HTTPScope, WebSocketScope, LifespanScope]
-
-
-class HTTPRequestEvent(TypedDict):
-    type: Literal["http.request"]
-    body: bytes
-    more_body: bool
-
-
-class HTTPResponseDebugEvent(TypedDict):
-    type: Literal["http.response.debug"]
-    info: Dict[str, object]
-
-
-class HTTPResponseStartEvent(TypedDict):
-    type: Literal["http.response.start"]
-    status: int
-    headers: Iterable[Tuple[bytes, bytes]]
-    trailers: bool
-
-
-class HTTPResponseBodyEvent(TypedDict):
-    type: Literal["http.response.body"]
-    body: bytes
-    more_body: bool
-
-
-class HTTPResponseTrailersEvent(TypedDict):
-    type: Literal["http.response.trailers"]
-    headers: Iterable[Tuple[bytes, bytes]]
-    more_trailers: bool
-
-
-class HTTPResponsePathsendEvent(TypedDict):
-    type: Literal["http.response.pathsend"]
-    path: str
-
-
-class HTTPServerPushEvent(TypedDict):
-    type: Literal["http.response.push"]
-    path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-
-
-class HTTPDisconnectEvent(TypedDict):
-    type: Literal["http.disconnect"]
-
-
-class WebSocketConnectEvent(TypedDict):
-    type: Literal["websocket.connect"]
-
-
-class WebSocketAcceptEvent(TypedDict):
-    type: Literal["websocket.accept"]
-    subprotocol: Optional[str]
-    headers: Iterable[Tuple[bytes, bytes]]
-
-
-class WebSocketReceiveEvent(TypedDict):
-    type: Literal["websocket.receive"]
-    bytes: Optional[bytes]
-    text: Optional[str]
-
-
-class WebSocketSendEvent(TypedDict):
-    type: Literal["websocket.send"]
-    bytes: Optional[bytes]
-    text: Optional[str]
-
-
-class WebSocketResponseStartEvent(TypedDict):
-    type: Literal["websocket.http.response.start"]
-    status: int
-    headers: Iterable[Tuple[bytes, bytes]]
-
-
-class WebSocketResponseBodyEvent(TypedDict):
-    type: Literal["websocket.http.response.body"]
-    body: bytes
-    more_body: bool
-
-
-class WebSocketDisconnectEvent(TypedDict):
-    type: Literal["websocket.disconnect"]
-    code: int
-    reason: Optional[str]
-
-
-class WebSocketCloseEvent(TypedDict):
-    type: Literal["websocket.close"]
-    code: int
-    reason: Optional[str]
-
-
-class LifespanStartupEvent(TypedDict):
-    type: Literal["lifespan.startup"]
-
-
-class LifespanShutdownEvent(TypedDict):
-    type: Literal["lifespan.shutdown"]
-
-
-class LifespanStartupCompleteEvent(TypedDict):
-    type: Literal["lifespan.startup.complete"]
-
-
-class LifespanStartupFailedEvent(TypedDict):
-    type: Literal["lifespan.startup.failed"]
-    message: str
-
-
-class LifespanShutdownCompleteEvent(TypedDict):
-    type: Literal["lifespan.shutdown.complete"]
-
-
-class LifespanShutdownFailedEvent(TypedDict):
-    type: Literal["lifespan.shutdown.failed"]
-    message: str
-
-
-ASGIReceiveEvent = Union[
-    HTTPRequestEvent,
-    HTTPDisconnectEvent,
-    WebSocketConnectEvent,
-    WebSocketReceiveEvent,
-    WebSocketDisconnectEvent,
-    LifespanStartupEvent,
-    LifespanShutdownEvent,
-]
-
-
-ASGISendEvent = Union[
-    HTTPResponseStartEvent,
-    HTTPResponseBodyEvent,
-    HTTPResponseTrailersEvent,
-    HTTPServerPushEvent,
-    HTTPDisconnectEvent,
-    WebSocketAcceptEvent,
-    WebSocketSendEvent,
-    WebSocketResponseStartEvent,
-    WebSocketResponseBodyEvent,
-    WebSocketCloseEvent,
-    LifespanStartupCompleteEvent,
-    LifespanStartupFailedEvent,
-    LifespanShutdownCompleteEvent,
-    LifespanShutdownFailedEvent,
-]
-
-
-ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]]
-ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]]
-
-
-class ASGI2Protocol(Protocol):
-    def __init__(self, scope: Scope) -> None:
-        ...
-
-    async def __call__(
-        self, receive: ASGIReceiveCallable, send: ASGISendCallable
-    ) -> None:
-        ...
-
-
-ASGI2Application = Type[ASGI2Protocol]
-ASGI3Application = Callable[
-    [
-        Scope,
-        ASGIReceiveCallable,
-        ASGISendCallable,
-    ],
-    Awaitable[None],
-]
-ASGIApplication = Union[ASGI2Application, ASGI3Application]

.venv/lib/python3.12/site-packages/asgiref/wsgi.py

@@ -1,197 +0,0 @@
-import sys
-from collections import defaultdict
-from tempfile import SpooledTemporaryFile
-
-from asgiref.sync import AsyncToSync, sync_to_async
-
-
-class WsgiToAsgi:
-    """
-    Wraps a WSGI application to make it into an ASGI application.
-    """
-
-    def __init__(self, wsgi_application, duplicate_header_limit=100):
-        self.wsgi_application = wsgi_application
-        self.duplicate_header_limit = duplicate_header_limit
-
-    async def __call__(self, scope, receive, send):
-        """
-        ASGI application instantiation point.
-        We return a new WsgiToAsgiInstance here with the WSGI app
-        and the scope, ready to respond when it is __call__ed.
-        """
-        await WsgiToAsgiInstance(self.wsgi_application, self.duplicate_header_limit)(
-            scope, receive, send
-        )
-
-
-class WsgiToAsgiInstance:
-    """
-    Per-socket instance of a wrapped WSGI application
-    """
-
-    def __init__(self, wsgi_application, duplicate_header_limit=100):
-        self.wsgi_application = wsgi_application
-        self.duplicate_header_limit = duplicate_header_limit
-        self.response_started = False
-        self.response_content_length = None
-
-    async def __call__(self, scope, receive, send):
-        if scope["type"] != "http":
-            raise ValueError("WSGI wrapper received a non-HTTP scope")
-        self.scope = scope
-        with SpooledTemporaryFile(max_size=65536) as body:
-            # Alright, wait for the http.request messages
-            while True:
-                message = await receive()
-                if message["type"] != "http.request":
-                    raise ValueError("WSGI wrapper received a non-HTTP-request message")
-                body.write(message.get("body", b""))
-                if not message.get("more_body"):
-                    break
-            body.seek(0)
-            # Wrap send so it can be called from the subthread
-            self.sync_send = AsyncToSync(send)
-            # Call the WSGI app
-            await self.run_wsgi_app(body)
-
-    def build_environ(self, scope, body):
-        """
-        Builds a scope and request body into a WSGI environ object.
-        """
-        script_name = scope.get("root_path", "").encode("utf8").decode("latin1")
-        path_info = scope["path"].encode("utf8").decode("latin1")
-        if path_info.startswith(script_name):
-            path_info = path_info[len(script_name) :]
-        environ = {
-            "REQUEST_METHOD": scope["method"],
-            "SCRIPT_NAME": script_name,
-            "PATH_INFO": path_info,
-            "QUERY_STRING": scope["query_string"].decode("ascii"),
-            "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"],
-            "wsgi.version": (1, 0),
-            "wsgi.url_scheme": scope.get("scheme", "http"),
-            "wsgi.input": body,
-            "wsgi.errors": sys.stderr,
-            "wsgi.multithread": True,
-            "wsgi.multiprocess": True,
-            "wsgi.run_once": False,
-        }
-        # Get server name and port - required in WSGI, not in ASGI
-        if "server" in scope:
-            environ["SERVER_NAME"] = scope["server"][0]
-            environ["SERVER_PORT"] = str(scope["server"][1])
-        else:
-            environ["SERVER_NAME"] = "localhost"
-            environ["SERVER_PORT"] = "80"
-
-        if scope.get("client") is not None:
-            environ["REMOTE_ADDR"] = scope["client"][0]
-
-        # Go through headers and make them into environ entries
-        _headers = defaultdict(list)
-        for name, value in self.scope.get("headers", []):
-            name = name.decode("latin1")
-            if name == "content-length":
-                corrected_name = "CONTENT_LENGTH"
-            elif name == "content-type":
-                corrected_name = "CONTENT_TYPE"
-            else:
-                corrected_name = "HTTP_%s" % name.upper().replace("-", "_")
-            # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case
-            value = value.decode("latin1")
-            if (
-                self.duplicate_header_limit
-                and len(_headers[corrected_name]) >= self.duplicate_header_limit
-            ):
-                raise ValueError(
-                    f"Too many duplicate headers: {corrected_name} exceeds limit of"
-                    f"{self.duplicate_header_limit}"
-                )
-            _headers[corrected_name].append(value)
-        for name, values in _headers.items():
-            environ[name] = ",".join(values)
-        return environ
-
-    def start_response(self, status, response_headers, exc_info=None):
-        """
-        WSGI start_response callable.
-        """
-        # Don't allow re-calling once response has begun
-        if self.response_started:
-            raise exc_info[1].with_traceback(exc_info[2])
-        # Don't allow re-calling without exc_info
-        if hasattr(self, "response_start") and exc_info is None:
-            raise ValueError(
-                "You cannot call start_response a second time without exc_info"
-            )
-        # Extract status code
-        status_code, _ = status.split(" ", 1)
-        status_code = int(status_code)
-        # Extract headers
-        headers = [
-            (name.lower().encode("ascii"), value.encode("ascii"))
-            for name, value in response_headers
-        ]
-        # Extract content-length
-        self.response_content_length = None
-        for name, value in response_headers:
-            if name.lower() == "content-length":
-                self.response_content_length = int(value)
-        # Build and send response start message.
-        self.response_start = {
-            "type": "http.response.start",
-            "status": status_code,
-            "headers": headers,
-        }
-
-    @sync_to_async
-    def run_wsgi_app(self, body):
-        """
-        Called in a subthread to run the WSGI app. We encapsulate like
-        this so that the start_response callable is called in the same thread.
-        """
-        # Translate the scope and incoming request body into a WSGI environ
-        try:
-            environ = self.build_environ(self.scope, body)
-        except ValueError:
-            # Return 400 Bad Request if header limit exceeded
-            self.sync_send(
-                {
-                    "type": "http.response.start",
-                    "status": 400,
-                    "headers": [(b"content-type", b"text/plain")],
-                }
-            )
-            self.sync_send(
-                {
-                    "type": "http.response.body",
-                    "body": b"Bad Request: Too many duplicate headers",
-                }
-            )
-            return
-        # Run the WSGI app
-        bytes_sent = 0
-        for output in self.wsgi_application(environ, self.start_response):
-            # If this is the first response, include the response headers
-            if not self.response_started:
-                self.response_started = True
-                self.sync_send(self.response_start)
-            # If the application supplies a Content-Length header
-            if self.response_content_length is not None:
-                # The server should not transmit more bytes to the client than the header allows
-                bytes_allowed = self.response_content_length - bytes_sent
-                if len(output) > bytes_allowed:
-                    output = output[:bytes_allowed]
-            self.sync_send(
-                {"type": "http.response.body", "body": output, "more_body": True}
-            )
-            bytes_sent += len(output)
-            # The server should stop iterating over the response when enough data has been sent
-            if bytes_sent == self.response_content_length:
-                break
-        # Close connection
-        if not self.response_started:
-            self.response_started = True
-            self.sync_send(self.response_start)
-        self.sync_send({"type": "http.response.body"})

.venv/lib/python3.12/site-packages/channels-4.3.2.dist-info/INSTALLER

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

.venv/lib/python3.12/site-packages/channels-4.3.2.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.4
-Name: channels
-Version: 4.3.2
-Summary: Brings async, event-driven capabilities to Django.
-Home-page: http://github.com/django/channels
-Author: Django Software Foundation
-Author-email: foundation@djangoproject.com
-License: BSD
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Framework :: Django
-Classifier: Framework :: Django :: 4.2
-Classifier: Framework :: Django :: 5.1
-Classifier: Framework :: Django :: 5.2
-Classifier: Framework :: Django :: 6.0
-Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.9
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-Requires-Dist: Django>=4.2
-Requires-Dist: asgiref<4,>=3.9.0
-Provides-Extra: tests
-Requires-Dist: async-timeout; extra == "tests"
-Requires-Dist: coverage~=4.5; extra == "tests"
-Requires-Dist: pytest; extra == "tests"
-Requires-Dist: pytest-django; extra == "tests"
-Requires-Dist: pytest-asyncio; extra == "tests"
-Requires-Dist: selenium; extra == "tests"
-Provides-Extra: daphne
-Requires-Dist: daphne>=4.0.0; extra == "daphne"
-Provides-Extra: types
-Requires-Dist: types-channels; extra == "types"
-Dynamic: license-file
-
-Django Channels
-===============
-
-.. image:: https://github.com/django/channels/workflows/Tests/badge.svg?branch=master
-    :target: https://github.com/django/channels/actions
-
-.. image:: https://readthedocs.org/projects/channels/badge/?version=latest
-    :target: https://channels.readthedocs.io/en/latest/?badge=latest
-
-.. image:: https://img.shields.io/pypi/v/channels.svg
-    :target: https://pypi.python.org/pypi/channels
-
-.. image:: https://img.shields.io/pypi/l/channels.svg
-    :target: https://pypi.python.org/pypi/channels
-
-Channels augments Django to bring WebSocket, long-poll HTTP,
-task offloading and other async support to your code, using familiar Django
-design patterns and a flexible underlying framework that lets you not only
-customize behaviours but also write support for your own protocols and needs.
-
-Documentation, installation and getting started instructions are at
-https://channels.readthedocs.io
-
-Channels is an official Django Project and as such has a deprecation policy.
-Details about what's deprecated or pending deprecation for each release is in
-the `release notes <https://channels.readthedocs.io/en/latest/releases/index.html>`_.
-
-Support can be obtained through several locations - see our
-`support docs <https://channels.readthedocs.io/en/latest/support.html>`_ for more.
-
-You can install channels from PyPI as the ``channels`` package.
-See our `installation <https://channels.readthedocs.io/en/latest/installation.html>`_
-and `tutorial <https://channels.readthedocs.io/en/latest/tutorial/index.html>`_ docs for more.
-
-Dependencies
-------------
-
-All Channels projects currently support Python 3.9 and up. ``channels`` is
-compatible with Django 4.2+.
-
-
-Contributing
-------------
-
-To learn more about contributing, please `read our contributing docs <https://channels.readthedocs.io/en/latest/contributing.html>`_.
-
-
-Maintenance and Security
-------------------------
-
-To report security issues, please contact security@djangoproject.com. For GPG
-signatures and more security process information, see
-https://docs.djangoproject.com/en/dev/internals/security/.
-
-To report bugs or request new features, please open a new GitHub issue. For
-larger discussions, please post to the
-`django-developers mailing list <https://groups.google.com/d/forum/django-developers>`_.
-
-Maintenance is overseen by Carlton Gibson with help from others. It is a
-best-effort basis - we unfortunately can only dedicate guaranteed time to fixing
-security holes.
-
-If you are interested in joining the maintenance team, please
-`read more about contributing <https://channels.readthedocs.io/en/latest/contributing.html>`_
-and get in touch!
-
-
-Other Projects
---------------
-
-The Channels project is made up of several packages; the others are:
-
-* `Daphne <https://github.com/django/daphne/>`_, the HTTP and Websocket termination server
-* `channels_redis <https://github.com/django/channels_redis/>`_, the Redis channel backend
-* `asgiref <https://github.com/django/asgiref/>`_, the base ASGI library/memory backend

.venv/lib/python3.12/site-packages/channels-4.3.2.dist-info/RECORD

@@ -1,57 +0,0 @@
-channels-4.3.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-channels-4.3.2.dist-info/METADATA,sha256=BwYRORAOx9yHcJ-8r-ZL7HBLCUBe5Drp9Rxhai2Y0y4,4733
-channels-4.3.2.dist-info/RECORD,,
-channels-4.3.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channels-4.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-channels-4.3.2.dist-info/licenses/LICENSE,sha256=uEZBXRtRTpwd_xSiLeuQbXlLxUbKYSn5UKGM0JHipmk,1552
-channels-4.3.2.dist-info/top_level.txt,sha256=5-YaD2ZIFwhfgn0xikDTCwaofGY9Tg_HVyZkw2ocUnA,9
-channels/__init__.py,sha256=EFpQ7yveKhJpBCF-Obdnyz5DmEOZ_6wHmHbvZpcswW0,58
-channels/__pycache__/__init__.cpython-312.pyc,,
-channels/__pycache__/apps.cpython-312.pyc,,
-channels/__pycache__/auth.cpython-312.pyc,,
-channels/__pycache__/consumer.cpython-312.pyc,,
-channels/__pycache__/db.cpython-312.pyc,,
-channels/__pycache__/exceptions.cpython-312.pyc,,
-channels/__pycache__/layers.cpython-312.pyc,,
-channels/__pycache__/middleware.cpython-312.pyc,,
-channels/__pycache__/routing.cpython-312.pyc,,
-channels/__pycache__/sessions.cpython-312.pyc,,
-channels/__pycache__/utils.cpython-312.pyc,,
-channels/__pycache__/worker.cpython-312.pyc,,
-channels/apps.py,sha256=UHur2um23F2CCyBmTP5ltA1_UhE1BNv86c1Qwrhyq2M,121
-channels/auth.py,sha256=1PdA1_FP9fOx1WLcJrIJKDhZA9J2wAXMYDmO3bJUlxM,6547
-channels/consumer.py,sha256=Z_Q1Z3YwJuGn5ZmmOqtIhyQkUjGosIZs5WW2ruIxHRE,4383
-channels/db.py,sha256=csGTwmt2B4r25GfKpSdXq-R6gegeIrZMwOZAhtp6i2o,671
-channels/exceptions.py,sha256=-AJy2YuE4geaucjGDo59ZA78a-m5ZMJNOUS_QVzSASo,1119
-channels/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channels/generic/__pycache__/__init__.cpython-312.pyc,,
-channels/generic/__pycache__/http.cpython-312.pyc,,
-channels/generic/__pycache__/websocket.cpython-312.pyc,,
-channels/generic/http.py,sha256=uH-RRpsrjpIqQ6BkM97-q3ejINQN9lhnynge0sV0W6s,3164
-channels/generic/websocket.py,sha256=fBmRPYsHd8PN4meRQLwTnqSvfaVeUV_b1iUmQ1Eee0s,8971
-channels/layers.py,sha256=EIFVYS9pfwQhgF593H2SlTYCVGVVPOuy_j6HR1gSy2E,13885
-channels/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channels/management/__pycache__/__init__.cpython-312.pyc,,
-channels/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channels/management/commands/__pycache__/__init__.cpython-312.pyc,,
-channels/management/commands/__pycache__/runworker.cpython-312.pyc,,
-channels/management/commands/runworker.py,sha256=BtylPOYraYaMtpihq9AVo-AY7dPV-2yHaVU7XLl8HO8,1593
-channels/middleware.py,sha256=6PQuE_-vzH7QF2bHcbgyBBJYnsyZBhhMFwRUrj6hz7o,756
-channels/routing.py,sha256=1SsW3QuEiSNNODjWdTVaoJJWuoSnQ4ziAoqCW353tac,6222
-channels/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-channels/security/__pycache__/__init__.cpython-312.pyc,,
-channels/security/__pycache__/websocket.cpython-312.pyc,,
-channels/security/websocket.py,sha256=UpAGDrq1ua-7QdSheQr9S6KHa_2J79ofL_r1EHVWEK8,5799
-channels/sessions.py,sha256=ypGHxjlltZlXwQw-vL8F6Q04VNQ0xXdDqtlY4ZEeyR4,10070
-channels/testing/__init__.py,sha256=ut34-rDuPhaefvs3fMEk5qc0xeITdbhH7y17G95xl4U,339
-channels/testing/__pycache__/__init__.cpython-312.pyc,,
-channels/testing/__pycache__/application.cpython-312.pyc,,
-channels/testing/__pycache__/http.cpython-312.pyc,,
-channels/testing/__pycache__/live.cpython-312.pyc,,
-channels/testing/__pycache__/websocket.cpython-312.pyc,,
-channels/testing/application.py,sha256=uGLKlhfnVTcjfs-TxsoeKNhs4VlfSoabgYJxaN4s6Qo,533
-channels/testing/http.py,sha256=1j3GQw6Gwb9JWMK38YAQhEPD65FQLj1zdBQppSwExtg,2056
-channels/testing/live.py,sha256=Qj2JjqMxgX7whBRoednIOkP2v-Q2cyTA0-ySVfGlQ6s,3214
-channels/testing/websocket.py,sha256=3tSp5EYl7mxx_wyqpRsTz01ysgqEdsk-sqoU5NSRkDc,4417
-channels/utils.py,sha256=ZXkTASx-Qf9fcJjCHQFJkkH_oTDrcHerjcyyyHU8iyE,2177
-channels/worker.py,sha256=6z_R8hUqlD9bz2vNHi1NCgZyxLMNzU_0t6tF-APk7yI,1687

.venv/lib/python3.12/site-packages/channels-4.3.2.dist-info/WHEEL

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

.venv/lib/python3.12/site-packages/channels-4.3.2.dist-info/licenses/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/channels-4.3.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-channels

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

@@ -1,4 +0,0 @@
-__version__ = "4.3.2"
-
-
-DEFAULT_CHANNEL_LAYER = "default"

.venv/lib/python3.12/site-packages/channels/apps.py

@@ -1,6 +0,0 @@
-from django.apps import AppConfig
-
-
-class ChannelsConfig(AppConfig):
-    name = "channels"
-    verbose_name = "Channels"

.venv/lib/python3.12/site-packages/channels/auth.py

@@ -1,190 +0,0 @@
-from django.conf import settings
-from django.contrib.auth import (
-    BACKEND_SESSION_KEY,
-    HASH_SESSION_KEY,
-    SESSION_KEY,
-    _get_backends,
-    get_user_model,
-    load_backend,
-    user_logged_in,
-    user_logged_out,
-)
-from django.utils.crypto import constant_time_compare
-from django.utils.functional import LazyObject
-
-from channels.db import database_sync_to_async
-from channels.middleware import BaseMiddleware
-from channels.sessions import CookieMiddleware, SessionMiddleware
-
-
-@database_sync_to_async
-def get_user(scope):
-    """
-    Return the user model instance associated with the given scope.
-    If no user is retrieved, return an instance of `AnonymousUser`.
-    """
-    # postpone model import to avoid ImproperlyConfigured error before Django
-    # setup is complete.
-    from django.contrib.auth.models import AnonymousUser
-
-    if "session" not in scope:
-        raise ValueError(
-            "Cannot find session in scope. You should wrap your consumer in "
-            "SessionMiddleware."
-        )
-    session = scope["session"]
-    user = None
-    try:
-        user_id = _get_user_session_key(session)
-        backend_path = session[BACKEND_SESSION_KEY]
-    except KeyError:
-        pass
-    else:
-        if backend_path in settings.AUTHENTICATION_BACKENDS:
-            backend = load_backend(backend_path)
-            user = backend.get_user(user_id)
-            # Verify the session
-            if hasattr(user, "get_session_auth_hash"):
-                session_hash = session.get(HASH_SESSION_KEY)
-                session_hash_verified = session_hash and constant_time_compare(
-                    session_hash, user.get_session_auth_hash()
-                )
-                if not session_hash_verified:
-                    session.flush()
-                    user = None
-    return user or AnonymousUser()
-
-
-@database_sync_to_async
-def login(scope, user, backend=None):
-    """
-    Persist a user id and a backend in the request.
-    This way a user doesn't have to re-authenticate on every request.
-    Note that data set during the anonymous session is retained when the user
-    logs in.
-    """
-    if "session" not in scope:
-        raise ValueError(
-            "Cannot find session in scope. You should wrap your consumer in "
-            "SessionMiddleware."
-        )
-    session = scope["session"]
-    session_auth_hash = ""
-    if user is None:
-        user = scope.get("user", None)
-    if user is None:
-        raise ValueError(
-            "User must be passed as an argument or must be present in the scope."
-        )
-    if hasattr(user, "get_session_auth_hash"):
-        session_auth_hash = user.get_session_auth_hash()
-    if SESSION_KEY in session:
-        if _get_user_session_key(session) != user.pk or (
-            session_auth_hash
-            and not constant_time_compare(
-                session.get(HASH_SESSION_KEY, ""), session_auth_hash
-            )
-        ):
-            # To avoid reusing another user's session, create a new, empty
-            # session if the existing session corresponds to a different
-            # authenticated user.
-            session.flush()
-    else:
-        session.cycle_key()
-    try:
-        backend = backend or user.backend
-    except AttributeError:
-        backends = _get_backends(return_tuples=True)
-        if len(backends) == 1:
-            _, backend = backends[0]
-        else:
-            raise ValueError(
-                "You have multiple authentication backends configured and "
-                "therefore must provide the `backend` "
-                "argument or set the `backend` attribute on the user."
-            )
-    session[SESSION_KEY] = user._meta.pk.value_to_string(user)
-    session[BACKEND_SESSION_KEY] = backend
-    session[HASH_SESSION_KEY] = session_auth_hash
-    scope["user"] = user
-    # note this does not reset the CSRF_COOKIE/Token
-    user_logged_in.send(sender=user.__class__, request=None, user=user)
-
-
-@database_sync_to_async
-def logout(scope):
-    """
-    Remove the authenticated user's ID from the request and flush their session
-    data.
-    """
-    # postpone model import to avoid ImproperlyConfigured error before Django
-    # setup is complete.
-    from django.contrib.auth.models import AnonymousUser
-
-    if "session" not in scope:
-        raise ValueError(
-            "Login cannot find session in scope. You should wrap your "
-            "consumer in SessionMiddleware."
-        )
-    session = scope["session"]
-    # Dispatch the signal before the user is logged out so the receivers have a
-    # chance to find out *who* logged out.
-    user = scope.get("user", None)
-    if hasattr(user, "is_authenticated") and not user.is_authenticated:
-        user = None
-    if user is not None:
-        user_logged_out.send(sender=user.__class__, request=None, user=user)
-    session.flush()
-    if "user" in scope:
-        scope["user"] = AnonymousUser()
-
-
-def _get_user_session_key(session):
-    # This value in the session is always serialized to a string, so we need
-    # to convert it back to Python whenever we access it.
-    return get_user_model()._meta.pk.to_python(session[SESSION_KEY])
-
-
-class UserLazyObject(LazyObject):
-    """
-    Throw a more useful error message when scope['user'] is accessed before
-    it's resolved
-    """
-
-    def _setup(self):
-        raise ValueError("Accessing scope user before it is ready.")
-
-
-class AuthMiddleware(BaseMiddleware):
-    """
-    Middleware which populates scope["user"] from a Django session.
-    Requires SessionMiddleware to function.
-    """
-
-    def populate_scope(self, scope):
-        # Make sure we have a session
-        if "session" not in scope:
-            raise ValueError(
-                "AuthMiddleware cannot find session in scope. "
-                "SessionMiddleware must be above it."
-            )
-        # Add it to the scope if it's not there already
-        if "user" not in scope:
-            scope["user"] = UserLazyObject()
-
-    async def resolve_scope(self, scope):
-        scope["user"]._wrapped = await get_user(scope)
-
-    async def __call__(self, scope, receive, send):
-        scope = dict(scope)
-        # Scope injection/mutation per this middleware's needs.
-        self.populate_scope(scope)
-        # Grab the finalized/resolved scope
-        await self.resolve_scope(scope)
-
-        return await super().__call__(scope, receive, send)
-
-
-# Handy shortcut for applying all three layers at once
-def AuthMiddlewareStack(inner):
-    return CookieMiddleware(SessionMiddleware(AuthMiddleware(inner)))

.venv/lib/python3.12/site-packages/channels/consumer.py

@@ -1,134 +0,0 @@
-import functools
-
-from asgiref.sync import async_to_sync
-
-from . import DEFAULT_CHANNEL_LAYER
-from .db import aclose_old_connections, database_sync_to_async
-from .exceptions import StopConsumer
-from .layers import get_channel_layer
-from .utils import await_many_dispatch
-
-
-def get_handler_name(message):
-    """
-    Looks at a message, checks it has a sensible type, and returns the
-    handler name for that type.
-    """
-    # Check message looks OK
-    if "type" not in message:
-        raise ValueError("Incoming message has no 'type' attribute")
-    # Extract type and replace . with _
-    handler_name = message["type"].replace(".", "_")
-    if handler_name.startswith("_"):
-        raise ValueError("Malformed type in message (leading underscore)")
-    return handler_name
-
-
-class AsyncConsumer:
-    """
-    Base consumer class. Implements the ASGI application spec, and adds on
-    channel layer management and routing of events to named methods based
-    on their type.
-    """
-
-    _sync = False
-    channel_layer_alias = DEFAULT_CHANNEL_LAYER
-
-    async def __call__(self, scope, receive, send):
-        """
-        Dispatches incoming messages to type-based handlers asynchronously.
-        """
-        self.scope = scope
-
-        # Initialize channel layer
-        self.channel_layer = get_channel_layer(self.channel_layer_alias)
-        if self.channel_layer is not None:
-            self.channel_name = await self.channel_layer.new_channel()
-            self.channel_receive = functools.partial(
-                self.channel_layer.receive, self.channel_name
-            )
-        # Store send function
-        if self._sync:
-            self.base_send = async_to_sync(send)
-        else:
-            self.base_send = send
-        # Pass messages in from channel layer or client to dispatch method
-        try:
-            if self.channel_layer is not None:
-                await await_many_dispatch(
-                    [receive, self.channel_receive], self.dispatch
-                )
-            else:
-                await await_many_dispatch([receive], self.dispatch)
-        except StopConsumer:
-            # Exit cleanly
-            pass
-
-    async def dispatch(self, message):
-        """
-        Works out what to do with a message.
-        """
-        handler = getattr(self, get_handler_name(message), None)
-        if handler:
-            await aclose_old_connections()
-            await handler(message)
-        else:
-            raise ValueError("No handler for message type %s" % message["type"])
-
-    async def send(self, message):
-        """
-        Overrideable/callable-by-subclasses send method.
-        """
-        await self.base_send(message)
-
-    @classmethod
-    def as_asgi(cls, **initkwargs):
-        """
-        Return an ASGI v3 single callable that instantiates a consumer instance
-        per scope. Similar in purpose to Django's as_view().
-
-        initkwargs will be used to instantiate the consumer instance.
-        """
-
-        async def app(scope, receive, send):
-            consumer = cls(**initkwargs)
-            return await consumer(scope, receive, send)
-
-        app.consumer_class = cls
-        app.consumer_initkwargs = initkwargs
-
-        # take name and docstring from class
-        functools.update_wrapper(app, cls, updated=())
-        return app
-
-
-class SyncConsumer(AsyncConsumer):
-    """
-    Synchronous version of the consumer, which is what we write most of the
-    generic consumers against (for now). Calls handlers in a threadpool and
-    uses CallBouncer to get the send method out to the main event loop.
-
-    It would have been possible to have "mixed" consumers and auto-detect
-    if a handler was awaitable or not, but that would have made the API
-    for user-called methods very confusing as there'd be two types of each.
-    """
-
-    _sync = True
-
-    @database_sync_to_async
-    def dispatch(self, message):
-        """
-        Dispatches incoming messages to type-based handlers asynchronously.
-        """
-        # Get and execute the handler
-        handler = getattr(self, get_handler_name(message), None)
-        if handler:
-            handler(message)
-        else:
-            raise ValueError("No handler for message type %s" % message["type"])
-
-    def send(self, message):
-        """
-        Overrideable/callable-by-subclasses send method.
-        """
-        self.base_send(message)

.venv/lib/python3.12/site-packages/channels/db.py

@@ -1,23 +0,0 @@
-from asgiref.sync import SyncToAsync, sync_to_async
-from django.db import close_old_connections
-
-
-class DatabaseSyncToAsync(SyncToAsync):
-    """
-    SyncToAsync version that cleans up old database connections when it exits.
-    """
-
-    def thread_handler(self, loop, *args, **kwargs):
-        close_old_connections()
-        try:
-            return super().thread_handler(loop, *args, **kwargs)
-        finally:
-            close_old_connections()
-
-
-# The class is TitleCased, but we want to encourage use as a callable/decorator
-database_sync_to_async = DatabaseSyncToAsync
-
-
-async def aclose_old_connections():
-    return await sync_to_async(close_old_connections)()

.venv/lib/python3.12/site-packages/channels/exceptions.py

@@ -1,65 +0,0 @@
-class RequestAborted(Exception):
-    """
-    Raised when the incoming request tells us it's aborted partway through
-    reading the body.
-    """
-
-    pass
-
-
-class RequestTimeout(RequestAborted):
-    """
-    Aborted specifically due to timeout.
-    """
-
-    pass
-
-
-class InvalidChannelLayerError(ValueError):
-    """
-    Raised when a channel layer is configured incorrectly.
-    """
-
-    pass
-
-
-class AcceptConnection(Exception):
-    """
-    Raised during a websocket.connect (or other supported connection) handler
-    to accept the connection.
-    """
-
-    pass
-
-
-class DenyConnection(Exception):
-    """
-    Raised during a websocket.connect (or other supported connection) handler
-    to deny the connection.
-    """
-
-    pass
-
-
-class ChannelFull(Exception):
-    """
-    Raised when a channel cannot be sent to as it is over capacity.
-    """
-
-    pass
-
-
-class MessageTooLarge(Exception):
-    """
-    Raised when a message cannot be sent as it's too big.
-    """
-
-    pass
-
-
-class StopConsumer(Exception):
-    """
-    Raised when a consumer wants to stop and close down its application instance.
-    """
-
-    pass

.venv/lib/python3.12/site-packages/channels/generic/http.py

@@ -1,93 +0,0 @@
-from channels.consumer import AsyncConsumer
-
-from ..db import aclose_old_connections
-from ..exceptions import StopConsumer
-
-
-class AsyncHttpConsumer(AsyncConsumer):
-    """
-    Async HTTP consumer. Provides basic primitives for building asynchronous
-    HTTP endpoints.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self.body = []
-
-    async def send_headers(self, *, status=200, headers=None):
-        """
-        Sets the HTTP response status and headers. Headers may be provided as
-        a list of tuples or as a dictionary.
-
-        Note that the ASGI spec requires that the protocol server only starts
-        sending the response to the client after ``self.send_body`` has been
-        called the first time.
-        """
-        if headers is None:
-            headers = []
-        elif isinstance(headers, dict):
-            headers = list(headers.items())
-
-        await self.send(
-            {"type": "http.response.start", "status": status, "headers": headers}
-        )
-
-    async def send_body(self, body, *, more_body=False):
-        """
-        Sends a response body to the client. The method expects a bytestring.
-
-        Set ``more_body=True`` if you want to send more body content later.
-        The default behavior closes the response, and further messages on
-        the channel will be ignored.
-        """
-        assert isinstance(body, bytes), "Body is not bytes"
-        await self.send(
-            {"type": "http.response.body", "body": body, "more_body": more_body}
-        )
-
-    async def send_response(self, status, body, **kwargs):
-        """
-        Sends a response to the client. This is a thin wrapper over
-        ``self.send_headers`` and ``self.send_body``, and everything said
-        above applies here as well. This method may only be called once.
-        """
-        await self.send_headers(status=status, **kwargs)
-        await self.send_body(body)
-
-    async def handle(self, body):
-        """
-        Receives the request body as a bytestring. Response may be composed
-        using the ``self.send*`` methods; the return value of this method is
-        thrown away.
-        """
-        raise NotImplementedError(
-            "Subclasses of AsyncHttpConsumer must provide a handle() method."
-        )
-
-    async def disconnect(self):
-        """
-        Overrideable place to run disconnect handling. Do not send anything
-        from here.
-        """
-        pass
-
-    async def http_request(self, message):
-        """
-        Async entrypoint - concatenates body fragments and hands off control
-        to ``self.handle`` when the body has been completely received.
-        """
-        if "body" in message:
-            self.body.append(message["body"])
-        if not message.get("more_body"):
-            try:
-                await self.handle(b"".join(self.body))
-            finally:
-                await self.disconnect()
-            raise StopConsumer()
-
-    async def http_disconnect(self, message):
-        """
-        Let the user do their cleanup and close the consumer.
-        """
-        await self.disconnect()
-        await aclose_old_connections()
-        raise StopConsumer()