diff --git a/.env b/.env new file mode 100644 index 0000000..2cfb031 --- /dev/null +++ b/.env @@ -0,0 +1,2 @@ +OPENAI_API_KEY=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 +OPENAI_MODEL=gpt-4.1-mini diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..60f1c19 --- /dev/null +++ b/.env.example @@ -0,0 +1,2 @@ +OPENAI_API_KEY=put-your-key-here +OPENAI_MODEL=gpt-4.1-mini diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/.venv/bin/Activate.ps1 b/.venv/bin/Activate.ps1 new file mode 100644 index 0000000..b49d77b --- /dev/null +++ b/.venv/bin/Activate.ps1 @@ -0,0 +1,247 @@ +<# +.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" diff --git a/.venv/bin/activate b/.venv/bin/activate new file mode 100644 index 0000000..231bd47 --- /dev/null +++ b/.venv/bin/activate @@ -0,0 +1,69 @@ +# 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 + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + unset VIRTUAL_ENV_PROMPT + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV=/home/ed/projects/subfox/.venv +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/"bin":$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1='(.venv) '"${PS1:-}" + export PS1 + VIRTUAL_ENV_PROMPT='(.venv) ' + export VIRTUAL_ENV_PROMPT +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null +fi diff --git a/.venv/bin/activate.csh b/.venv/bin/activate.csh new file mode 100644 index 0000000..e5af970 --- /dev/null +++ b/.venv/bin/activate.csh @@ -0,0 +1,26 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +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/ed/projects/subfox/.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 diff --git a/.venv/bin/activate.fish b/.venv/bin/activate.fish new file mode 100644 index 0000000..7aae682 --- /dev/null +++ b/.venv/bin/activate.fish @@ -0,0 +1,69 @@ +# This file must be used with "source /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/ed/projects/subfox/.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 diff --git a/.venv/bin/deep-translator b/.venv/bin/deep-translator new file mode 100755 index 0000000..4065136 --- /dev/null +++ b/.venv/bin/deep-translator @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from deep_translator.__main__ import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/distro b/.venv/bin/distro new file mode 100755 index 0000000..d23a7d1 --- /dev/null +++ b/.venv/bin/distro @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from distro.distro import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/dt b/.venv/bin/dt new file mode 100755 index 0000000..4065136 --- /dev/null +++ b/.venv/bin/dt @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from deep_translator.__main__ import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/fastapi b/.venv/bin/fastapi new file mode 100755 index 0000000..b1fc66b --- /dev/null +++ b/.venv/bin/fastapi @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from fastapi.cli import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/httpx b/.venv/bin/httpx new file mode 100755 index 0000000..4cf689b --- /dev/null +++ b/.venv/bin/httpx @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from httpx import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/normalizer b/.venv/bin/normalizer new file mode 100755 index 0000000..1ecd013 --- /dev/null +++ b/.venv/bin/normalizer @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from charset_normalizer.cli import cli_detect +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(cli_detect()) diff --git a/.venv/bin/openai b/.venv/bin/openai new file mode 100755 index 0000000..aa49507 --- /dev/null +++ b/.venv/bin/openai @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from openai.cli import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/pip b/.venv/bin/pip new file mode 100755 index 0000000..ace2cc9 --- /dev/null +++ b/.venv/bin/pip @@ -0,0 +1,8 @@ +#!/home/ed/projects/subfox/.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()) diff --git a/.venv/bin/pip3 b/.venv/bin/pip3 new file mode 100755 index 0000000..ace2cc9 --- /dev/null +++ b/.venv/bin/pip3 @@ -0,0 +1,8 @@ +#!/home/ed/projects/subfox/.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()) diff --git a/.venv/bin/pip3.10 b/.venv/bin/pip3.10 new file mode 100755 index 0000000..ace2cc9 --- /dev/null +++ b/.venv/bin/pip3.10 @@ -0,0 +1,8 @@ +#!/home/ed/projects/subfox/.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()) diff --git a/.venv/bin/python b/.venv/bin/python new file mode 120000 index 0000000..b8a0adb --- /dev/null +++ b/.venv/bin/python @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/.venv/bin/python3 b/.venv/bin/python3 new file mode 120000 index 0000000..ae65fda --- /dev/null +++ b/.venv/bin/python3 @@ -0,0 +1 @@ +/usr/bin/python3 \ No newline at end of file diff --git a/.venv/bin/python3.10 b/.venv/bin/python3.10 new file mode 120000 index 0000000..b8a0adb --- /dev/null +++ b/.venv/bin/python3.10 @@ -0,0 +1 @@ +python3 \ No newline at end of file diff --git a/.venv/bin/tqdm b/.venv/bin/tqdm new file mode 100755 index 0000000..a847137 --- /dev/null +++ b/.venv/bin/tqdm @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from tqdm.cli import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/bin/uvicorn b/.venv/bin/uvicorn new file mode 100755 index 0000000..a648be3 --- /dev/null +++ b/.venv/bin/uvicorn @@ -0,0 +1,6 @@ +#!/home/ed/projects/subfox/.venv/bin/python +import sys +from uvicorn.main import main +if __name__ == '__main__': + sys.argv[0] = sys.argv[0].removesuffix('.exe') + sys.exit(main()) diff --git a/.venv/lib/python3.10/site-packages/81d243bd2c585b0f4821__mypyc.cpython-310-x86_64-linux-gnu.so b/.venv/lib/python3.10/site-packages/81d243bd2c585b0f4821__mypyc.cpython-310-x86_64-linux-gnu.so new file mode 100755 index 0000000..883c5a2 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/81d243bd2c585b0f4821__mypyc.cpython-310-x86_64-linux-gnu.so differ diff --git a/.venv/lib/python3.10/site-packages/__pycache__/typing_extensions.cpython-310.pyc b/.venv/lib/python3.10/site-packages/__pycache__/typing_extensions.cpython-310.pyc new file mode 100644 index 0000000..b8d724a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/__pycache__/typing_extensions.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/_distutils_hack/__init__.py b/.venv/lib/python3.10/site-packages/_distutils_hack/__init__.py new file mode 100644 index 0000000..f707416 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/_distutils_hack/__init__.py @@ -0,0 +1,132 @@ +import sys +import os +import re +import importlib +import warnings + + +is_pypy = '__pypy__' in sys.builtin_module_names + + +warnings.filterwarnings('ignore', + r'.+ distutils\b.+ deprecated', + DeprecationWarning) + + +def warn_distutils_present(): + if 'distutils' not in sys.modules: + return + if is_pypy and sys.version_info < (3, 7): + # PyPy for 3.6 unconditionally imports distutils, so bypass the warning + # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250 + return + warnings.warn( + "Distutils was imported before Setuptools, but importing Setuptools " + "also replaces the `distutils` module in `sys.modules`. This may lead " + "to undesirable behaviors or errors. To avoid these issues, avoid " + "using distutils directly, ensure that setuptools is installed in the " + "traditional way (e.g. not an editable install), and/or make sure " + "that setuptools is always imported before distutils.") + + +def clear_distutils(): + if 'distutils' not in sys.modules: + return + warnings.warn("Setuptools is replacing distutils.") + mods = [name for name in sys.modules if re.match(r'distutils\b', name)] + for name in mods: + del sys.modules[name] + + +def enabled(): + """ + Allow selection of distutils by environment variable. + """ + which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib') + return which == 'local' + + +def ensure_local_distutils(): + clear_distutils() + + # With the DistutilsMetaFinder in place, + # perform an import to cause distutils to be + # loaded from setuptools._distutils. Ref #2906. + add_shim() + importlib.import_module('distutils') + remove_shim() + + # check that submodules load as expected + core = importlib.import_module('distutils.core') + assert '_distutils' in core.__file__, core.__file__ + + +def do_override(): + """ + Ensure that the local copy of distutils is preferred over stdlib. + + See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401 + for more motivation. + """ + if enabled(): + warn_distutils_present() + ensure_local_distutils() + + +class DistutilsMetaFinder: + def find_spec(self, fullname, path, target=None): + if path is not None: + return + + method_name = 'spec_for_{fullname}'.format(**locals()) + method = getattr(self, method_name, lambda: None) + return method() + + def spec_for_distutils(self): + import importlib.abc + import importlib.util + + class DistutilsLoader(importlib.abc.Loader): + + def create_module(self, spec): + return importlib.import_module('setuptools._distutils') + + def exec_module(self, module): + pass + + return importlib.util.spec_from_loader('distutils', DistutilsLoader()) + + def spec_for_pip(self): + """ + Ensure stdlib distutils when running under pip. + See pypa/pip#8761 for rationale. + """ + if self.pip_imported_during_build(): + return + clear_distutils() + self.spec_for_distutils = lambda: None + + @staticmethod + def pip_imported_during_build(): + """ + Detect if pip is being imported in a build script. Ref #2355. + """ + import traceback + return any( + frame.f_globals['__file__'].endswith('setup.py') + for frame, line in traceback.walk_stack(None) + ) + + +DISTUTILS_FINDER = DistutilsMetaFinder() + + +def add_shim(): + sys.meta_path.insert(0, DISTUTILS_FINDER) + + +def remove_shim(): + try: + sys.meta_path.remove(DISTUTILS_FINDER) + except ValueError: + pass diff --git a/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..a127e79 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/override.cpython-310.pyc b/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/override.cpython-310.pyc new file mode 100644 index 0000000..fb65ffc Binary files /dev/null and b/.venv/lib/python3.10/site-packages/_distutils_hack/__pycache__/override.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/_distutils_hack/override.py b/.venv/lib/python3.10/site-packages/_distutils_hack/override.py new file mode 100644 index 0000000..2cc433a --- /dev/null +++ b/.venv/lib/python3.10/site-packages/_distutils_hack/override.py @@ -0,0 +1 @@ +__import__('_distutils_hack').do_override() diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/METADATA b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/METADATA new file mode 100644 index 0000000..9bf7a9e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/METADATA @@ -0,0 +1,145 @@ +Metadata-Version: 2.4 +Name: annotated-doc +Version: 0.0.4 +Summary: Document parameters, class attributes, return types, and variables inline, with Annotated. +Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= +License-Expression: MIT +License-File: LICENSE +Classifier: Intended Audience :: Information Technology +Classifier: Intended Audience :: System Administrators +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python +Classifier: Topic :: Internet +Classifier: Topic :: Software Development :: Libraries :: Application Frameworks +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Software Development +Classifier: Typing :: Typed +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Project-URL: Homepage, https://github.com/fastapi/annotated-doc +Project-URL: Documentation, https://github.com/fastapi/annotated-doc +Project-URL: Repository, https://github.com/fastapi/annotated-doc +Project-URL: Issues, https://github.com/fastapi/annotated-doc/issues +Project-URL: Changelog, https://github.com/fastapi/annotated-doc/release-notes.md +Requires-Python: >=3.8 +Description-Content-Type: text/markdown + +# Annotated Doc + +Document parameters, class attributes, return types, and variables inline, with `Annotated`. + + + Test + + + Coverage + + + Package version + + + Supported Python versions + + +## Installation + +```bash +pip install annotated-doc +``` + +Or with `uv`: + +```Python +uv add annotated-doc +``` + +## Usage + +Import `Doc` and pass a single literal string with the documentation for the specific parameter, class attribute, return type, or variable. + +For example, to document a parameter `name` in a function `hi` you could do: + +```Python +from typing import Annotated + +from annotated_doc import Doc + +def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None: + print(f"Hi, {name}!") +``` + +You can also use it to document class attributes: + +```Python +from typing import Annotated + +from annotated_doc import Doc + +class User: + name: Annotated[str, Doc("The user's name")] + age: Annotated[int, Doc("The user's age")] +``` + +The same way, you could document return types and variables, or anything that could have a type annotation with `Annotated`. + +## Who Uses This + +`annotated-doc` was made for: + +* [FastAPI](https://fastapi.tiangolo.com/) +* [Typer](https://typer.tiangolo.com/) +* [SQLModel](https://sqlmodel.tiangolo.com/) +* [Asyncer](https://asyncer.tiangolo.com/) + +`annotated-doc` is supported by [griffe-typingdoc](https://github.com/mkdocstrings/griffe-typingdoc), which powers reference documentation like the one in the [FastAPI Reference](https://fastapi.tiangolo.com/reference/). + +## Reasons not to use `annotated-doc` + +You are already comfortable with one of the existing docstring formats, like: + +* Sphinx +* numpydoc +* Google +* Keras + +Your team is already comfortable using them. + +You prefer having the documentation about parameters all together in a docstring, separated from the code defining them. + +You care about a specific set of users, using one specific editor, and that editor already has support for the specific docstring format you use. + +## Reasons to use `annotated-doc` + +* No micro-syntax to learn for newcomers, it’s **just Python** syntax. +* **Editing** would be already fully supported by default by any editor (current or future) supporting Python syntax, including syntax errors, syntax highlighting, etc. +* **Rendering** would be relatively straightforward to implement by static tools (tools that don't need runtime execution), as the information can be extracted from the AST they normally already create. +* **Deduplication of information**: the name of a parameter would be defined in a single place, not duplicated inside of a docstring. +* **Elimination** of the possibility of having **inconsistencies** when removing a parameter or class variable and **forgetting to remove** its documentation. +* **Minimization** of the probability of adding a new parameter or class variable and **forgetting to add its documentation**. +* **Elimination** of the possibility of having **inconsistencies** between the **name** of a parameter in the **signature** and the name in the docstring when it is renamed. +* **Access** to the documentation string for each symbol at **runtime**, including existing (older) Python versions. +* A more formalized way to document other symbols, like type aliases, that could use Annotated. +* **Support** for apps using FastAPI, Typer and others. +* **AI Accessibility**: AI tools will have an easier way understanding each parameter as the distance from documentation to parameter is much closer. + +## History + +I ([@tiangolo](https://github.com/tiangolo)) originally wanted for this to be part of the Python standard library (in [PEP 727](https://peps.python.org/pep-0727/)), but the proposal was withdrawn as there was a fair amount of negative feedback and opposition. + +The conclusion was that this was better done as an external effort, in a third-party library. + +So, here it is, with a simpler approach, as a third-party library, in a way that can be used by others, starting with FastAPI and friends. + +## License + +This project is licensed under the terms of the MIT license. diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/RECORD b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/RECORD new file mode 100644 index 0000000..314d720 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/RECORD @@ -0,0 +1,11 @@ +annotated_doc-0.0.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +annotated_doc-0.0.4.dist-info/METADATA,sha256=Irm5KJua33dY2qKKAjJ-OhKaVBVIfwFGej_dSe3Z1TU,6566 +annotated_doc-0.0.4.dist-info/RECORD,, +annotated_doc-0.0.4.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90 +annotated_doc-0.0.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34 +annotated_doc-0.0.4.dist-info/licenses/LICENSE,sha256=__Fwd5pqy_ZavbQFwIfxzuF4ZpHkqWpANFF-SlBKDN8,1086 +annotated_doc/__init__.py,sha256=VuyxxUe80kfEyWnOrCx_Bk8hybo3aKo6RYBlkBBYW8k,52 +annotated_doc/__pycache__/__init__.cpython-310.pyc,, +annotated_doc/__pycache__/main.cpython-310.pyc,, +annotated_doc/main.py,sha256=5Zfvxv80SwwLqpRW73AZyZyiM4bWma9QWRbp_cgD20s,1075 +annotated_doc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/WHEEL new file mode 100644 index 0000000..045c8ac --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: pdm-backend (2.4.5) +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt new file mode 100644 index 0000000..c3ad472 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt @@ -0,0 +1,4 @@ +[console_scripts] + +[gui_scripts] + diff --git a/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE new file mode 100644 index 0000000..7a25446 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc-0.0.4.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2025 Sebastián Ramírez + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/.venv/lib/python3.10/site-packages/annotated_doc/__init__.py b/.venv/lib/python3.10/site-packages/annotated_doc/__init__.py new file mode 100644 index 0000000..a0152a7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc/__init__.py @@ -0,0 +1,3 @@ +from .main import Doc as Doc + +__version__ = "0.0.4" diff --git a/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..2501f81 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/main.cpython-310.pyc b/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/main.cpython-310.pyc new file mode 100644 index 0000000..b8adb3b Binary files /dev/null and b/.venv/lib/python3.10/site-packages/annotated_doc/__pycache__/main.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/annotated_doc/main.py b/.venv/lib/python3.10/site-packages/annotated_doc/main.py new file mode 100644 index 0000000..7063c59 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_doc/main.py @@ -0,0 +1,36 @@ +class Doc: + """Define the documentation of a type annotation using `Annotated`, to be + used in class attributes, function and method parameters, return values, + and variables. + + The value should be a positional-only string literal to allow static tools + like editors and documentation generators to use it. + + This complements docstrings. + + The string value passed is available in the attribute `documentation`. + + Example: + + ```Python + from typing import Annotated + from annotated_doc import Doc + + def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None: + print(f"Hi, {name}!") + ``` + """ + + def __init__(self, documentation: str, /) -> None: + self.documentation = documentation + + def __repr__(self) -> str: + return f"Doc({self.documentation!r})" + + def __hash__(self) -> int: + return hash(self.documentation) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Doc): + return NotImplemented + return self.documentation == other.documentation diff --git a/.venv/lib/python3.10/site-packages/annotated_doc/py.typed b/.venv/lib/python3.10/site-packages/annotated_doc/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/METADATA b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/METADATA new file mode 100644 index 0000000..3ac05cf --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/METADATA @@ -0,0 +1,295 @@ +Metadata-Version: 2.3 +Name: annotated-types +Version: 0.7.0 +Summary: Reusable constraint types to use with typing.Annotated +Project-URL: Homepage, https://github.com/annotated-types/annotated-types +Project-URL: Source, https://github.com/annotated-types/annotated-types +Project-URL: Changelog, https://github.com/annotated-types/annotated-types/releases +Author-email: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, Samuel Colvin , Zac Hatfield-Dodds +License-File: LICENSE +Classifier: Development Status :: 4 - Beta +Classifier: Environment :: Console +Classifier: Environment :: MacOS X +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Information Technology +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: POSIX :: Linux +Classifier: Operating System :: Unix +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Typing :: Typed +Requires-Python: >=3.8 +Requires-Dist: typing-extensions>=4.0.0; python_version < '3.9' +Description-Content-Type: text/markdown + +# annotated-types + +[![CI](https://github.com/annotated-types/annotated-types/workflows/CI/badge.svg?event=push)](https://github.com/annotated-types/annotated-types/actions?query=event%3Apush+branch%3Amain+workflow%3ACI) +[![pypi](https://img.shields.io/pypi/v/annotated-types.svg)](https://pypi.python.org/pypi/annotated-types) +[![versions](https://img.shields.io/pypi/pyversions/annotated-types.svg)](https://github.com/annotated-types/annotated-types) +[![license](https://img.shields.io/github/license/annotated-types/annotated-types.svg)](https://github.com/annotated-types/annotated-types/blob/main/LICENSE) + +[PEP-593](https://peps.python.org/pep-0593/) added `typing.Annotated` as a way of +adding context-specific metadata to existing types, and specifies that +`Annotated[T, x]` _should_ be treated as `T` by any tool or library without special +logic for `x`. + +This package provides metadata objects which can be used to represent common +constraints such as upper and lower bounds on scalar values and collection sizes, +a `Predicate` marker for runtime checks, and +descriptions of how we intend these metadata to be interpreted. In some cases, +we also note alternative representations which do not require this package. + +## Install + +```bash +pip install annotated-types +``` + +## Examples + +```python +from typing import Annotated +from annotated_types import Gt, Len, Predicate + +class MyClass: + age: Annotated[int, Gt(18)] # Valid: 19, 20, ... + # Invalid: 17, 18, "19", 19.0, ... + factors: list[Annotated[int, Predicate(is_prime)]] # Valid: 2, 3, 5, 7, 11, ... + # Invalid: 4, 8, -2, 5.0, "prime", ... + + my_list: Annotated[list[int], Len(0, 10)] # Valid: [], [10, 20, 30, 40, 50] + # Invalid: (1, 2), ["abc"], [0] * 20 +``` + +## Documentation + +_While `annotated-types` avoids runtime checks for performance, users should not +construct invalid combinations such as `MultipleOf("non-numeric")` or `Annotated[int, Len(3)]`. +Downstream implementors may choose to raise an error, emit a warning, silently ignore +a metadata item, etc., if the metadata objects described below are used with an +incompatible type - or for any other reason!_ + +### Gt, Ge, Lt, Le + +Express inclusive and/or exclusive bounds on orderable values - which may be numbers, +dates, times, strings, sets, etc. Note that the boundary value need not be of the +same type that was annotated, so long as they can be compared: `Annotated[int, Gt(1.5)]` +is fine, for example, and implies that the value is an integer x such that `x > 1.5`. + +We suggest that implementors may also interpret `functools.partial(operator.le, 1.5)` +as being equivalent to `Gt(1.5)`, for users who wish to avoid a runtime dependency on +the `annotated-types` package. + +To be explicit, these types have the following meanings: + +* `Gt(x)` - value must be "Greater Than" `x` - equivalent to exclusive minimum +* `Ge(x)` - value must be "Greater than or Equal" to `x` - equivalent to inclusive minimum +* `Lt(x)` - value must be "Less Than" `x` - equivalent to exclusive maximum +* `Le(x)` - value must be "Less than or Equal" to `x` - equivalent to inclusive maximum + +### Interval + +`Interval(gt, ge, lt, le)` allows you to specify an upper and lower bound with a single +metadata object. `None` attributes should be ignored, and non-`None` attributes +treated as per the single bounds above. + +### MultipleOf + +`MultipleOf(multiple_of=x)` might be interpreted in two ways: + +1. Python semantics, implying `value % multiple_of == 0`, or +2. [JSONschema semantics](https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.2.1), + where `int(value / multiple_of) == value / multiple_of`. + +We encourage users to be aware of these two common interpretations and their +distinct behaviours, especially since very large or non-integer numbers make +it easy to cause silent data corruption due to floating-point imprecision. + +We encourage libraries to carefully document which interpretation they implement. + +### MinLen, MaxLen, Len + +`Len()` implies that `min_length <= len(value) <= max_length` - lower and upper bounds are inclusive. + +As well as `Len()` which can optionally include upper and lower bounds, we also +provide `MinLen(x)` and `MaxLen(y)` which are equivalent to `Len(min_length=x)` +and `Len(max_length=y)` respectively. + +`Len`, `MinLen`, and `MaxLen` may be used with any type which supports `len(value)`. + +Examples of usage: + +* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10))`) - list must have a length of 10 or less +* `Annotated[str, MaxLen(10)]` - string must have a length of 10 or less +* `Annotated[list, MinLen(3))` (or `Annotated[list, Len(min_length=3))`) - list must have a length of 3 or more +* `Annotated[list, Len(4, 6)]` - list must have a length of 4, 5, or 6 +* `Annotated[list, Len(8, 8)]` - list must have a length of exactly 8 + +#### Changed in v0.4.0 + +* `min_inclusive` has been renamed to `min_length`, no change in meaning +* `max_exclusive` has been renamed to `max_length`, upper bound is now **inclusive** instead of **exclusive** +* The recommendation that slices are interpreted as `Len` has been removed due to ambiguity and different semantic + meaning of the upper bound in slices vs. `Len` + +See [issue #23](https://github.com/annotated-types/annotated-types/issues/23) for discussion. + +### Timezone + +`Timezone` can be used with a `datetime` or a `time` to express which timezones +are allowed. `Annotated[datetime, Timezone(None)]` must be a naive datetime. +`Timezone[...]` ([literal ellipsis](https://docs.python.org/3/library/constants.html#Ellipsis)) +expresses that any timezone-aware datetime is allowed. You may also pass a specific +timezone string or [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects) +object such as `Timezone(timezone.utc)` or `Timezone("Africa/Abidjan")` to express that you only +allow a specific timezone, though we note that this is often a symptom of fragile design. + +#### Changed in v0.x.x + +* `Timezone` accepts [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects) objects instead of + `timezone`, extending compatibility to [`zoneinfo`](https://docs.python.org/3/library/zoneinfo.html) and third party libraries. + +### Unit + +`Unit(unit: str)` expresses that the annotated numeric value is the magnitude of +a quantity with the specified unit. For example, `Annotated[float, Unit("m/s")]` +would be a float representing a velocity in meters per second. + +Please note that `annotated_types` itself makes no attempt to parse or validate +the unit string in any way. That is left entirely to downstream libraries, +such as [`pint`](https://pint.readthedocs.io) or +[`astropy.units`](https://docs.astropy.org/en/stable/units/). + +An example of how a library might use this metadata: + +```python +from annotated_types import Unit +from typing import Annotated, TypeVar, Callable, Any, get_origin, get_args + +# given a type annotated with a unit: +Meters = Annotated[float, Unit("m")] + + +# you can cast the annotation to a specific unit type with any +# callable that accepts a string and returns the desired type +T = TypeVar("T") +def cast_unit(tp: Any, unit_cls: Callable[[str], T]) -> T | None: + if get_origin(tp) is Annotated: + for arg in get_args(tp): + if isinstance(arg, Unit): + return unit_cls(arg.unit) + return None + + +# using `pint` +import pint +pint_unit = cast_unit(Meters, pint.Unit) + + +# using `astropy.units` +import astropy.units as u +astropy_unit = cast_unit(Meters, u.Unit) +``` + +### Predicate + +`Predicate(func: Callable)` expresses that `func(value)` is truthy for valid values. +Users should prefer the statically inspectable metadata above, but if you need +the full power and flexibility of arbitrary runtime predicates... here it is. + +For some common constraints, we provide generic types: + +* `IsLower = Annotated[T, Predicate(str.islower)]` +* `IsUpper = Annotated[T, Predicate(str.isupper)]` +* `IsDigit = Annotated[T, Predicate(str.isdigit)]` +* `IsFinite = Annotated[T, Predicate(math.isfinite)]` +* `IsNotFinite = Annotated[T, Predicate(Not(math.isfinite))]` +* `IsNan = Annotated[T, Predicate(math.isnan)]` +* `IsNotNan = Annotated[T, Predicate(Not(math.isnan))]` +* `IsInfinite = Annotated[T, Predicate(math.isinf)]` +* `IsNotInfinite = Annotated[T, Predicate(Not(math.isinf))]` + +so that you can write e.g. `x: IsFinite[float] = 2.0` instead of the longer +(but exactly equivalent) `x: Annotated[float, Predicate(math.isfinite)] = 2.0`. + +Some libraries might have special logic to handle known or understandable predicates, +for example by checking for `str.isdigit` and using its presence to both call custom +logic to enforce digit-only strings, and customise some generated external schema. +Users are therefore encouraged to avoid indirection like `lambda s: s.lower()`, in +favor of introspectable methods such as `str.lower` or `re.compile("pattern").search`. + +To enable basic negation of commonly used predicates like `math.isnan` without introducing introspection that makes it impossible for implementers to introspect the predicate we provide a `Not` wrapper that simply negates the predicate in an introspectable manner. Several of the predicates listed above are created in this manner. + +We do not specify what behaviour should be expected for predicates that raise +an exception. For example `Annotated[int, Predicate(str.isdigit)]` might silently +skip invalid constraints, or statically raise an error; or it might try calling it +and then propagate or discard the resulting +`TypeError: descriptor 'isdigit' for 'str' objects doesn't apply to a 'int' object` +exception. We encourage libraries to document the behaviour they choose. + +### Doc + +`doc()` can be used to add documentation information in `Annotated`, for function and method parameters, variables, class attributes, return types, and any place where `Annotated` can be used. + +It expects a value that can be statically analyzed, as the main use case is for static analysis, editors, documentation generators, and similar tools. + +It returns a `DocInfo` class with a single attribute `documentation` containing the value passed to `doc()`. + +This is the early adopter's alternative form of the [`typing-doc` proposal](https://github.com/tiangolo/fastapi/blob/typing-doc/typing_doc.md). + +### Integrating downstream types with `GroupedMetadata` + +Implementers may choose to provide a convenience wrapper that groups multiple pieces of metadata. +This can help reduce verbosity and cognitive overhead for users. +For example, an implementer like Pydantic might provide a `Field` or `Meta` type that accepts keyword arguments and transforms these into low-level metadata: + +```python +from dataclasses import dataclass +from typing import Iterator +from annotated_types import GroupedMetadata, Ge + +@dataclass +class Field(GroupedMetadata): + ge: int | None = None + description: str | None = None + + def __iter__(self) -> Iterator[object]: + # Iterating over a GroupedMetadata object should yield annotated-types + # constraint metadata objects which describe it as fully as possible, + # and may include other unknown objects too. + if self.ge is not None: + yield Ge(self.ge) + if self.description is not None: + yield Description(self.description) +``` + +Libraries consuming annotated-types constraints should check for `GroupedMetadata` and unpack it by iterating over the object and treating the results as if they had been "unpacked" in the `Annotated` type. The same logic should be applied to the [PEP 646 `Unpack` type](https://peps.python.org/pep-0646/), so that `Annotated[T, Field(...)]`, `Annotated[T, Unpack[Field(...)]]` and `Annotated[T, *Field(...)]` are all treated consistently. + +Libraries consuming annotated-types should also ignore any metadata they do not recongize that came from unpacking a `GroupedMetadata`, just like they ignore unrecognized metadata in `Annotated` itself. + +Our own `annotated_types.Interval` class is a `GroupedMetadata` which unpacks itself into `Gt`, `Lt`, etc., so this is not an abstract concern. Similarly, `annotated_types.Len` is a `GroupedMetadata` which unpacks itself into `MinLen` (optionally) and `MaxLen`. + +### Consuming metadata + +We intend to not be prescriptive as to _how_ the metadata and constraints are used, but as an example of how one might parse constraints from types annotations see our [implementation in `test_main.py`](https://github.com/annotated-types/annotated-types/blob/f59cf6d1b5255a0fe359b93896759a180bec30ae/tests/test_main.py#L94-L103). + +It is up to the implementer to determine how this metadata is used. +You could use the metadata for runtime type checking, for generating schemas or to generate example data, amongst other use cases. + +## Design & History + +This package was designed at the PyCon 2022 sprints by the maintainers of Pydantic +and Hypothesis, with the goal of making it as easy as possible for end-users to +provide more informative annotations for use by runtime libraries. + +It is deliberately minimal, and following PEP-593 allows considerable downstream +discretion in what (if anything!) they choose to support. Nonetheless, we expect +that staying simple and covering _only_ the most common use-cases will give users +and maintainers the best experience we can. If you'd like more constraints for your +types - follow our lead, by defining them and documenting them downstream! diff --git a/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/RECORD b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/RECORD new file mode 100644 index 0000000..7c37220 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/RECORD @@ -0,0 +1,10 @@ +annotated_types-0.7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +annotated_types-0.7.0.dist-info/METADATA,sha256=7ltqxksJJ0wCYFGBNIQCWTlWQGeAH0hRFdnK3CB895E,15046 +annotated_types-0.7.0.dist-info/RECORD,, +annotated_types-0.7.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87 +annotated_types-0.7.0.dist-info/licenses/LICENSE,sha256=_hBJiEsaDZNCkB6I4H8ykl0ksxIdmXK2poBfuYJLCV0,1083 +annotated_types/__init__.py,sha256=RynLsRKUEGI0KimXydlD1fZEfEzWwDo0Uon3zOKhG1Q,13819 +annotated_types/__pycache__/__init__.cpython-310.pyc,, +annotated_types/__pycache__/test_cases.cpython-310.pyc,, +annotated_types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +annotated_types/test_cases.py,sha256=zHFX6EpcMbGJ8FzBYDbO56bPwx_DYIVSKbZM-4B3_lg,6421 diff --git a/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/WHEEL new file mode 100644 index 0000000..516596c --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.24.2 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000..d99323a --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types-0.7.0.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2022 the contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/.venv/lib/python3.10/site-packages/annotated_types/__init__.py b/.venv/lib/python3.10/site-packages/annotated_types/__init__.py new file mode 100644 index 0000000..74e0dee --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types/__init__.py @@ -0,0 +1,432 @@ +import math +import sys +import types +from dataclasses import dataclass +from datetime import tzinfo +from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, SupportsFloat, SupportsIndex, TypeVar, Union + +if sys.version_info < (3, 8): + from typing_extensions import Protocol, runtime_checkable +else: + from typing import Protocol, runtime_checkable + +if sys.version_info < (3, 9): + from typing_extensions import Annotated, Literal +else: + from typing import Annotated, Literal + +if sys.version_info < (3, 10): + EllipsisType = type(Ellipsis) + KW_ONLY = {} + SLOTS = {} +else: + from types import EllipsisType + + KW_ONLY = {"kw_only": True} + SLOTS = {"slots": True} + + +__all__ = ( + 'BaseMetadata', + 'GroupedMetadata', + 'Gt', + 'Ge', + 'Lt', + 'Le', + 'Interval', + 'MultipleOf', + 'MinLen', + 'MaxLen', + 'Len', + 'Timezone', + 'Predicate', + 'LowerCase', + 'UpperCase', + 'IsDigits', + 'IsFinite', + 'IsNotFinite', + 'IsNan', + 'IsNotNan', + 'IsInfinite', + 'IsNotInfinite', + 'doc', + 'DocInfo', + '__version__', +) + +__version__ = '0.7.0' + + +T = TypeVar('T') + + +# arguments that start with __ are considered +# positional only +# see https://peps.python.org/pep-0484/#positional-only-arguments + + +class SupportsGt(Protocol): + def __gt__(self: T, __other: T) -> bool: + ... + + +class SupportsGe(Protocol): + def __ge__(self: T, __other: T) -> bool: + ... + + +class SupportsLt(Protocol): + def __lt__(self: T, __other: T) -> bool: + ... + + +class SupportsLe(Protocol): + def __le__(self: T, __other: T) -> bool: + ... + + +class SupportsMod(Protocol): + def __mod__(self: T, __other: T) -> T: + ... + + +class SupportsDiv(Protocol): + def __div__(self: T, __other: T) -> T: + ... + + +class BaseMetadata: + """Base class for all metadata. + + This exists mainly so that implementers + can do `isinstance(..., BaseMetadata)` while traversing field annotations. + """ + + __slots__ = () + + +@dataclass(frozen=True, **SLOTS) +class Gt(BaseMetadata): + """Gt(gt=x) implies that the value must be greater than x. + + It can be used with any type that supports the ``>`` operator, + including numbers, dates and times, strings, sets, and so on. + """ + + gt: SupportsGt + + +@dataclass(frozen=True, **SLOTS) +class Ge(BaseMetadata): + """Ge(ge=x) implies that the value must be greater than or equal to x. + + It can be used with any type that supports the ``>=`` operator, + including numbers, dates and times, strings, sets, and so on. + """ + + ge: SupportsGe + + +@dataclass(frozen=True, **SLOTS) +class Lt(BaseMetadata): + """Lt(lt=x) implies that the value must be less than x. + + It can be used with any type that supports the ``<`` operator, + including numbers, dates and times, strings, sets, and so on. + """ + + lt: SupportsLt + + +@dataclass(frozen=True, **SLOTS) +class Le(BaseMetadata): + """Le(le=x) implies that the value must be less than or equal to x. + + It can be used with any type that supports the ``<=`` operator, + including numbers, dates and times, strings, sets, and so on. + """ + + le: SupportsLe + + +@runtime_checkable +class GroupedMetadata(Protocol): + """A grouping of multiple objects, like typing.Unpack. + + `GroupedMetadata` on its own is not metadata and has no meaning. + All of the constraints and metadata should be fully expressable + in terms of the `BaseMetadata`'s returned by `GroupedMetadata.__iter__()`. + + Concrete implementations should override `GroupedMetadata.__iter__()` + to add their own metadata. + For example: + + >>> @dataclass + >>> class Field(GroupedMetadata): + >>> gt: float | None = None + >>> description: str | None = None + ... + >>> def __iter__(self) -> Iterable[object]: + >>> if self.gt is not None: + >>> yield Gt(self.gt) + >>> if self.description is not None: + >>> yield Description(self.gt) + + Also see the implementation of `Interval` below for an example. + + Parsers should recognize this and unpack it so that it can be used + both with and without unpacking: + + - `Annotated[int, Field(...)]` (parser must unpack Field) + - `Annotated[int, *Field(...)]` (PEP-646) + """ # noqa: trailing-whitespace + + @property + def __is_annotated_types_grouped_metadata__(self) -> Literal[True]: + return True + + def __iter__(self) -> Iterator[object]: + ... + + if not TYPE_CHECKING: + __slots__ = () # allow subclasses to use slots + + def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None: + # Basic ABC like functionality without the complexity of an ABC + super().__init_subclass__(*args, **kwargs) + if cls.__iter__ is GroupedMetadata.__iter__: + raise TypeError("Can't subclass GroupedMetadata without implementing __iter__") + + def __iter__(self) -> Iterator[object]: # noqa: F811 + raise NotImplementedError # more helpful than "None has no attribute..." type errors + + +@dataclass(frozen=True, **KW_ONLY, **SLOTS) +class Interval(GroupedMetadata): + """Interval can express inclusive or exclusive bounds with a single object. + + It accepts keyword arguments ``gt``, ``ge``, ``lt``, and/or ``le``, which + are interpreted the same way as the single-bound constraints. + """ + + gt: Union[SupportsGt, None] = None + ge: Union[SupportsGe, None] = None + lt: Union[SupportsLt, None] = None + le: Union[SupportsLe, None] = None + + def __iter__(self) -> Iterator[BaseMetadata]: + """Unpack an Interval into zero or more single-bounds.""" + if self.gt is not None: + yield Gt(self.gt) + if self.ge is not None: + yield Ge(self.ge) + if self.lt is not None: + yield Lt(self.lt) + if self.le is not None: + yield Le(self.le) + + +@dataclass(frozen=True, **SLOTS) +class MultipleOf(BaseMetadata): + """MultipleOf(multiple_of=x) might be interpreted in two ways: + + 1. Python semantics, implying ``value % multiple_of == 0``, or + 2. JSONschema semantics, where ``int(value / multiple_of) == value / multiple_of`` + + We encourage users to be aware of these two common interpretations, + and libraries to carefully document which they implement. + """ + + multiple_of: Union[SupportsDiv, SupportsMod] + + +@dataclass(frozen=True, **SLOTS) +class MinLen(BaseMetadata): + """ + MinLen() implies minimum inclusive length, + e.g. ``len(value) >= min_length``. + """ + + min_length: Annotated[int, Ge(0)] + + +@dataclass(frozen=True, **SLOTS) +class MaxLen(BaseMetadata): + """ + MaxLen() implies maximum inclusive length, + e.g. ``len(value) <= max_length``. + """ + + max_length: Annotated[int, Ge(0)] + + +@dataclass(frozen=True, **SLOTS) +class Len(GroupedMetadata): + """ + Len() implies that ``min_length <= len(value) <= max_length``. + + Upper bound may be omitted or ``None`` to indicate no upper length bound. + """ + + min_length: Annotated[int, Ge(0)] = 0 + max_length: Optional[Annotated[int, Ge(0)]] = None + + def __iter__(self) -> Iterator[BaseMetadata]: + """Unpack a Len into zone or more single-bounds.""" + if self.min_length > 0: + yield MinLen(self.min_length) + if self.max_length is not None: + yield MaxLen(self.max_length) + + +@dataclass(frozen=True, **SLOTS) +class Timezone(BaseMetadata): + """Timezone(tz=...) requires a datetime to be aware (or ``tz=None``, naive). + + ``Annotated[datetime, Timezone(None)]`` must be a naive datetime. + ``Timezone[...]`` (the ellipsis literal) expresses that the datetime must be + tz-aware but any timezone is allowed. + + You may also pass a specific timezone string or tzinfo object such as + ``Timezone(timezone.utc)`` or ``Timezone("Africa/Abidjan")`` to express that + you only allow a specific timezone, though we note that this is often + a symptom of poor design. + """ + + tz: Union[str, tzinfo, EllipsisType, None] + + +@dataclass(frozen=True, **SLOTS) +class Unit(BaseMetadata): + """Indicates that the value is a physical quantity with the specified unit. + + It is intended for usage with numeric types, where the value represents the + magnitude of the quantity. For example, ``distance: Annotated[float, Unit('m')]`` + or ``speed: Annotated[float, Unit('m/s')]``. + + Interpretation of the unit string is left to the discretion of the consumer. + It is suggested to follow conventions established by python libraries that work + with physical quantities, such as + + - ``pint`` : + - ``astropy.units``: + + For indicating a quantity with a certain dimensionality but without a specific unit + it is recommended to use square brackets, e.g. `Annotated[float, Unit('[time]')]`. + Note, however, ``annotated_types`` itself makes no use of the unit string. + """ + + unit: str + + +@dataclass(frozen=True, **SLOTS) +class Predicate(BaseMetadata): + """``Predicate(func: Callable)`` implies `func(value)` is truthy for valid values. + + Users should prefer statically inspectable metadata, but if you need the full + power and flexibility of arbitrary runtime predicates... here it is. + + We provide a few predefined predicates for common string constraints: + ``IsLower = Predicate(str.islower)``, ``IsUpper = Predicate(str.isupper)``, and + ``IsDigits = Predicate(str.isdigit)``. Users are encouraged to use methods which + can be given special handling, and avoid indirection like ``lambda s: s.lower()``. + + Some libraries might have special logic to handle certain predicates, e.g. by + checking for `str.isdigit` and using its presence to both call custom logic to + enforce digit-only strings, and customise some generated external schema. + + We do not specify what behaviour should be expected for predicates that raise + an exception. For example `Annotated[int, Predicate(str.isdigit)]` might silently + skip invalid constraints, or statically raise an error; or it might try calling it + and then propagate or discard the resulting exception. + """ + + func: Callable[[Any], bool] + + def __repr__(self) -> str: + if getattr(self.func, "__name__", "") == "": + return f"{self.__class__.__name__}({self.func!r})" + if isinstance(self.func, (types.MethodType, types.BuiltinMethodType)) and ( + namespace := getattr(self.func.__self__, "__name__", None) + ): + return f"{self.__class__.__name__}({namespace}.{self.func.__name__})" + if isinstance(self.func, type(str.isascii)): # method descriptor + return f"{self.__class__.__name__}({self.func.__qualname__})" + return f"{self.__class__.__name__}({self.func.__name__})" + + +@dataclass +class Not: + func: Callable[[Any], bool] + + def __call__(self, __v: Any) -> bool: + return not self.func(__v) + + +_StrType = TypeVar("_StrType", bound=str) + +LowerCase = Annotated[_StrType, Predicate(str.islower)] +""" +Return True if the string is a lowercase string, False otherwise. + +A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string. +""" # noqa: E501 +UpperCase = Annotated[_StrType, Predicate(str.isupper)] +""" +Return True if the string is an uppercase string, False otherwise. + +A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string. +""" # noqa: E501 +IsDigit = Annotated[_StrType, Predicate(str.isdigit)] +IsDigits = IsDigit # type: ignore # plural for backwards compatibility, see #63 +""" +Return True if the string is a digit string, False otherwise. + +A string is a digit string if all characters in the string are digits and there is at least one character in the string. +""" # noqa: E501 +IsAscii = Annotated[_StrType, Predicate(str.isascii)] +""" +Return True if all characters in the string are ASCII, False otherwise. + +ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too. +""" + +_NumericType = TypeVar('_NumericType', bound=Union[SupportsFloat, SupportsIndex]) +IsFinite = Annotated[_NumericType, Predicate(math.isfinite)] +"""Return True if x is neither an infinity nor a NaN, and False otherwise.""" +IsNotFinite = Annotated[_NumericType, Predicate(Not(math.isfinite))] +"""Return True if x is one of infinity or NaN, and False otherwise""" +IsNan = Annotated[_NumericType, Predicate(math.isnan)] +"""Return True if x is a NaN (not a number), and False otherwise.""" +IsNotNan = Annotated[_NumericType, Predicate(Not(math.isnan))] +"""Return True if x is anything but NaN (not a number), and False otherwise.""" +IsInfinite = Annotated[_NumericType, Predicate(math.isinf)] +"""Return True if x is a positive or negative infinity, and False otherwise.""" +IsNotInfinite = Annotated[_NumericType, Predicate(Not(math.isinf))] +"""Return True if x is neither a positive or negative infinity, and False otherwise.""" + +try: + from typing_extensions import DocInfo, doc # type: ignore [attr-defined] +except ImportError: + + @dataclass(frozen=True, **SLOTS) + class DocInfo: # type: ignore [no-redef] + """ " + The return value of doc(), mainly to be used by tools that want to extract the + Annotated documentation at runtime. + """ + + documentation: str + """The documentation string passed to doc().""" + + def doc( + documentation: str, + ) -> DocInfo: + """ + Add documentation to a type annotation inside of Annotated. + + For example: + + >>> def hi(name: Annotated[int, doc("The name of the user")]) -> None: ... + """ + return DocInfo(documentation) diff --git a/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..e8e57d2 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/test_cases.cpython-310.pyc b/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/test_cases.cpython-310.pyc new file mode 100644 index 0000000..5e81810 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/annotated_types/__pycache__/test_cases.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/annotated_types/py.typed b/.venv/lib/python3.10/site-packages/annotated_types/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/annotated_types/test_cases.py b/.venv/lib/python3.10/site-packages/annotated_types/test_cases.py new file mode 100644 index 0000000..d9164d6 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/annotated_types/test_cases.py @@ -0,0 +1,151 @@ +import math +import sys +from datetime import date, datetime, timedelta, timezone +from decimal import Decimal +from typing import Any, Dict, Iterable, Iterator, List, NamedTuple, Set, Tuple + +if sys.version_info < (3, 9): + from typing_extensions import Annotated +else: + from typing import Annotated + +import annotated_types as at + + +class Case(NamedTuple): + """ + A test case for `annotated_types`. + """ + + annotation: Any + valid_cases: Iterable[Any] + invalid_cases: Iterable[Any] + + +def cases() -> Iterable[Case]: + # Gt, Ge, Lt, Le + yield Case(Annotated[int, at.Gt(4)], (5, 6, 1000), (4, 0, -1)) + yield Case(Annotated[float, at.Gt(0.5)], (0.6, 0.7, 0.8, 0.9), (0.5, 0.0, -0.1)) + yield Case( + Annotated[datetime, at.Gt(datetime(2000, 1, 1))], + [datetime(2000, 1, 2), datetime(2000, 1, 3)], + [datetime(2000, 1, 1), datetime(1999, 12, 31)], + ) + yield Case( + Annotated[datetime, at.Gt(date(2000, 1, 1))], + [date(2000, 1, 2), date(2000, 1, 3)], + [date(2000, 1, 1), date(1999, 12, 31)], + ) + yield Case( + Annotated[datetime, at.Gt(Decimal('1.123'))], + [Decimal('1.1231'), Decimal('123')], + [Decimal('1.123'), Decimal('0')], + ) + + yield Case(Annotated[int, at.Ge(4)], (4, 5, 6, 1000, 4), (0, -1)) + yield Case(Annotated[float, at.Ge(0.5)], (0.5, 0.6, 0.7, 0.8, 0.9), (0.4, 0.0, -0.1)) + yield Case( + Annotated[datetime, at.Ge(datetime(2000, 1, 1))], + [datetime(2000, 1, 2), datetime(2000, 1, 3)], + [datetime(1998, 1, 1), datetime(1999, 12, 31)], + ) + + yield Case(Annotated[int, at.Lt(4)], (0, -1), (4, 5, 6, 1000, 4)) + yield Case(Annotated[float, at.Lt(0.5)], (0.4, 0.0, -0.1), (0.5, 0.6, 0.7, 0.8, 0.9)) + yield Case( + Annotated[datetime, at.Lt(datetime(2000, 1, 1))], + [datetime(1999, 12, 31), datetime(1999, 12, 31)], + [datetime(2000, 1, 2), datetime(2000, 1, 3)], + ) + + yield Case(Annotated[int, at.Le(4)], (4, 0, -1), (5, 6, 1000)) + yield Case(Annotated[float, at.Le(0.5)], (0.5, 0.0, -0.1), (0.6, 0.7, 0.8, 0.9)) + yield Case( + Annotated[datetime, at.Le(datetime(2000, 1, 1))], + [datetime(2000, 1, 1), datetime(1999, 12, 31)], + [datetime(2000, 1, 2), datetime(2000, 1, 3)], + ) + + # Interval + yield Case(Annotated[int, at.Interval(gt=4)], (5, 6, 1000), (4, 0, -1)) + yield Case(Annotated[int, at.Interval(gt=4, lt=10)], (5, 6), (4, 10, 1000, 0, -1)) + yield Case(Annotated[float, at.Interval(ge=0.5, le=1)], (0.5, 0.9, 1), (0.49, 1.1)) + yield Case( + Annotated[datetime, at.Interval(gt=datetime(2000, 1, 1), le=datetime(2000, 1, 3))], + [datetime(2000, 1, 2), datetime(2000, 1, 3)], + [datetime(2000, 1, 1), datetime(2000, 1, 4)], + ) + + yield Case(Annotated[int, at.MultipleOf(multiple_of=3)], (0, 3, 9), (1, 2, 4)) + yield Case(Annotated[float, at.MultipleOf(multiple_of=0.5)], (0, 0.5, 1, 1.5), (0.4, 1.1)) + + # lengths + + yield Case(Annotated[str, at.MinLen(3)], ('123', '1234', 'x' * 10), ('', '1', '12')) + yield Case(Annotated[str, at.Len(3)], ('123', '1234', 'x' * 10), ('', '1', '12')) + yield Case(Annotated[List[int], at.MinLen(3)], ([1, 2, 3], [1, 2, 3, 4], [1] * 10), ([], [1], [1, 2])) + yield Case(Annotated[List[int], at.Len(3)], ([1, 2, 3], [1, 2, 3, 4], [1] * 10), ([], [1], [1, 2])) + + yield Case(Annotated[str, at.MaxLen(4)], ('', '1234'), ('12345', 'x' * 10)) + yield Case(Annotated[str, at.Len(0, 4)], ('', '1234'), ('12345', 'x' * 10)) + yield Case(Annotated[List[str], at.MaxLen(4)], ([], ['a', 'bcdef'], ['a', 'b', 'c']), (['a'] * 5, ['b'] * 10)) + yield Case(Annotated[List[str], at.Len(0, 4)], ([], ['a', 'bcdef'], ['a', 'b', 'c']), (['a'] * 5, ['b'] * 10)) + + yield Case(Annotated[str, at.Len(3, 5)], ('123', '12345'), ('', '1', '12', '123456', 'x' * 10)) + yield Case(Annotated[str, at.Len(3, 3)], ('123',), ('12', '1234')) + + yield Case(Annotated[Dict[int, int], at.Len(2, 3)], [{1: 1, 2: 2}], [{}, {1: 1}, {1: 1, 2: 2, 3: 3, 4: 4}]) + yield Case(Annotated[Set[int], at.Len(2, 3)], ({1, 2}, {1, 2, 3}), (set(), {1}, {1, 2, 3, 4})) + yield Case(Annotated[Tuple[int, ...], at.Len(2, 3)], ((1, 2), (1, 2, 3)), ((), (1,), (1, 2, 3, 4))) + + # Timezone + + yield Case( + Annotated[datetime, at.Timezone(None)], [datetime(2000, 1, 1)], [datetime(2000, 1, 1, tzinfo=timezone.utc)] + ) + yield Case( + Annotated[datetime, at.Timezone(...)], [datetime(2000, 1, 1, tzinfo=timezone.utc)], [datetime(2000, 1, 1)] + ) + yield Case( + Annotated[datetime, at.Timezone(timezone.utc)], + [datetime(2000, 1, 1, tzinfo=timezone.utc)], + [datetime(2000, 1, 1), datetime(2000, 1, 1, tzinfo=timezone(timedelta(hours=6)))], + ) + yield Case( + Annotated[datetime, at.Timezone('Europe/London')], + [datetime(2000, 1, 1, tzinfo=timezone(timedelta(0), name='Europe/London'))], + [datetime(2000, 1, 1), datetime(2000, 1, 1, tzinfo=timezone(timedelta(hours=6)))], + ) + + # Quantity + + yield Case(Annotated[float, at.Unit(unit='m')], (5, 4.2), ('5m', '4.2m')) + + # predicate types + + yield Case(at.LowerCase[str], ['abc', 'foobar'], ['', 'A', 'Boom']) + yield Case(at.UpperCase[str], ['ABC', 'DEFO'], ['', 'a', 'abc', 'AbC']) + yield Case(at.IsDigit[str], ['123'], ['', 'ab', 'a1b2']) + yield Case(at.IsAscii[str], ['123', 'foo bar'], ['£100', '😊', 'whatever 👀']) + + yield Case(Annotated[int, at.Predicate(lambda x: x % 2 == 0)], [0, 2, 4], [1, 3, 5]) + + yield Case(at.IsFinite[float], [1.23], [math.nan, math.inf, -math.inf]) + yield Case(at.IsNotFinite[float], [math.nan, math.inf], [1.23]) + yield Case(at.IsNan[float], [math.nan], [1.23, math.inf]) + yield Case(at.IsNotNan[float], [1.23, math.inf], [math.nan]) + yield Case(at.IsInfinite[float], [math.inf], [math.nan, 1.23]) + yield Case(at.IsNotInfinite[float], [math.nan, 1.23], [math.inf]) + + # check stacked predicates + yield Case(at.IsInfinite[Annotated[float, at.Predicate(lambda x: x > 0)]], [math.inf], [-math.inf, 1.23, math.nan]) + + # doc + yield Case(Annotated[int, at.doc("A number")], [1, 2], []) + + # custom GroupedMetadata + class MyCustomGroupedMetadata(at.GroupedMetadata): + def __iter__(self) -> Iterator[at.Predicate]: + yield at.Predicate(lambda x: float(x).is_integer()) + + yield Case(Annotated[float, MyCustomGroupedMetadata()], [0, 2.0], [0.01, 1.5]) diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/METADATA b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/METADATA new file mode 100644 index 0000000..2de1cd5 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/METADATA @@ -0,0 +1,105 @@ +Metadata-Version: 2.4 +Name: anyio +Version: 4.13.0 +Summary: High-level concurrency and networking framework on top of asyncio or Trio +Author-email: Alex Grönholm +License-Expression: MIT +Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/ +Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html +Project-URL: Source code, https://github.com/agronholm/anyio +Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Framework :: AnyIO +Classifier: Typing :: Typed +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +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 +Requires-Python: >=3.10 +Description-Content-Type: text/x-rst +License-File: LICENSE +Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11" +Requires-Dist: idna>=2.8 +Requires-Dist: typing_extensions>=4.5; python_version < "3.13" +Provides-Extra: trio +Requires-Dist: trio>=0.32.0; extra == "trio" +Dynamic: license-file + +.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg + :target: https://github.com/agronholm/anyio/actions/workflows/test.yml + :alt: Build Status +.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master + :target: https://coveralls.io/github/agronholm/anyio?branch=master + :alt: Code Coverage +.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest + :target: https://anyio.readthedocs.io/en/latest/?badge=latest + :alt: Documentation +.. image:: https://badges.gitter.im/gitterHQ/gitter.svg + :target: https://gitter.im/python-trio/AnyIO + :alt: Gitter chat +.. image:: https://tidelift.com/badges/package/pypi/anyio + :target: https://tidelift.com/subscription/pkg/pypi-anyio + :alt: Tidelift + +AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or +Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony +with the native SC of Trio itself. + +Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or +Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full +refactoring necessary. It will blend in with the native libraries of your chosen backend. + +To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it +`here `_. + +Documentation +------------- + +View full documentation at: https://anyio.readthedocs.io/ + +Features +-------- + +AnyIO offers the following functionality: + +* Task groups (nurseries_ in trio terminology) +* High-level networking (TCP, UDP and UNIX sockets) + + * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python + 3.8) + * async/await style UDP sockets (unlike asyncio where you still have to use Transports and + Protocols) + +* A versatile API for byte streams and object streams +* Inter-task synchronization and communication (locks, conditions, events, semaphores, object + streams) +* Worker threads +* Subprocesses +* Subinterpreter support for code parallelization (on Python 3.13 and later) +* Asynchronous file I/O (using worker threads) +* Signal handling +* Asynchronous version of the functools_ module + +AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures. +It even works with the popular Hypothesis_ library. + +.. _asyncio: https://docs.python.org/3/library/asyncio.html +.. _Trio: https://github.com/python-trio/trio +.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency +.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning +.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs +.. _pytest: https://docs.pytest.org/en/latest/ +.. _functools: https://docs.python.org/3/library/functools.html +.. _Hypothesis: https://hypothesis.works/ + +Security contact information +---------------------------- + +To report a security vulnerability, please use the `Tidelift security contact`_. +Tidelift will coordinate the fix and disclosure. + +.. _Tidelift security contact: https://tidelift.com/security diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/RECORD b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/RECORD new file mode 100644 index 0000000..d4b6f84 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/RECORD @@ -0,0 +1,92 @@ +anyio-4.13.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +anyio-4.13.0.dist-info/METADATA,sha256=F0EYfiPlmTRwmJN2JktNxJg1GNnl0wHhzOWmz7pFvjM,4513 +anyio-4.13.0.dist-info/RECORD,, +anyio-4.13.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91 +anyio-4.13.0.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39 +anyio-4.13.0.dist-info/licenses/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081 +anyio-4.13.0.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6 +anyio/__init__.py,sha256=7iDVqMUprUuKNY91FuoKqayAhR-OY136YDPI6P78HHk,6170 +anyio/__pycache__/__init__.cpython-310.pyc,, +anyio/__pycache__/from_thread.cpython-310.pyc,, +anyio/__pycache__/functools.cpython-310.pyc,, +anyio/__pycache__/lowlevel.cpython-310.pyc,, +anyio/__pycache__/pytest_plugin.cpython-310.pyc,, +anyio/__pycache__/to_interpreter.cpython-310.pyc,, +anyio/__pycache__/to_process.cpython-310.pyc,, +anyio/__pycache__/to_thread.cpython-310.pyc,, +anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +anyio/_backends/__pycache__/__init__.cpython-310.pyc,, +anyio/_backends/__pycache__/_asyncio.cpython-310.pyc,, +anyio/_backends/__pycache__/_trio.cpython-310.pyc,, +anyio/_backends/_asyncio.py,sha256=kuqlg2sBUsFdgY80xSDAw60Gx_4WNCl9iSL5XlY6lCU,99476 +anyio/_backends/_trio.py,sha256=l9U-TsKRxzmTQxSMvOhn0bNeFn_iRx3Ho30jvR5Bdu0,41366 +anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +anyio/_core/__pycache__/__init__.cpython-310.pyc,, +anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc,, +anyio/_core/__pycache__/_contextmanagers.cpython-310.pyc,, +anyio/_core/__pycache__/_eventloop.cpython-310.pyc,, +anyio/_core/__pycache__/_exceptions.cpython-310.pyc,, +anyio/_core/__pycache__/_fileio.cpython-310.pyc,, +anyio/_core/__pycache__/_resources.cpython-310.pyc,, +anyio/_core/__pycache__/_signals.cpython-310.pyc,, +anyio/_core/__pycache__/_sockets.cpython-310.pyc,, +anyio/_core/__pycache__/_streams.cpython-310.pyc,, +anyio/_core/__pycache__/_subprocesses.cpython-310.pyc,, +anyio/_core/__pycache__/_synchronization.cpython-310.pyc,, +anyio/_core/__pycache__/_tasks.cpython-310.pyc,, +anyio/_core/__pycache__/_tempfile.cpython-310.pyc,, +anyio/_core/__pycache__/_testing.cpython-310.pyc,, +anyio/_core/__pycache__/_typedattr.cpython-310.pyc,, +anyio/_core/_asyncio_selector_thread.py,sha256=2PdxFM3cs02Kp6BSppbvmRT7q7asreTW5FgBxEsflBo,5626 +anyio/_core/_contextmanagers.py,sha256=YInBCabiEeS-UaP_Jdxa1CaFC71ETPW8HZTHIM8Rsc8,7215 +anyio/_core/_eventloop.py,sha256=c2EdcBX-xnKwxPcC4Pjn3_qG9I-x4IWFO2R9RqCGjM4,6448 +anyio/_core/_exceptions.py,sha256=Y3aq-Wxd7Q2HqwSg7nZPvRsHEuGazv_qeet6gqEBdPk,4407 +anyio/_core/_fileio.py,sha256=CKi1gFNiW2G4knWeBE7He7-rptQwgYjDUWfG8DSlvLs,25665 +anyio/_core/_resources.py,sha256=NbmU5O5UX3xEyACnkmYX28Fmwdl-f-ny0tHym26e0w0,435 +anyio/_core/_signals.py,sha256=mjTBB2hTKNPRlU0IhnijeQedpWOGERDiMjSlJQsFrug,1016 +anyio/_core/_sockets.py,sha256=RBXHcUqZt5gg_-OOfgHVv8uq2FSKk1uVUzTdpjBoI1o,34977 +anyio/_core/_streams.py,sha256=FczFwIgDpnkK0bODWJXMpsUJYdvAD04kaUaGzJU8DK0,1806 +anyio/_core/_subprocesses.py,sha256=tkmkPKEkEaiMD8C9WRZBlmgjOYRDRbZdte6e-unay2E,7916 +anyio/_core/_synchronization.py,sha256=9G3fvRsPNrrWJ_Z6gD_80wXq8I8qgAyhwM8PvHQnT2c,21061 +anyio/_core/_tasks.py,sha256=pVB7K6AAulzUM8YgXAeqNZG44nSyZ1bYJjH8GznC00I,5435 +anyio/_core/_tempfile.py,sha256=jE2w59FRF3yRo4vjkjfZF2YcqsBZvc66VWRwrJGDYGk,19624 +anyio/_core/_testing.py,sha256=u7MPqGXwpTxqI7hclSdNA30z2GH1Nw258uwKvy_RfBg,2340 +anyio/_core/_typedattr.py,sha256=P4ozZikn3-DbpoYcvyghS_FOYAgbmUxeoU8-L_07pZM,2508 +anyio/abc/__init__.py,sha256=6mWhcl_pGXhrgZVHP_TCfMvIXIOp9mroEFM90fYCU_U,2869 +anyio/abc/__pycache__/__init__.cpython-310.pyc,, +anyio/abc/__pycache__/_eventloop.cpython-310.pyc,, +anyio/abc/__pycache__/_resources.cpython-310.pyc,, +anyio/abc/__pycache__/_sockets.cpython-310.pyc,, +anyio/abc/__pycache__/_streams.cpython-310.pyc,, +anyio/abc/__pycache__/_subprocesses.cpython-310.pyc,, +anyio/abc/__pycache__/_tasks.cpython-310.pyc,, +anyio/abc/__pycache__/_testing.cpython-310.pyc,, +anyio/abc/_eventloop.py,sha256=39lYnmtvoHaZw22sWBKOTA_zv7bamOnr8O49PqgDXdw,10629 +anyio/abc/_resources.py,sha256=DrYvkNN1hH6Uvv5_5uKySvDsnknGVDe8FCKfko0VtN8,783 +anyio/abc/_sockets.py,sha256=OmVDrfemVvF9c5K1tpBgQyV6fn5v0XyCExLAqBOGz9o,13124 +anyio/abc/_streams.py,sha256=HYvna1iZbWcwLROTO6IhLX79RTRLPShZMWe0sG1q54I,7481 +anyio/abc/_subprocesses.py,sha256=cumAPJTktOQtw63IqG0lDpyZqu_l1EElvQHMiwJgL08,2067 +anyio/abc/_tasks.py,sha256=KC7wrciE48AINOI-AhPutnFhe1ewfP7QnamFlDzqesQ,3721 +anyio/abc/_testing.py,sha256=tBJUzkSfOXJw23fe8qSJ03kJlShOYjjaEyFB6k6MYT8,1821 +anyio/from_thread.py,sha256=L-0w1HxJ6BSb-KuVi57k5Tkc3yzQrx3QK5tAxMPcY-0,19141 +anyio/functools.py,sha256=5AWM1iYTKkTzptvUhQDdLSh5GvbBW-vcs-SAUfIfA9A,12076 +anyio/lowlevel.py,sha256=AyKLVK3LaWSoK39LkCKxE4_GDMLKZBNqTrLUgk63y80,5158 +anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +anyio/pytest_plugin.py,sha256=t6h4KJstqIxfxwTZ1YO8vpUVuB99nfCLltn0NHfatHo,12775 +anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +anyio/streams/__pycache__/__init__.cpython-310.pyc,, +anyio/streams/__pycache__/buffered.cpython-310.pyc,, +anyio/streams/__pycache__/file.cpython-310.pyc,, +anyio/streams/__pycache__/memory.cpython-310.pyc,, +anyio/streams/__pycache__/stapled.cpython-310.pyc,, +anyio/streams/__pycache__/text.cpython-310.pyc,, +anyio/streams/__pycache__/tls.cpython-310.pyc,, +anyio/streams/buffered.py,sha256=2R3PeJhe4EXrdYqz44Y6-Eg9R6DrmlsYrP36Ir43-po,6263 +anyio/streams/file.py,sha256=msnrotVKGMQomUu_Rj2qz9MvIdUp6d3JGr7MOEO8kV4,4428 +anyio/streams/memory.py,sha256=F0zwzvFJKAhX_LRZGoKzzqDC2oMM-f-yyTBrEYEGOaU,10740 +anyio/streams/stapled.py,sha256=T8Xqwf8K6EgURPxbt1N4i7A8BAk-gScv-GRhjLXIf_o,4390 +anyio/streams/text.py,sha256=BcVAGJw1VRvtIqnv-o0Rb0pwH7p8vwlvl21xHq522ag,5765 +anyio/streams/tls.py,sha256=DQVkXUvsTEYKkBO8dlVU7j_5H8QOtLy4sGi1Wrjqevo,15303 +anyio/to_interpreter.py,sha256=_mLngrMy97TMR6VbW4Y6YzDUk9ZuPcQMPlkuyRh3C9k,7100 +anyio/to_process.py,sha256=J7gAA_YOuoHqnpDAf5fm1Qu6kOmTzdFbiDNvnV755vk,9798 +anyio/to_thread.py,sha256=f6h_k2d743GBv9FhAnhM_YpTvWgIrzBy9cOE0eJ1UJw,2693 diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/WHEEL new file mode 100644 index 0000000..14a883f --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (82.0.1) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/entry_points.txt b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/entry_points.txt new file mode 100644 index 0000000..44dd9bd --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[pytest11] +anyio = anyio.pytest_plugin diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/licenses/LICENSE b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000..104eebf --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/licenses/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2018 Alex Grönholm + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/top_level.txt b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/top_level.txt new file mode 100644 index 0000000..c77c069 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio-4.13.0.dist-info/top_level.txt @@ -0,0 +1 @@ +anyio diff --git a/.venv/lib/python3.10/site-packages/anyio/__init__.py b/.venv/lib/python3.10/site-packages/anyio/__init__.py new file mode 100644 index 0000000..d23c5a5 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/__init__.py @@ -0,0 +1,111 @@ +from __future__ import annotations + +from ._core._contextmanagers import AsyncContextManagerMixin as AsyncContextManagerMixin +from ._core._contextmanagers import ContextManagerMixin as ContextManagerMixin +from ._core._eventloop import current_time as current_time +from ._core._eventloop import get_all_backends as get_all_backends +from ._core._eventloop import get_available_backends as get_available_backends +from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class +from ._core._eventloop import run as run +from ._core._eventloop import sleep as sleep +from ._core._eventloop import sleep_forever as sleep_forever +from ._core._eventloop import sleep_until as sleep_until +from ._core._exceptions import BrokenResourceError as BrokenResourceError +from ._core._exceptions import BrokenWorkerInterpreter as BrokenWorkerInterpreter +from ._core._exceptions import BrokenWorkerProcess as BrokenWorkerProcess +from ._core._exceptions import BusyResourceError as BusyResourceError +from ._core._exceptions import ClosedResourceError as ClosedResourceError +from ._core._exceptions import ConnectionFailed as ConnectionFailed +from ._core._exceptions import DelimiterNotFound as DelimiterNotFound +from ._core._exceptions import EndOfStream as EndOfStream +from ._core._exceptions import IncompleteRead as IncompleteRead +from ._core._exceptions import NoEventLoopError as NoEventLoopError +from ._core._exceptions import RunFinishedError as RunFinishedError +from ._core._exceptions import TypedAttributeLookupError as TypedAttributeLookupError +from ._core._exceptions import WouldBlock as WouldBlock +from ._core._fileio import AsyncFile as AsyncFile +from ._core._fileio import Path as Path +from ._core._fileio import open_file as open_file +from ._core._fileio import wrap_file as wrap_file +from ._core._resources import aclose_forcefully as aclose_forcefully +from ._core._signals import open_signal_receiver as open_signal_receiver +from ._core._sockets import TCPConnectable as TCPConnectable +from ._core._sockets import UNIXConnectable as UNIXConnectable +from ._core._sockets import as_connectable as as_connectable +from ._core._sockets import connect_tcp as connect_tcp +from ._core._sockets import connect_unix as connect_unix +from ._core._sockets import create_connected_udp_socket as create_connected_udp_socket +from ._core._sockets import ( + create_connected_unix_datagram_socket as create_connected_unix_datagram_socket, +) +from ._core._sockets import create_tcp_listener as create_tcp_listener +from ._core._sockets import create_udp_socket as create_udp_socket +from ._core._sockets import create_unix_datagram_socket as create_unix_datagram_socket +from ._core._sockets import create_unix_listener as create_unix_listener +from ._core._sockets import getaddrinfo as getaddrinfo +from ._core._sockets import getnameinfo as getnameinfo +from ._core._sockets import notify_closing as notify_closing +from ._core._sockets import wait_readable as wait_readable +from ._core._sockets import wait_socket_readable as wait_socket_readable +from ._core._sockets import wait_socket_writable as wait_socket_writable +from ._core._sockets import wait_writable as wait_writable +from ._core._streams import create_memory_object_stream as create_memory_object_stream +from ._core._subprocesses import open_process as open_process +from ._core._subprocesses import run_process as run_process +from ._core._synchronization import CapacityLimiter as CapacityLimiter +from ._core._synchronization import ( + CapacityLimiterStatistics as CapacityLimiterStatistics, +) +from ._core._synchronization import Condition as Condition +from ._core._synchronization import ConditionStatistics as ConditionStatistics +from ._core._synchronization import Event as Event +from ._core._synchronization import EventStatistics as EventStatistics +from ._core._synchronization import Lock as Lock +from ._core._synchronization import LockStatistics as LockStatistics +from ._core._synchronization import ResourceGuard as ResourceGuard +from ._core._synchronization import Semaphore as Semaphore +from ._core._synchronization import SemaphoreStatistics as SemaphoreStatistics +from ._core._tasks import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED +from ._core._tasks import CancelScope as CancelScope +from ._core._tasks import create_task_group as create_task_group +from ._core._tasks import current_effective_deadline as current_effective_deadline +from ._core._tasks import fail_after as fail_after +from ._core._tasks import move_on_after as move_on_after +from ._core._tempfile import NamedTemporaryFile as NamedTemporaryFile +from ._core._tempfile import SpooledTemporaryFile as SpooledTemporaryFile +from ._core._tempfile import TemporaryDirectory as TemporaryDirectory +from ._core._tempfile import TemporaryFile as TemporaryFile +from ._core._tempfile import gettempdir as gettempdir +from ._core._tempfile import gettempdirb as gettempdirb +from ._core._tempfile import mkdtemp as mkdtemp +from ._core._tempfile import mkstemp as mkstemp +from ._core._testing import TaskInfo as TaskInfo +from ._core._testing import get_current_task as get_current_task +from ._core._testing import get_running_tasks as get_running_tasks +from ._core._testing import wait_all_tasks_blocked as wait_all_tasks_blocked +from ._core._typedattr import TypedAttributeProvider as TypedAttributeProvider +from ._core._typedattr import TypedAttributeSet as TypedAttributeSet +from ._core._typedattr import typed_attribute as typed_attribute + +# Re-export imports so they look like they live directly in this package +for __value in list(locals().values()): + if getattr(__value, "__module__", "").startswith("anyio."): + __value.__module__ = __name__ + + +del __value + + +def __getattr__(attr: str) -> type[BrokenWorkerInterpreter]: + """Support deprecated aliases.""" + if attr == "BrokenWorkerIntepreter": + import warnings + + warnings.warn( + "The 'BrokenWorkerIntepreter' alias is deprecated, use 'BrokenWorkerInterpreter' instead.", + DeprecationWarning, + stacklevel=2, + ) + return BrokenWorkerInterpreter + + raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..b8fee1e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/from_thread.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/from_thread.cpython-310.pyc new file mode 100644 index 0000000..f4c62be Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/from_thread.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/functools.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/functools.cpython-310.pyc new file mode 100644 index 0000000..891dd88 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/functools.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/lowlevel.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/lowlevel.cpython-310.pyc new file mode 100644 index 0000000..b86dee9 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/lowlevel.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/pytest_plugin.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/pytest_plugin.cpython-310.pyc new file mode 100644 index 0000000..8a3bb9d Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/pytest_plugin.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_interpreter.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_interpreter.cpython-310.pyc new file mode 100644 index 0000000..a21282c Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_interpreter.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_process.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_process.cpython-310.pyc new file mode 100644 index 0000000..6a2364e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_process.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_thread.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_thread.cpython-310.pyc new file mode 100644 index 0000000..f2dd605 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/__pycache__/to_thread.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/__init__.py b/.venv/lib/python3.10/site-packages/anyio/_backends/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..8a447e9 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-310.pyc new file mode 100644 index 0000000..f7d098a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_trio.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_trio.cpython-310.pyc new file mode 100644 index 0000000..4e19a1a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_backends/__pycache__/_trio.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/_asyncio.py b/.venv/lib/python3.10/site-packages/anyio/_backends/_asyncio.py new file mode 100644 index 0000000..9f1ddc2 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_backends/_asyncio.py @@ -0,0 +1,2996 @@ +from __future__ import annotations + +import array +import asyncio +import concurrent.futures +import contextvars +import math +import os +import socket +import sys +import threading +import weakref +from asyncio import ( + AbstractEventLoop, + CancelledError, + all_tasks, + create_task, + current_task, + get_running_loop, + sleep, +) +from asyncio.base_events import _run_until_complete_cb # type: ignore[attr-defined] +from collections import OrderedDict, deque +from collections.abc import ( + AsyncGenerator, + AsyncIterator, + Awaitable, + Callable, + Collection, + Coroutine, + Iterable, + Sequence, +) +from concurrent.futures import Future +from contextlib import AbstractContextManager, suppress +from contextvars import Context, copy_context +from dataclasses import dataclass, field +from functools import partial, wraps +from inspect import ( + CORO_RUNNING, + CORO_SUSPENDED, + getcoroutinestate, + iscoroutine, +) +from io import IOBase +from os import PathLike +from queue import Queue +from signal import Signals +from socket import AddressFamily, SocketKind +from threading import Thread +from types import CodeType, TracebackType +from typing import ( + IO, + TYPE_CHECKING, + Any, + ParamSpec, + TypeVar, + cast, +) +from weakref import WeakKeyDictionary + +from .. import ( + CapacityLimiterStatistics, + EventStatistics, + LockStatistics, + TaskInfo, + abc, +) +from .._core._eventloop import ( + claim_worker_thread, + set_current_async_library, + threadlocals, +) +from .._core._exceptions import ( + BrokenResourceError, + BusyResourceError, + ClosedResourceError, + EndOfStream, + RunFinishedError, + WouldBlock, +) +from .._core._sockets import convert_ipv6_sockaddr +from .._core._streams import create_memory_object_stream +from .._core._synchronization import ( + CapacityLimiter as BaseCapacityLimiter, +) +from .._core._synchronization import Event as BaseEvent +from .._core._synchronization import Lock as BaseLock +from .._core._synchronization import ( + ResourceGuard, + SemaphoreStatistics, +) +from .._core._synchronization import Semaphore as BaseSemaphore +from .._core._tasks import CancelScope as BaseCancelScope +from ..abc import ( + AsyncBackend, + IPSockAddrType, + SocketListener, + UDPPacketType, + UNIXDatagramPacketType, +) +from ..abc._eventloop import StrOrBytesPath +from ..lowlevel import RunVar +from ..streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike +else: + FileDescriptorLike = object + +if sys.version_info >= (3, 11): + from asyncio import Runner + from typing import TypeVarTuple, Unpack +else: + import contextvars + import enum + import signal + from asyncio import coroutines, events, exceptions, tasks + + from exceptiongroup import BaseExceptionGroup + from typing_extensions import TypeVarTuple, Unpack + + class _State(enum.Enum): + CREATED = "created" + INITIALIZED = "initialized" + CLOSED = "closed" + + class Runner: + # Copied from CPython 3.11 + def __init__( + self, + *, + debug: bool | None = None, + loop_factory: Callable[[], AbstractEventLoop] | None = None, + ): + self._state = _State.CREATED + self._debug = debug + self._loop_factory = loop_factory + self._loop: AbstractEventLoop | None = None + self._context = None + self._interrupt_count = 0 + self._set_event_loop = False + + def __enter__(self) -> Runner: + self._lazy_init() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def close(self) -> None: + """Shutdown and close event loop.""" + loop = self._loop + if self._state is not _State.INITIALIZED or loop is None: + return + try: + _cancel_all_tasks(loop) + loop.run_until_complete(loop.shutdown_asyncgens()) + if hasattr(loop, "shutdown_default_executor"): + loop.run_until_complete(loop.shutdown_default_executor()) + else: + loop.run_until_complete(_shutdown_default_executor(loop)) + finally: + if self._set_event_loop: + events.set_event_loop(None) + loop.close() + self._loop = None + self._state = _State.CLOSED + + def get_loop(self) -> AbstractEventLoop: + """Return embedded event loop.""" + self._lazy_init() + return self._loop + + def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval: + """Run a coroutine inside the embedded event loop.""" + if not coroutines.iscoroutine(coro): + raise ValueError(f"a coroutine was expected, got {coro!r}") + + if events._get_running_loop() is not None: + # fail fast with short traceback + raise RuntimeError( + "Runner.run() cannot be called from a running event loop" + ) + + self._lazy_init() + + if context is None: + context = self._context + task = context.run(self._loop.create_task, coro) + + if ( + threading.current_thread() is threading.main_thread() + and signal.getsignal(signal.SIGINT) is signal.default_int_handler + ): + sigint_handler = partial(self._on_sigint, main_task=task) + try: + signal.signal(signal.SIGINT, sigint_handler) + except ValueError: + # `signal.signal` may throw if `threading.main_thread` does + # not support signals (e.g. embedded interpreter with signals + # not registered - see gh-91880) + sigint_handler = None + else: + sigint_handler = None + + self._interrupt_count = 0 + try: + return self._loop.run_until_complete(task) + except exceptions.CancelledError: + if self._interrupt_count > 0: + uncancel = getattr(task, "uncancel", None) + if uncancel is not None and uncancel() == 0: + raise KeyboardInterrupt # noqa: B904 + raise # CancelledError + finally: + if ( + sigint_handler is not None + and signal.getsignal(signal.SIGINT) is sigint_handler + ): + signal.signal(signal.SIGINT, signal.default_int_handler) + + def _lazy_init(self) -> None: + if self._state is _State.CLOSED: + raise RuntimeError("Runner is closed") + if self._state is _State.INITIALIZED: + return + if self._loop_factory is None: + self._loop = events.new_event_loop() + if not self._set_event_loop: + # Call set_event_loop only once to avoid calling + # attach_loop multiple times on child watchers + events.set_event_loop(self._loop) + self._set_event_loop = True + else: + self._loop = self._loop_factory() + if self._debug is not None: + self._loop.set_debug(self._debug) + self._context = contextvars.copy_context() + self._state = _State.INITIALIZED + + def _on_sigint(self, signum, frame, main_task: asyncio.Task) -> None: + self._interrupt_count += 1 + if self._interrupt_count == 1 and not main_task.done(): + main_task.cancel() + # wakeup loop if it is blocked by select() with long timeout + self._loop.call_soon_threadsafe(lambda: None) + return + raise KeyboardInterrupt() + + def _cancel_all_tasks(loop: AbstractEventLoop) -> None: + to_cancel = tasks.all_tasks(loop) + if not to_cancel: + return + + for task in to_cancel: + task.cancel() + + loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True)) + + for task in to_cancel: + if task.cancelled(): + continue + if task.exception() is not None: + loop.call_exception_handler( + { + "message": "unhandled exception during asyncio.run() shutdown", + "exception": task.exception(), + "task": task, + } + ) + + async def _shutdown_default_executor(loop: AbstractEventLoop) -> None: + """Schedule the shutdown of the default executor.""" + + def _do_shutdown(future: asyncio.futures.Future) -> None: + try: + loop._default_executor.shutdown(wait=True) # type: ignore[attr-defined] + loop.call_soon_threadsafe(future.set_result, None) + except Exception as ex: + loop.call_soon_threadsafe(future.set_exception, ex) + + loop._executor_shutdown_called = True + if loop._default_executor is None: + return + future = loop.create_future() + thread = threading.Thread(target=_do_shutdown, args=(future,)) + thread.start() + try: + await future + finally: + thread.join() + + +T_Retval = TypeVar("T_Retval") +T_contra = TypeVar("T_contra", contravariant=True) +PosArgsT = TypeVarTuple("PosArgsT") +P = ParamSpec("P") + +_root_task: RunVar[asyncio.Task | None] = RunVar("_root_task") + + +def find_root_task() -> asyncio.Task: + root_task = _root_task.get(None) + if root_task is not None and not root_task.done(): + return root_task + + # Look for a task that has been started via run_until_complete() + for task in all_tasks(): + if task._callbacks and not task.done(): + callbacks = [cb for cb, context in task._callbacks] + for cb in callbacks: + if ( + cb is _run_until_complete_cb + or getattr(cb, "__module__", None) == "uvloop.loop" + ): + _root_task.set(task) + return task + + # Look up the topmost task in the AnyIO task tree, if possible + task = cast(asyncio.Task, current_task()) + state = _task_states.get(task) + if state: + cancel_scope = state.cancel_scope + while cancel_scope and cancel_scope._parent_scope is not None: + cancel_scope = cancel_scope._parent_scope + + if cancel_scope is not None: + return cast(asyncio.Task, cancel_scope._host_task) + + return task + + +def get_callable_name(func: Callable) -> str: + module = getattr(func, "__module__", None) + qualname = getattr(func, "__qualname__", None) + return ".".join([x for x in (module, qualname) if x]) + + +# +# Event loop +# + +_run_vars: WeakKeyDictionary[asyncio.AbstractEventLoop, Any] = WeakKeyDictionary() + + +def _task_started(task: asyncio.Task) -> bool: + """Return ``True`` if the task has been started and has not finished.""" + # The task coro should never be None here, as we never add finished tasks to the + # task list + coro = task.get_coro() + assert coro is not None + try: + return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED) + except AttributeError: + # task coro is async_genenerator_asend https://bugs.python.org/issue37771 + raise Exception(f"Cannot determine if task {task} has started or not") from None + + +# +# Timeouts and cancellation +# + + +def is_anyio_cancellation(exc: CancelledError) -> bool: + # Sometimes third party frameworks catch a CancelledError and raise a new one, so as + # a workaround we have to look at the previous ones in __context__ too for a + # matching cancel message + while True: + if ( + exc.args + and isinstance(exc.args[0], str) + and exc.args[0].startswith("Cancelled via cancel scope ") + ): + return True + + if isinstance(exc.__context__, CancelledError): + exc = exc.__context__ + continue + + return False + + +class CancelScope(BaseCancelScope): + def __new__( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return object.__new__(cls) + + def __init__(self, deadline: float = math.inf, shield: bool = False): + self._deadline = deadline + self._shield = shield + self._parent_scope: CancelScope | None = None + self._child_scopes: set[CancelScope] = set() + self._cancel_called = False + self._cancel_reason: str | None = None + self._cancelled_caught = False + self._active = False + self._timeout_handle: asyncio.TimerHandle | None = None + self._cancel_handle: asyncio.Handle | None = None + self._tasks: set[asyncio.Task] = set() + self._host_task: asyncio.Task | None = None + if sys.version_info >= (3, 11): + self._pending_uncancellations: int | None = 0 + else: + self._pending_uncancellations = None + + def __enter__(self) -> CancelScope: + if self._active: + raise RuntimeError( + "Each CancelScope may only be used for a single 'with' block" + ) + + self._host_task = host_task = cast(asyncio.Task, current_task()) + self._tasks.add(host_task) + try: + task_state = _task_states[host_task] + except KeyError: + task_state = TaskState(None, self) + _task_states[host_task] = task_state + else: + self._parent_scope = task_state.cancel_scope + task_state.cancel_scope = self + if self._parent_scope is not None: + # If using an eager task factory, the parent scope may not even contain + # the host task + self._parent_scope._child_scopes.add(self) + self._parent_scope._tasks.discard(host_task) + + self._timeout() + self._active = True + + # Start cancelling the host task if the scope was cancelled before entering + if self._cancel_called: + self._deliver_cancellation(self) + + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + del exc_tb + + if not self._active: + raise RuntimeError("This cancel scope is not active") + if current_task() is not self._host_task: + raise RuntimeError( + "Attempted to exit cancel scope in a different task than it was " + "entered in" + ) + + assert self._host_task is not None + host_task_state = _task_states.get(self._host_task) + if host_task_state is None or host_task_state.cancel_scope is not self: + raise RuntimeError( + "Attempted to exit a cancel scope that isn't the current tasks's " + "current cancel scope" + ) + + try: + self._active = False + if self._timeout_handle: + self._timeout_handle.cancel() + self._timeout_handle = None + + self._tasks.remove(self._host_task) + if self._parent_scope is not None: + self._parent_scope._child_scopes.remove(self) + self._parent_scope._tasks.add(self._host_task) + + host_task_state.cancel_scope = self._parent_scope + + # Restart the cancellation effort in the closest visible, cancelled parent + # scope if necessary + self._restart_cancellation_in_parent() + + # We only swallow the exception iff it was an AnyIO CancelledError, either + # directly as exc_val or inside an exception group and there are no cancelled + # parent cancel scopes visible to us here + if self._cancel_called and not self._parent_cancellation_is_visible_to_us: + # For each level-cancel() call made on the host task, call uncancel() + while self._pending_uncancellations: + self._host_task.uncancel() + self._pending_uncancellations -= 1 + + # Update cancelled_caught and check for exceptions we must not swallow + if isinstance(exc_val, BaseExceptionGroup): + cancelleds_caught, remaining = exc_val.split( + lambda exc: ( + isinstance(exc, CancelledError) + and is_anyio_cancellation(exc) + ) + ) + + if cancelleds_caught is None: + return False + + self._cancelled_caught = True + + if remaining is None: + return True + + context = remaining.__context__ + try: + # Preserve __cause__ and __suppress_context__ by avoiding `raise + # ... from ...` + raise remaining + finally: + # Preserve __context__ + remaining.__context__ = context + del context + else: + if isinstance(exc_val, CancelledError) and is_anyio_cancellation( + exc_val + ): + self._cancelled_caught = True + return True + else: + return False + else: + if self._pending_uncancellations: + assert self._parent_scope is not None + assert self._parent_scope._pending_uncancellations is not None + self._parent_scope._pending_uncancellations += ( + self._pending_uncancellations + ) + self._pending_uncancellations = 0 + + return False + finally: + self._host_task = None + del exc_val + + @property + def _effectively_cancelled(self) -> bool: + cancel_scope: CancelScope | None = self + while cancel_scope is not None: + if cancel_scope._cancel_called: + return True + + if cancel_scope.shield: + return False + + cancel_scope = cancel_scope._parent_scope + + return False + + @property + def _parent_cancellation_is_visible_to_us(self) -> bool: + return ( + self._parent_scope is not None + and not self.shield + and self._parent_scope._effectively_cancelled + ) + + def _timeout(self) -> None: + if self._deadline != math.inf: + loop = get_running_loop() + if loop.time() >= self._deadline: + self.cancel("deadline exceeded") + else: + self._timeout_handle = loop.call_at(self._deadline, self._timeout) + + def _deliver_cancellation(self, origin: CancelScope) -> bool: + """ + Deliver cancellation to directly contained tasks and nested cancel scopes. + + Schedule another run at the end if we still have tasks eligible for + cancellation. + + :param origin: the cancel scope that originated the cancellation + :return: ``True`` if the delivery needs to be retried on the next cycle + + """ + should_retry = False + current = current_task() + for task in self._tasks: + should_retry = True + if task._must_cancel: # type: ignore[attr-defined] + continue + + # The task is eligible for cancellation if it has started + if task is not current and (task is self._host_task or _task_started(task)): + waiter = task._fut_waiter # type: ignore[attr-defined] + if not isinstance(waiter, asyncio.Future) or not waiter.done(): + task.cancel(origin._cancel_reason) + if ( + task is origin._host_task + and origin._pending_uncancellations is not None + ): + origin._pending_uncancellations += 1 + + # Deliver cancellation to child scopes that aren't shielded or running their own + # cancellation callbacks + for scope in self._child_scopes: + if not scope._shield and not scope.cancel_called: + should_retry = scope._deliver_cancellation(origin) or should_retry + + # Schedule another callback if there are still tasks left + if origin is self: + if should_retry: + self._cancel_handle = get_running_loop().call_soon( + self._deliver_cancellation, origin + ) + else: + self._cancel_handle = None + + return should_retry + + def _restart_cancellation_in_parent(self) -> None: + """ + Restart the cancellation effort in the closest directly cancelled parent scope. + + """ + scope = self._parent_scope + while scope is not None: + if scope._cancel_called: + if scope._cancel_handle is None: + scope._deliver_cancellation(scope) + + break + + # No point in looking beyond any shielded scope + if scope._shield: + break + + scope = scope._parent_scope + + def cancel(self, reason: str | None = None) -> None: + if not self._cancel_called: + if self._timeout_handle: + self._timeout_handle.cancel() + self._timeout_handle = None + + self._cancel_called = True + self._cancel_reason = f"Cancelled via cancel scope {id(self):x}" + if task := current_task(): + self._cancel_reason += f" by {task}" + + if reason: + self._cancel_reason += f"; reason: {reason}" + + if self._host_task is not None: + self._deliver_cancellation(self) + + @property + def deadline(self) -> float: + return self._deadline + + @deadline.setter + def deadline(self, value: float) -> None: + self._deadline = float(value) + if self._timeout_handle is not None: + self._timeout_handle.cancel() + self._timeout_handle = None + + if self._active and not self._cancel_called: + self._timeout() + + @property + def cancel_called(self) -> bool: + return self._cancel_called + + @property + def cancelled_caught(self) -> bool: + return self._cancelled_caught + + @property + def shield(self) -> bool: + return self._shield + + @shield.setter + def shield(self, value: bool) -> None: + if self._shield != value: + self._shield = value + if not value: + self._restart_cancellation_in_parent() + + +# +# Task states +# + + +class TaskState: + """ + Encapsulates auxiliary task information that cannot be added to the Task instance + itself because there are no guarantees about its implementation. + """ + + __slots__ = "parent_id", "cancel_scope", "__weakref__" + + def __init__(self, parent_id: int | None, cancel_scope: CancelScope | None): + self.parent_id = parent_id + self.cancel_scope = cancel_scope + + +_task_states: WeakKeyDictionary[asyncio.Task, TaskState] = WeakKeyDictionary() + + +# +# Task groups +# + + +class _AsyncioTaskStatus(abc.TaskStatus): + def __init__(self, future: asyncio.Future, parent_id: int): + self._future = future + self._parent_id = parent_id + + def started(self, value: T_contra | None = None) -> None: + try: + self._future.set_result(value) + except asyncio.InvalidStateError: + if not self._future.cancelled(): + raise RuntimeError( + "called 'started' twice on the same task status" + ) from None + + task = cast(asyncio.Task, current_task()) + _task_states[task].parent_id = self._parent_id + + +if sys.version_info >= (3, 12): + _eager_task_factory_code: CodeType | None = asyncio.eager_task_factory.__code__ +else: + _eager_task_factory_code = None + + +class TaskGroup(abc.TaskGroup): + def __init__(self) -> None: + self.cancel_scope: CancelScope = CancelScope() + self._active = False + self._exceptions: list[BaseException] = [] + self._tasks: set[asyncio.Task] = set() + self._on_completed_fut: asyncio.Future[None] | None = None + + async def __aenter__(self) -> TaskGroup: + self.cancel_scope.__enter__() + self._active = True + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + try: + if exc_val is not None: + self.cancel_scope.cancel() + if not isinstance(exc_val, CancelledError): + self._exceptions.append(exc_val) + + loop = get_running_loop() + try: + if self._tasks: + with CancelScope() as wait_scope: + while self._tasks: + self._on_completed_fut = loop.create_future() + + try: + await self._on_completed_fut + except CancelledError as exc: + # Shield the scope against further cancellation attempts, + # as they're not productive (#695) + wait_scope.shield = True + self.cancel_scope.cancel() + + # Set exc_val from the cancellation exception if it was + # previously unset. However, we should not replace a native + # cancellation exception with one raise by a cancel scope. + if exc_val is None or ( + isinstance(exc_val, CancelledError) + and not is_anyio_cancellation(exc) + ): + exc_val = exc + + self._on_completed_fut = None + else: + # If there are no child tasks to wait on, run at least one checkpoint + # anyway + await AsyncIOBackend.cancel_shielded_checkpoint() + + self._active = False + if self._exceptions: + # The exception that got us here should already have been + # added to self._exceptions so it's ok to break exception + # chaining and avoid adding a "During handling of above..." + # for each nesting level. + raise BaseExceptionGroup( + "unhandled errors in a TaskGroup", self._exceptions + ) from None + elif exc_val: + raise exc_val + except BaseException as exc: + if self.cancel_scope.__exit__(type(exc), exc, exc.__traceback__): + return True + + raise + + return self.cancel_scope.__exit__(exc_type, exc_val, exc_tb) + finally: + del exc_val, exc_tb, self._exceptions + + def _spawn( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + args: tuple[Unpack[PosArgsT]], + name: object, + task_status_future: asyncio.Future | None = None, + ) -> asyncio.Task: + def task_done(_task: asyncio.Task) -> None: + if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None: + asyncio.future_discard_from_awaited_by( + _task, self.cancel_scope._host_task + ) + + task_state = _task_states[_task] + assert task_state.cancel_scope is not None + assert _task in task_state.cancel_scope._tasks + task_state.cancel_scope._tasks.remove(_task) + self._tasks.remove(task) + del _task_states[_task] + + if self._on_completed_fut is not None and not self._tasks: + try: + self._on_completed_fut.set_result(None) + except asyncio.InvalidStateError: + pass + + try: + exc = _task.exception() + except CancelledError as e: + while isinstance(e.__context__, CancelledError): + e = e.__context__ + + exc = e + + if exc is not None: + # The future can only be in the cancelled state if the host task was + # cancelled, so return immediately instead of adding one more + # CancelledError to the exceptions list + if task_status_future is not None and task_status_future.cancelled(): + return + + if task_status_future is None or task_status_future.done(): + if not isinstance(exc, CancelledError): + self._exceptions.append(exc) + + if not self.cancel_scope._effectively_cancelled: + self.cancel_scope.cancel() + else: + task_status_future.set_exception(exc) + elif task_status_future is not None and not task_status_future.done(): + task_status_future.set_exception( + RuntimeError("Child exited without calling task_status.started()") + ) + + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + kwargs = {} + if task_status_future: + parent_id = id(current_task()) + kwargs["task_status"] = _AsyncioTaskStatus( + task_status_future, id(self.cancel_scope._host_task) + ) + else: + parent_id = id(self.cancel_scope._host_task) + + coro = func(*args, **kwargs) + if not iscoroutine(coro): + prefix = f"{func.__module__}." if hasattr(func, "__module__") else "" + raise TypeError( + f"Expected {prefix}{func.__qualname__}() to return a coroutine, but " + f"the return value ({coro!r}) is not a coroutine object" + ) + + name = get_callable_name(func) if name is None else str(name) + loop = asyncio.get_running_loop() + if ( + (factory := loop.get_task_factory()) + and getattr(factory, "__code__", None) is _eager_task_factory_code + and (closure := getattr(factory, "__closure__", None)) + ): + custom_task_constructor = closure[0].cell_contents + task = custom_task_constructor(coro, loop=loop, name=name) + else: + task = create_task(coro, name=name) + + # Make the spawned task inherit the task group's cancel scope + _task_states[task] = TaskState( + parent_id=parent_id, cancel_scope=self.cancel_scope + ) + self.cancel_scope._tasks.add(task) + self._tasks.add(task) + if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None: + asyncio.future_add_to_awaited_by(task, self.cancel_scope._host_task) + + task.add_done_callback(task_done) + return task + + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + self._spawn(func, args, name) + + async def start( + self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None + ) -> Any: + future: asyncio.Future = asyncio.Future() + task = self._spawn(func, args, name, future) + + # If the task raises an exception after sending a start value without a switch + # point between, the task group is cancelled and this method never proceeds to + # process the completed future. That's why we have to have a shielded cancel + # scope here. + try: + return await future + except CancelledError: + # Cancel the task and wait for it to exit before returning + task.cancel() + with CancelScope(shield=True), suppress(CancelledError): + await task + + raise + + +# +# Threads +# + +_Retval_Queue_Type = tuple[T_Retval | None, BaseException | None] + + +class WorkerThread(Thread): + MAX_IDLE_TIME = 10 # seconds + + def __init__( + self, + root_task: asyncio.Task, + workers: set[WorkerThread], + idle_workers: deque[WorkerThread], + ): + super().__init__(name="AnyIO worker thread") + self.root_task = root_task + self.workers = workers + self.idle_workers = idle_workers + self.loop = root_task._loop + self.queue: Queue[ + tuple[Context, Callable, tuple, asyncio.Future, CancelScope] | None + ] = Queue(2) + self.idle_since = AsyncIOBackend.current_time() + self.stopping = False + + def _report_result( + self, future: asyncio.Future, result: Any, exc: BaseException | None + ) -> None: + self.idle_since = AsyncIOBackend.current_time() + if not self.stopping: + self.idle_workers.append(self) + + if not future.cancelled(): + if exc is not None: + if isinstance(exc, StopIteration): + new_exc = RuntimeError("coroutine raised StopIteration") + new_exc.__cause__ = exc + exc = new_exc + + future.set_exception(exc) + else: + future.set_result(result) + + def run(self) -> None: + with claim_worker_thread(AsyncIOBackend, self.loop): + while True: + item = self.queue.get() + if item is None: + # Shutdown command received + return + + context, func, args, future, cancel_scope = item + if not future.cancelled(): + result = None + exception: BaseException | None = None + threadlocals.current_cancel_scope = cancel_scope + try: + result = context.run(func, *args) + except BaseException as exc: + exception = exc + finally: + del threadlocals.current_cancel_scope + + if not self.loop.is_closed(): + self.loop.call_soon_threadsafe( + self._report_result, future, result, exception + ) + + del result, exception + + self.queue.task_done() + del item, context, func, args, future, cancel_scope + + def stop(self, f: asyncio.Task | None = None) -> None: + self.stopping = True + self.queue.put_nowait(None) + self.workers.discard(self) + try: + self.idle_workers.remove(self) + except ValueError: + pass + + +_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar( + "_threadpool_idle_workers" +) +_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers") + + +# +# Subprocesses +# + + +@dataclass(eq=False) +class StreamReaderWrapper(abc.ByteReceiveStream): + _stream: asyncio.StreamReader + + async def receive(self, max_bytes: int = 65536) -> bytes: + data = await self._stream.read(max_bytes) + if data: + return data + else: + raise EndOfStream + + async def aclose(self) -> None: + self._stream.set_exception(ClosedResourceError()) + await AsyncIOBackend.checkpoint() + + +@dataclass(eq=False) +class StreamWriterWrapper(abc.ByteSendStream): + _stream: asyncio.StreamWriter + _closed: bool = field(init=False, default=False) + + async def send(self, item: bytes) -> None: + await AsyncIOBackend.checkpoint_if_cancelled() + stream_paused = self._stream._protocol._paused # type: ignore[attr-defined] + try: + self._stream.write(item) + await self._stream.drain() + except (ConnectionResetError, BrokenPipeError, RuntimeError) as exc: + # If closed by us and/or the peer: + # * on stdlib, drain() raises ConnectionResetError or BrokenPipeError + # * on uvloop and Winloop, write() eventually starts raising RuntimeError + if self._closed: + raise ClosedResourceError from exc + elif self._stream.is_closing(): + raise BrokenResourceError from exc + + raise + + if not stream_paused: + await AsyncIOBackend.cancel_shielded_checkpoint() + + async def aclose(self) -> None: + self._closed = True + self._stream.close() + await AsyncIOBackend.checkpoint() + + +@dataclass(eq=False) +class Process(abc.Process): + _process: asyncio.subprocess.Process + _stdin: StreamWriterWrapper | None + _stdout: StreamReaderWrapper | None + _stderr: StreamReaderWrapper | None + + async def aclose(self) -> None: + with CancelScope(shield=True) as scope: + if self._stdin: + await self._stdin.aclose() + if self._stdout: + await self._stdout.aclose() + if self._stderr: + await self._stderr.aclose() + + scope.shield = False + try: + await self.wait() + except BaseException: + scope.shield = True + self.kill() + await self.wait() + raise + + async def wait(self) -> int: + return await self._process.wait() + + def terminate(self) -> None: + self._process.terminate() + + def kill(self) -> None: + self._process.kill() + + def send_signal(self, signal: int) -> None: + self._process.send_signal(signal) + + @property + def pid(self) -> int: + return self._process.pid + + @property + def returncode(self) -> int | None: + return self._process.returncode + + @property + def stdin(self) -> abc.ByteSendStream | None: + return self._stdin + + @property + def stdout(self) -> abc.ByteReceiveStream | None: + return self._stdout + + @property + def stderr(self) -> abc.ByteReceiveStream | None: + return self._stderr + + +def _forcibly_shutdown_process_pool_on_exit( + workers: set[Process], _task: object +) -> None: + """ + Forcibly shuts down worker processes belonging to this event loop.""" + child_watcher: asyncio.AbstractChildWatcher | None = None # type: ignore[name-defined] + if sys.version_info < (3, 12): + try: + child_watcher = asyncio.get_event_loop_policy().get_child_watcher() + except NotImplementedError: + pass + + # Close as much as possible (w/o async/await) to avoid warnings + for process in workers.copy(): + if process.returncode is not None: + continue + + process._stdin._stream._transport.close() # type: ignore[union-attr] + process._stdout._stream._transport.close() # type: ignore[union-attr] + process._stderr._stream._transport.close() # type: ignore[union-attr] + process.kill() + if child_watcher: + child_watcher.remove_child_handler(process.pid) + + +async def _shutdown_process_pool_on_exit(workers: set[abc.Process]) -> None: + """ + Shuts down worker processes belonging to this event loop. + + NOTE: this only works when the event loop was started using asyncio.run() or + anyio.run(). + + """ + process: abc.Process + try: + await sleep(math.inf) + except asyncio.CancelledError: + workers = workers.copy() + for process in workers: + if process.returncode is None: + process.kill() + + for process in workers: + await process.aclose() + + +# +# Sockets and networking +# + + +class StreamProtocol(asyncio.Protocol): + read_queue: deque[bytes] + read_event: asyncio.Event + write_event: asyncio.Event + exception: Exception | None = None + is_at_eof: bool = False + + def connection_made(self, transport: asyncio.BaseTransport) -> None: + self.read_queue = deque() + self.read_event = asyncio.Event() + self.write_event = asyncio.Event() + self.write_event.set() + cast(asyncio.Transport, transport).set_write_buffer_limits(0) + + def connection_lost(self, exc: Exception | None) -> None: + if exc: + self.exception = exc + + self.read_event.set() + self.write_event.set() + + def data_received(self, data: bytes) -> None: + # ProactorEventloop sometimes sends bytearray instead of bytes + self.read_queue.append(bytes(data)) + self.read_event.set() + + def eof_received(self) -> bool | None: + self.is_at_eof = True + self.read_event.set() + return True + + def pause_writing(self) -> None: + self.write_event = asyncio.Event() + + def resume_writing(self) -> None: + self.write_event.set() + + +class DatagramProtocol(asyncio.DatagramProtocol): + read_queue: deque[tuple[bytes, IPSockAddrType]] + read_event: asyncio.Event + write_event: asyncio.Event + exception: Exception | None = None + + def connection_made(self, transport: asyncio.BaseTransport) -> None: + self.read_queue = deque(maxlen=100) # arbitrary value + self.read_event = asyncio.Event() + self.write_event = asyncio.Event() + self.write_event.set() + + def connection_lost(self, exc: Exception | None) -> None: + self.read_event.set() + self.write_event.set() + + def datagram_received(self, data: bytes, addr: IPSockAddrType) -> None: + addr = convert_ipv6_sockaddr(addr) + self.read_queue.append((data, addr)) + self.read_event.set() + + def error_received(self, exc: Exception) -> None: + self.exception = exc + + def pause_writing(self) -> None: + self.write_event.clear() + + def resume_writing(self) -> None: + self.write_event.set() + + +class SocketStream(abc.SocketStream): + def __init__(self, transport: asyncio.Transport, protocol: StreamProtocol): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def receive(self, max_bytes: int = 65536) -> bytes: + with self._receive_guard: + if ( + not self._protocol.read_event.is_set() + and not self._transport.is_closing() + and not self._protocol.is_at_eof + ): + self._transport.resume_reading() + await self._protocol.read_event.wait() + self._transport.pause_reading() + else: + await AsyncIOBackend.checkpoint() + + try: + chunk = self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + elif self._protocol.exception: + raise BrokenResourceError from self._protocol.exception + else: + raise EndOfStream from None + + if len(chunk) > max_bytes: + # Split the oversized chunk + chunk, leftover = chunk[:max_bytes], chunk[max_bytes:] + self._protocol.read_queue.appendleft(leftover) + + # If the read queue is empty, clear the flag so that the next call will + # block until data is available + if not self._protocol.read_queue: + self._protocol.read_event.clear() + + return chunk + + async def send(self, item: bytes) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + + if self._closed: + raise ClosedResourceError + elif self._protocol.exception is not None: + raise BrokenResourceError from self._protocol.exception + + try: + self._transport.write(item) + except RuntimeError as exc: + if self._transport.is_closing(): + raise BrokenResourceError from exc + else: + raise + + await self._protocol.write_event.wait() + + async def send_eof(self) -> None: + try: + self._transport.write_eof() + except OSError: + pass + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + try: + self._transport.write_eof() + except OSError: + pass + + self._transport.close() + await sleep(0) + self._transport.abort() + + +class _RawSocketMixin: + _receive_future: asyncio.Future | None = None + _send_future: asyncio.Future | None = None + _closing = False + + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + def _wait_until_readable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future: + def callback(f: object) -> None: + del self._receive_future + loop.remove_reader(self.__raw_socket) + + f = self._receive_future = asyncio.Future() + loop.add_reader(self.__raw_socket, f.set_result, None) + f.add_done_callback(callback) + return f + + def _wait_until_writable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future: + def callback(f: object) -> None: + del self._send_future + loop.remove_writer(self.__raw_socket) + + f = self._send_future = asyncio.Future() + loop.add_writer(self.__raw_socket, f.set_result, None) + f.add_done_callback(callback) + return f + + async def aclose(self) -> None: + if not self._closing: + self._closing = True + if self.__raw_socket.fileno() != -1: + self.__raw_socket.close() + + if self._receive_future: + self._receive_future.set_result(None) + if self._send_future: + self._send_future.set_result(None) + + +class UNIXSocketStream(_RawSocketMixin, abc.UNIXSocketStream): + async def send_eof(self) -> None: + with self._send_guard: + self._raw_socket.shutdown(socket.SHUT_WR) + + async def receive(self, max_bytes: int = 65536) -> bytes: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recv(max_bytes) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + if not data: + raise EndOfStream + + return data + + async def send(self, item: bytes) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + view = memoryview(item) + while view: + try: + bytes_sent = self._raw_socket.send(view) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + view = view[bytes_sent:] + + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + if not isinstance(msglen, int) or msglen < 0: + raise ValueError("msglen must be a non-negative integer") + if not isinstance(maxfds, int) or maxfds < 1: + raise ValueError("maxfds must be a positive integer") + + loop = get_running_loop() + fds = array.array("i") + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + message, ancdata, flags, addr = self._raw_socket.recvmsg( + msglen, socket.CMSG_LEN(maxfds * fds.itemsize) + ) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + if not message and not ancdata: + raise EndOfStream + + break + + for cmsg_level, cmsg_type, cmsg_data in ancdata: + if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS: + raise RuntimeError( + f"Received unexpected ancillary data; message = {message!r}, " + f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}" + ) + + fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)]) + + return message, list(fds) + + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + if not message: + raise ValueError("message must not be empty") + if not fds: + raise ValueError("fds must not be empty") + + loop = get_running_loop() + filenos: list[int] = [] + for fd in fds: + if isinstance(fd, int): + filenos.append(fd) + elif isinstance(fd, IOBase): + filenos.append(fd.fileno()) + + fdarray = array.array("i", filenos) + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + # The ignore can be removed after mypy picks up + # https://github.com/python/typeshed/pull/5545 + self._raw_socket.sendmsg( + [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)] + ) + break + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + + +class TCPSocketListener(abc.SocketListener): + _accept_scope: CancelScope | None = None + _closed = False + + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._loop = cast(asyncio.BaseEventLoop, get_running_loop()) + self._accept_guard = ResourceGuard("accepting connections from") + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + async def accept(self) -> abc.SocketStream: + if self._closed: + raise ClosedResourceError + + with self._accept_guard: + await AsyncIOBackend.checkpoint() + with CancelScope() as self._accept_scope: + try: + client_sock, _addr = await self._loop.sock_accept(self._raw_socket) + except asyncio.CancelledError: + # Workaround for https://bugs.python.org/issue41317 + try: + self._loop.remove_reader(self._raw_socket) + except (ValueError, NotImplementedError): + pass + + if self._closed: + raise ClosedResourceError from None + + raise + finally: + self._accept_scope = None + + client_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + transport, protocol = await self._loop.connect_accepted_socket( + StreamProtocol, client_sock + ) + return SocketStream(transport, protocol) + + async def aclose(self) -> None: + if self._closed: + return + + self._closed = True + if self._accept_scope: + # Workaround for https://bugs.python.org/issue41317 + try: + self._loop.remove_reader(self._raw_socket) + except (ValueError, NotImplementedError): + pass + + self._accept_scope.cancel() + await sleep(0) + + self._raw_socket.close() + + +class UNIXSocketListener(abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + self.__raw_socket = raw_socket + self._loop = get_running_loop() + self._accept_guard = ResourceGuard("accepting connections from") + self._closed = False + + async def accept(self) -> abc.SocketStream: + await AsyncIOBackend.checkpoint() + with self._accept_guard: + while True: + try: + client_sock, _ = self.__raw_socket.accept() + client_sock.setblocking(False) + return UNIXSocketStream(client_sock) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + self._loop.add_reader(self.__raw_socket, f.set_result, None) + f.add_done_callback( + lambda _: self._loop.remove_reader(self.__raw_socket) + ) + await f + except OSError as exc: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + + async def aclose(self) -> None: + self._closed = True + self.__raw_socket.close() + + @property + def _raw_socket(self) -> socket.socket: + return self.__raw_socket + + +class UDPSocket(abc.UDPSocket): + def __init__( + self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol + ): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + self._transport.close() + + async def receive(self) -> tuple[bytes, IPSockAddrType]: + with self._receive_guard: + await AsyncIOBackend.checkpoint() + + # If the buffer is empty, ask for more data + if not self._protocol.read_queue and not self._transport.is_closing(): + self._protocol.read_event.clear() + await self._protocol.read_event.wait() + + try: + return self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from None + + async def send(self, item: UDPPacketType) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + await self._protocol.write_event.wait() + if self._closed: + raise ClosedResourceError + elif self._transport.is_closing(): + raise BrokenResourceError + else: + self._transport.sendto(*item) + + +class ConnectedUDPSocket(abc.ConnectedUDPSocket): + def __init__( + self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol + ): + self._transport = transport + self._protocol = protocol + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + self._closed = False + + @property + def _raw_socket(self) -> socket.socket: + return self._transport.get_extra_info("socket") + + async def aclose(self) -> None: + self._closed = True + if not self._transport.is_closing(): + self._transport.close() + + async def receive(self) -> bytes: + with self._receive_guard: + await AsyncIOBackend.checkpoint() + + # If the buffer is empty, ask for more data + if not self._protocol.read_queue and not self._transport.is_closing(): + self._protocol.read_event.clear() + await self._protocol.read_event.wait() + + try: + packet = self._protocol.read_queue.popleft() + except IndexError: + if self._closed: + raise ClosedResourceError from None + else: + raise BrokenResourceError from None + + return packet[0] + + async def send(self, item: bytes) -> None: + with self._send_guard: + await AsyncIOBackend.checkpoint() + await self._protocol.write_event.wait() + if self._closed: + raise ClosedResourceError + elif self._transport.is_closing(): + raise BrokenResourceError + else: + self._transport.sendto(item) + + +class UNIXDatagramSocket(_RawSocketMixin, abc.UNIXDatagramSocket): + async def receive(self) -> UNIXDatagramPacketType: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recvfrom(65536) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return data + + async def send(self, item: UNIXDatagramPacketType) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + self._raw_socket.sendto(*item) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return + + +class ConnectedUNIXDatagramSocket(_RawSocketMixin, abc.ConnectedUNIXDatagramSocket): + async def receive(self) -> bytes: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._receive_guard: + while True: + try: + data = self._raw_socket.recv(65536) + except BlockingIOError: + await self._wait_until_readable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return data + + async def send(self, item: bytes) -> None: + loop = get_running_loop() + await AsyncIOBackend.checkpoint() + with self._send_guard: + while True: + try: + self._raw_socket.send(item) + except BlockingIOError: + await self._wait_until_writable(loop) + except OSError as exc: + if self._closing: + raise ClosedResourceError from None + else: + raise BrokenResourceError from exc + else: + return + + +_read_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("read_events") +_write_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("write_events") + + +# +# Synchronization +# + + +class Event(BaseEvent): + def __new__(cls) -> Event: + return object.__new__(cls) + + def __init__(self) -> None: + self._event = asyncio.Event() + + def set(self) -> None: + self._event.set() + + def is_set(self) -> bool: + return self._event.is_set() + + async def wait(self) -> None: + if self.is_set(): + await AsyncIOBackend.checkpoint() + else: + await self._event.wait() + + def statistics(self) -> EventStatistics: + return EventStatistics(len(self._event._waiters)) + + +class Lock(BaseLock): + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False) -> None: + self._fast_acquire = fast_acquire + self._owner_task: asyncio.Task | None = None + self._waiters: deque[tuple[asyncio.Task, asyncio.Future]] = deque() + + async def acquire(self) -> None: + task = cast(asyncio.Task, current_task()) + if self._owner_task is None and not self._waiters: + await AsyncIOBackend.checkpoint_if_cancelled() + self._owner_task = task + + # Unless on the "fast path", yield control of the event loop so that other + # tasks can run too + if not self._fast_acquire: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except CancelledError: + self.release() + raise + + return + + if self._owner_task == task: + raise RuntimeError("Attempted to acquire an already held Lock") + + fut: asyncio.Future[None] = asyncio.Future() + item = task, fut + self._waiters.append(item) + try: + await fut + except CancelledError: + self._waiters.remove(item) + if self._owner_task is task: + self.release() + + raise + + self._waiters.remove(item) + + def acquire_nowait(self) -> None: + task = cast(asyncio.Task, current_task()) + if self._owner_task is None and not self._waiters: + self._owner_task = task + return + + if self._owner_task is task: + raise RuntimeError("Attempted to acquire an already held Lock") + + raise WouldBlock + + def locked(self) -> bool: + return self._owner_task is not None + + def release(self) -> None: + if self._owner_task != current_task(): + raise RuntimeError("The current task is not holding this lock") + + for task, fut in self._waiters: + if not fut.cancelled(): + self._owner_task = task + fut.set_result(None) + return + + self._owner_task = None + + def statistics(self) -> LockStatistics: + task_info = AsyncIOTaskInfo(self._owner_task) if self._owner_task else None + return LockStatistics(self.locked(), task_info, len(self._waiters)) + + +class Semaphore(BaseSemaphore): + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ): + super().__init__(initial_value, max_value=max_value) + self._value = initial_value + self._max_value = max_value + self._fast_acquire = fast_acquire + self._waiters: deque[asyncio.Future[None]] = deque() + + async def acquire(self) -> None: + if self._value > 0 and not self._waiters: + await AsyncIOBackend.checkpoint_if_cancelled() + self._value -= 1 + + # Unless on the "fast path", yield control of the event loop so that other + # tasks can run too + if not self._fast_acquire: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except CancelledError: + self.release() + raise + + return + + fut: asyncio.Future[None] = asyncio.Future() + self._waiters.append(fut) + try: + await fut + except CancelledError: + try: + self._waiters.remove(fut) + except ValueError: + self.release() + + raise + + def acquire_nowait(self) -> None: + if self._value == 0: + raise WouldBlock + + self._value -= 1 + + def release(self) -> None: + if self._max_value is not None and self._value == self._max_value: + raise ValueError("semaphore released too many times") + + for fut in self._waiters: + if not fut.cancelled(): + fut.set_result(None) + self._waiters.remove(fut) + return + + self._value += 1 + + @property + def value(self) -> int: + return self._value + + @property + def max_value(self) -> int | None: + return self._max_value + + def statistics(self) -> SemaphoreStatistics: + return SemaphoreStatistics(len(self._waiters)) + + +class CapacityLimiter(BaseCapacityLimiter): + _total_tokens: float = 0 + + def __new__(cls, total_tokens: float) -> CapacityLimiter: + return object.__new__(cls) + + def __init__(self, total_tokens: float): + self._borrowers: set[Any] = set() + self._wait_queue: OrderedDict[Any, asyncio.Event] = OrderedDict() + self.total_tokens = total_tokens + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + @property + def total_tokens(self) -> float: + return self._total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + if not isinstance(value, int) and not math.isinf(value): + raise TypeError("total_tokens must be an int or math.inf") + + if value < 0: + raise ValueError("total_tokens must be >= 0") + + waiters_to_notify = max(value - self._total_tokens, 0) + self._total_tokens = value + + # Notify waiting tasks that they have acquired the limiter + while self._wait_queue and waiters_to_notify: + event = self._wait_queue.popitem(last=False)[1] + event.set() + waiters_to_notify -= 1 + + @property + def borrowed_tokens(self) -> int: + return len(self._borrowers) + + @property + def available_tokens(self) -> float: + return self._total_tokens - len(self._borrowers) + + def _notify_next_waiter(self) -> None: + """Notify the next task in line if this limiter has free capacity now.""" + if self._wait_queue and len(self._borrowers) < self._total_tokens: + event = self._wait_queue.popitem(last=False)[1] + event.set() + + def acquire_nowait(self) -> None: + self.acquire_on_behalf_of_nowait(current_task()) + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + if borrower in self._borrowers: + raise RuntimeError( + "this borrower is already holding one of this CapacityLimiter's tokens" + ) + + if self._wait_queue or len(self._borrowers) >= self._total_tokens: + raise WouldBlock + + self._borrowers.add(borrower) + + async def acquire(self) -> None: + return await self.acquire_on_behalf_of(current_task()) + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await AsyncIOBackend.checkpoint_if_cancelled() + try: + self.acquire_on_behalf_of_nowait(borrower) + except WouldBlock: + event = asyncio.Event() + self._wait_queue[borrower] = event + try: + await event.wait() + except BaseException: + self._wait_queue.pop(borrower, None) + if event.is_set(): + self._notify_next_waiter() + + raise + + self._borrowers.add(borrower) + else: + try: + await AsyncIOBackend.cancel_shielded_checkpoint() + except BaseException: + self.release() + raise + + def release(self) -> None: + self.release_on_behalf_of(current_task()) + + def release_on_behalf_of(self, borrower: object) -> None: + try: + self._borrowers.remove(borrower) + except KeyError: + raise RuntimeError( + "this borrower isn't holding any of this CapacityLimiter's tokens" + ) from None + + self._notify_next_waiter() + + def statistics(self) -> CapacityLimiterStatistics: + return CapacityLimiterStatistics( + self.borrowed_tokens, + self.total_tokens, + tuple(self._borrowers), + len(self._wait_queue), + ) + + +_default_thread_limiter: RunVar[CapacityLimiter] = RunVar("_default_thread_limiter") + + +# +# Operating system signals +# + + +class _SignalReceiver: + def __init__(self, signals: tuple[Signals, ...]): + self._signals = signals + self._loop = get_running_loop() + self._signal_queue: deque[Signals] = deque() + self._future: asyncio.Future = asyncio.Future() + self._handled_signals: set[Signals] = set() + + def _deliver(self, signum: Signals) -> None: + self._signal_queue.append(signum) + if not self._future.done(): + self._future.set_result(None) + + def __enter__(self) -> _SignalReceiver: + for sig in set(self._signals): + self._loop.add_signal_handler(sig, self._deliver, sig) + self._handled_signals.add(sig) + + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + for sig in self._handled_signals: + self._loop.remove_signal_handler(sig) + + def __aiter__(self) -> _SignalReceiver: + return self + + async def __anext__(self) -> Signals: + await AsyncIOBackend.checkpoint() + if not self._signal_queue: + self._future = asyncio.Future() + await self._future + + return self._signal_queue.popleft() + + +# +# Testing and debugging +# + + +class AsyncIOTaskInfo(TaskInfo): + def __init__(self, task: asyncio.Task): + task_state = _task_states.get(task) + if task_state is None: + parent_id = None + else: + parent_id = task_state.parent_id + + coro = task.get_coro() + assert coro is not None, "created TaskInfo from a completed Task" + super().__init__(id(task), parent_id, task.get_name(), coro) + self._task = weakref.ref(task) + + def has_pending_cancellation(self) -> bool: + if not (task := self._task()): + # If the task isn't around anymore, it won't have a pending cancellation + return False + + if task._must_cancel: # type: ignore[attr-defined] + return True + elif ( + isinstance(task._fut_waiter, asyncio.Future) # type: ignore[attr-defined] + and task._fut_waiter.cancelled() # type: ignore[attr-defined] + ): + return True + + if task_state := _task_states.get(task): + if cancel_scope := task_state.cancel_scope: + return cancel_scope._effectively_cancelled + + return False + + +class TestRunner(abc.TestRunner): + _send_stream: MemoryObjectSendStream[tuple[Awaitable[Any], asyncio.Future[Any]]] + + def __init__( + self, + *, + debug: bool | None = None, + use_uvloop: bool = False, + loop_factory: Callable[[], AbstractEventLoop] | None = None, + ) -> None: + if use_uvloop and loop_factory is None: + if sys.platform != "win32": + import uvloop + + loop_factory = uvloop.new_event_loop + else: + import winloop + + loop_factory = winloop.new_event_loop + + self._runner = Runner(debug=debug, loop_factory=loop_factory) + self._exceptions: list[BaseException] = [] + self._runner_task: asyncio.Task | None = None + + def __enter__(self) -> TestRunner: + self._runner.__enter__() + self.get_loop().set_exception_handler(self._exception_handler) + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self._runner.__exit__(exc_type, exc_val, exc_tb) + + def get_loop(self) -> AbstractEventLoop: + return self._runner.get_loop() + + def _exception_handler( + self, loop: asyncio.AbstractEventLoop, context: dict[str, Any] + ) -> None: + if isinstance(context.get("exception"), Exception): + self._exceptions.append(context["exception"]) + else: + loop.default_exception_handler(context) + + def _raise_async_exceptions(self) -> None: + # Re-raise any exceptions raised in asynchronous callbacks + if self._exceptions: + exceptions, self._exceptions = self._exceptions, [] + if len(exceptions) == 1: + raise exceptions[0] + elif exceptions: + raise BaseExceptionGroup( + "Multiple exceptions occurred in asynchronous callbacks", exceptions + ) + + async def _run_tests_and_fixtures( + self, + receive_stream: MemoryObjectReceiveStream[ + tuple[Awaitable[T_Retval], asyncio.Future[T_Retval]] + ], + ) -> None: + from _pytest.outcomes import OutcomeException + + with receive_stream, self._send_stream: + async for coro, future in receive_stream: + try: + retval = await coro + except CancelledError as exc: + if not future.cancelled(): + future.cancel(*exc.args) + + raise + except BaseException as exc: + if not future.cancelled(): + future.set_exception(exc) + + if not isinstance(exc, (Exception, OutcomeException)): + raise + else: + if not future.cancelled(): + future.set_result(retval) + + async def _call_in_runner_task( + self, + func: Callable[P, Awaitable[T_Retval]], + /, + *args: P.args, + **kwargs: P.kwargs, + ) -> T_Retval: + if not self._runner_task: + self._send_stream, receive_stream = create_memory_object_stream[ + tuple[Awaitable[Any], asyncio.Future] + ](1) + self._runner_task = self.get_loop().create_task( + self._run_tests_and_fixtures(receive_stream) + ) + + coro = func(*args, **kwargs) + future: asyncio.Future[T_Retval] = self.get_loop().create_future() + self._send_stream.send_nowait((coro, future)) + return await future + + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]], + kwargs: dict[str, Any], + ) -> Iterable[T_Retval]: + asyncgen = fixture_func(**kwargs) + fixturevalue: T_Retval = self.get_loop().run_until_complete( + self._call_in_runner_task(asyncgen.asend, None) + ) + self._raise_async_exceptions() + + yield fixturevalue + + try: + self.get_loop().run_until_complete( + self._call_in_runner_task(asyncgen.asend, None) + ) + except StopAsyncIteration: + self._raise_async_exceptions() + else: + self.get_loop().run_until_complete(asyncgen.aclose()) + raise RuntimeError("Async generator fixture did not stop") + + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]], + kwargs: dict[str, Any], + ) -> T_Retval: + retval = self.get_loop().run_until_complete( + self._call_in_runner_task(fixture_func, **kwargs) + ) + self._raise_async_exceptions() + return retval + + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + try: + self.get_loop().run_until_complete( + self._call_in_runner_task(test_func, **kwargs) + ) + except Exception as exc: + self._exceptions.append(exc) + + self._raise_async_exceptions() + + +class AsyncIOBackend(AsyncBackend): + @classmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + @wraps(func) + async def wrapper() -> T_Retval: + task = cast(asyncio.Task, current_task()) + task.set_name(get_callable_name(func)) + _task_states[task] = TaskState(None, None) + + try: + return await func(*args) + finally: + del _task_states[task] + + debug = options.get("debug", None) + loop_factory = options.get("loop_factory", None) + if loop_factory is None and options.get("use_uvloop", False): + if sys.platform != "win32": + import uvloop + + loop_factory = uvloop.new_event_loop + else: + import winloop + + loop_factory = winloop.new_event_loop + + with Runner(debug=debug, loop_factory=loop_factory) as runner: + return runner.run(wrapper()) + + @classmethod + def current_token(cls) -> object: + return get_running_loop() + + @classmethod + def current_time(cls) -> float: + return get_running_loop().time() + + @classmethod + def cancelled_exception_class(cls) -> type[BaseException]: + return CancelledError + + @classmethod + async def checkpoint(cls) -> None: + await sleep(0) + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + task = current_task() + if task is None: + return + + try: + cancel_scope = _task_states[task].cancel_scope + except KeyError: + return + + while cancel_scope: + if cancel_scope.cancel_called: + await sleep(0) + elif cancel_scope.shield: + break + else: + cancel_scope = cancel_scope._parent_scope + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + with CancelScope(shield=True): + await sleep(0) + + @classmethod + async def sleep(cls, delay: float) -> None: + await sleep(delay) + + @classmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return CancelScope(deadline=deadline, shield=shield) + + @classmethod + def current_effective_deadline(cls) -> float: + if (task := current_task()) is None: + return math.inf + + try: + cancel_scope = _task_states[task].cancel_scope + except KeyError: + return math.inf + + deadline = math.inf + while cancel_scope: + deadline = min(deadline, cancel_scope.deadline) + if cancel_scope._cancel_called: + deadline = -math.inf + break + elif cancel_scope.shield: + break + else: + cancel_scope = cancel_scope._parent_scope + + return deadline + + @classmethod + def create_task_group(cls) -> abc.TaskGroup: + return TaskGroup() + + @classmethod + def create_event(cls) -> abc.Event: + return Event() + + @classmethod + def create_lock(cls, *, fast_acquire: bool) -> abc.Lock: + return Lock(fast_acquire=fast_acquire) + + @classmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> abc.Semaphore: + return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire) + + @classmethod + def create_capacity_limiter(cls, total_tokens: float) -> abc.CapacityLimiter: + return CapacityLimiter(total_tokens) + + @classmethod + async def run_sync_in_worker_thread( # type: ignore[return] + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: abc.CapacityLimiter | None = None, + ) -> T_Retval: + await cls.checkpoint() + + # If this is the first run in this event loop thread, set up the necessary + # variables + try: + idle_workers = _threadpool_idle_workers.get() + workers = _threadpool_workers.get() + except LookupError: + idle_workers = deque() + workers = set() + _threadpool_idle_workers.set(idle_workers) + _threadpool_workers.set(workers) + + async with limiter or cls.current_default_thread_limiter(): + with CancelScope(shield=not abandon_on_cancel) as scope: + future = asyncio.Future[T_Retval]() + root_task = find_root_task() + if not idle_workers: + worker = WorkerThread(root_task, workers, idle_workers) + worker.start() + workers.add(worker) + root_task.add_done_callback( + worker.stop, context=contextvars.Context() + ) + else: + worker = idle_workers.pop() + + # Prune any other workers that have been idle for MAX_IDLE_TIME + # seconds or longer + now = cls.current_time() + while idle_workers: + if ( + now - idle_workers[0].idle_since + < WorkerThread.MAX_IDLE_TIME + ): + break + + expired_worker = idle_workers.popleft() + expired_worker.root_task.remove_done_callback( + expired_worker.stop + ) + expired_worker.stop() + + context = copy_context() + context.run(set_current_async_library, None) + if abandon_on_cancel or scope._parent_scope is None: + worker_scope = scope + else: + worker_scope = scope._parent_scope + + worker.queue.put_nowait((context, func, args, future, worker_scope)) + return await future + + @classmethod + def check_cancelled(cls) -> None: + scope: CancelScope | None = threadlocals.current_cancel_scope + while scope is not None: + if scope.cancel_called: + raise CancelledError(f"Cancelled by cancel scope {id(scope):x}") + + if scope.shield: + return + + scope = scope._parent_scope + + @classmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + async def task_wrapper() -> T_Retval: + __tracebackhide__ = True + if scope is not None: + task = cast(asyncio.Task, current_task()) + _task_states[task] = TaskState(None, scope) + scope._tasks.add(task) + try: + return await func(*args) + except CancelledError as exc: + raise concurrent.futures.CancelledError(str(exc)) from None + finally: + if scope is not None: + scope._tasks.discard(task) + + loop = cast( + "AbstractEventLoop", token or threadlocals.current_token.native_token + ) + if loop.is_closed(): + raise RunFinishedError + + context = copy_context() + context.run(set_current_async_library, "asyncio") + scope = getattr(threadlocals, "current_cancel_scope", None) + f: concurrent.futures.Future[T_Retval] = context.run( + asyncio.run_coroutine_threadsafe, task_wrapper(), loop=loop + ) + return f.result() + + @classmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + @wraps(func) + def wrapper() -> None: + try: + set_current_async_library("asyncio") + f.set_result(func(*args)) + except BaseException as exc: + f.set_exception(exc) + if not isinstance(exc, Exception): + raise + + loop = cast( + "AbstractEventLoop", token or threadlocals.current_token.native_token + ) + if loop.is_closed(): + raise RunFinishedError + + f: concurrent.futures.Future[T_Retval] = Future() + loop.call_soon_threadsafe(wrapper) + return f.result() + + @classmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + await cls.checkpoint() + if isinstance(command, PathLike): + command = os.fspath(command) + + if isinstance(command, (str, bytes)): + process = await asyncio.create_subprocess_shell( + command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + **kwargs, + ) + else: + process = await asyncio.create_subprocess_exec( + *command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + **kwargs, + ) + + stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None + stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None + stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None + return Process(process, stdin_stream, stdout_stream, stderr_stream) + + @classmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None: + create_task( + _shutdown_process_pool_on_exit(workers), + name="AnyIO process pool shutdown task", + ) + find_root_task().add_done_callback( + partial(_forcibly_shutdown_process_pool_on_exit, workers) # type:ignore[arg-type] + ) + + @classmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> abc.SocketStream: + transport, protocol = cast( + tuple[asyncio.Transport, StreamProtocol], + await get_running_loop().create_connection( + StreamProtocol, host, port, local_addr=local_address + ), + ) + transport.pause_reading() + return SocketStream(transport, protocol) + + @classmethod + async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream: + await cls.checkpoint() + loop = get_running_loop() + raw_socket = socket.socket(socket.AF_UNIX) + raw_socket.setblocking(False) + while True: + try: + raw_socket.connect(path) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + loop.add_writer(raw_socket, f.set_result, None) + f.add_done_callback(lambda _: loop.remove_writer(raw_socket)) + await f + except BaseException: + raw_socket.close() + raise + else: + return UNIXSocketStream(raw_socket) + + @classmethod + def create_tcp_listener(cls, sock: socket.socket) -> SocketListener: + return TCPSocketListener(sock) + + @classmethod + def create_unix_listener(cls, sock: socket.socket) -> SocketListener: + return UNIXSocketListener(sock) + + @classmethod + async def create_udp_socket( + cls, + family: AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, + local_addr=local_address, + remote_addr=remote_address, + family=family, + reuse_port=reuse_port, + ) + if protocol.exception: + transport.close() + raise protocol.exception + + if not remote_address: + return UDPSocket(transport, protocol) + else: + return ConnectedUDPSocket(transport, protocol) + + @classmethod + async def create_unix_datagram_socket( # type: ignore[override] + cls, raw_socket: socket.socket, remote_path: str | bytes | None + ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket: + await cls.checkpoint() + loop = get_running_loop() + + if remote_path: + while True: + try: + raw_socket.connect(remote_path) + except BlockingIOError: + f: asyncio.Future = asyncio.Future() + loop.add_writer(raw_socket, f.set_result, None) + f.add_done_callback(lambda _: loop.remove_writer(raw_socket)) + await f + except BaseException: + raw_socket.close() + raise + else: + return ConnectedUNIXDatagramSocket(raw_socket) + else: + return UNIXDatagramSocket(raw_socket) + + @classmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + return await get_running_loop().getaddrinfo( + host, port, family=family, type=type, proto=proto, flags=flags + ) + + @classmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + return await get_running_loop().getnameinfo(sockaddr, flags) + + @classmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + try: + read_events = _read_events.get() + except LookupError: + read_events = {} + _read_events.set(read_events) + + fd = obj if isinstance(obj, int) else obj.fileno() + if read_events.get(fd): + raise BusyResourceError("reading from") + + loop = get_running_loop() + fut: asyncio.Future[bool] = loop.create_future() + + def cb() -> None: + try: + del read_events[fd] + except KeyError: + pass + else: + remove_reader(fd) + + try: + fut.set_result(True) + except asyncio.InvalidStateError: + pass + + try: + loop.add_reader(fd, cb) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + selector = get_selector() + selector.add_reader(fd, cb) + remove_reader = selector.remove_reader + else: + remove_reader = loop.remove_reader + + read_events[fd] = fut + try: + success = await fut + finally: + try: + del read_events[fd] + except KeyError: + pass + else: + remove_reader(fd) + + if not success: + raise ClosedResourceError + + @classmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + try: + write_events = _write_events.get() + except LookupError: + write_events = {} + _write_events.set(write_events) + + fd = obj if isinstance(obj, int) else obj.fileno() + if write_events.get(fd): + raise BusyResourceError("writing to") + + loop = get_running_loop() + fut: asyncio.Future[bool] = loop.create_future() + + def cb() -> None: + try: + del write_events[fd] + except KeyError: + pass + else: + remove_writer(fd) + + try: + fut.set_result(True) + except asyncio.InvalidStateError: + pass + + try: + loop.add_writer(fd, cb) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + selector = get_selector() + selector.add_writer(fd, cb) + remove_writer = selector.remove_writer + else: + remove_writer = loop.remove_writer + + write_events[fd] = fut + try: + success = await fut + finally: + try: + del write_events[fd] + except KeyError: + pass + else: + remove_writer(fd) + + if not success: + raise ClosedResourceError + + @classmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + fd = obj if isinstance(obj, int) else obj.fileno() + loop = get_running_loop() + + try: + write_events = _write_events.get() + except LookupError: + pass + else: + try: + fut = write_events.pop(fd) + except KeyError: + pass + else: + try: + fut.set_result(False) + except asyncio.InvalidStateError: + pass + + try: + loop.remove_writer(fd) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + get_selector().remove_writer(fd) + + try: + read_events = _read_events.get() + except LookupError: + pass + else: + try: + fut = read_events.pop(fd) + except KeyError: + pass + else: + try: + fut.set_result(False) + except asyncio.InvalidStateError: + pass + + try: + loop.remove_reader(fd) + except NotImplementedError: + from anyio._core._asyncio_selector_thread import get_selector + + get_selector().remove_reader(fd) + + @classmethod + async def wrap_listener_socket(cls, sock: socket.socket) -> SocketListener: + return TCPSocketListener(sock) + + @classmethod + async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream: + transport, protocol = await get_running_loop().create_connection( + StreamProtocol, sock=sock + ) + return SocketStream(transport, protocol) + + @classmethod + async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream: + return UNIXSocketStream(sock) + + @classmethod + async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, sock=sock + ) + return UDPSocket(transport, protocol) + + @classmethod + async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket: + transport, protocol = await get_running_loop().create_datagram_endpoint( + DatagramProtocol, sock=sock + ) + return ConnectedUDPSocket(transport, protocol) + + @classmethod + async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket: + return UNIXDatagramSocket(sock) + + @classmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket.socket + ) -> ConnectedUNIXDatagramSocket: + return ConnectedUNIXDatagramSocket(sock) + + @classmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + try: + return _default_thread_limiter.get() + except LookupError: + limiter = CapacityLimiter(40) + _default_thread_limiter.set(limiter) + return limiter + + @classmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + return _SignalReceiver(signals) + + @classmethod + def get_current_task(cls) -> TaskInfo: + return AsyncIOTaskInfo(current_task()) # type: ignore[arg-type] + + @classmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + return [AsyncIOTaskInfo(task) for task in all_tasks() if not task.done()] + + @classmethod + async def wait_all_tasks_blocked(cls) -> None: + await cls.checkpoint() + this_task = current_task() + while True: + for task in all_tasks(): + if task is this_task: + continue + + waiter = task._fut_waiter # type: ignore[attr-defined] + if waiter is None or waiter.done(): + await sleep(0.1) + break + else: + return + + @classmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + return TestRunner(**options) + + +backend_class = AsyncIOBackend diff --git a/.venv/lib/python3.10/site-packages/anyio/_backends/_trio.py b/.venv/lib/python3.10/site-packages/anyio/_backends/_trio.py new file mode 100644 index 0000000..b85a10a --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_backends/_trio.py @@ -0,0 +1,1343 @@ +from __future__ import annotations + +import array +import math +import os +import socket +import sys +import types +import weakref +from collections.abc import ( + AsyncGenerator, + AsyncIterator, + Awaitable, + Callable, + Collection, + Coroutine, + Iterable, + Sequence, +) +from contextlib import AbstractContextManager +from dataclasses import dataclass +from io import IOBase +from os import PathLike +from signal import Signals +from socket import AddressFamily, SocketKind +from types import TracebackType +from typing import ( + IO, + TYPE_CHECKING, + Any, + Generic, + NoReturn, + ParamSpec, + TypeVar, + cast, + overload, +) + +import trio.from_thread +import trio.lowlevel +from outcome import Error, Outcome, Value +from trio.lowlevel import ( + current_root_task, + current_task, + notify_closing, + wait_readable, + wait_writable, +) +from trio.socket import SocketType as TrioSocketType +from trio.to_thread import run_sync + +from .. import ( + CapacityLimiterStatistics, + EventStatistics, + LockStatistics, + RunFinishedError, + TaskInfo, + WouldBlock, + abc, +) +from .._core._eventloop import claim_worker_thread +from .._core._exceptions import ( + BrokenResourceError, + BusyResourceError, + ClosedResourceError, + EndOfStream, +) +from .._core._sockets import convert_ipv6_sockaddr +from .._core._streams import create_memory_object_stream +from .._core._synchronization import ( + CapacityLimiter as BaseCapacityLimiter, +) +from .._core._synchronization import Event as BaseEvent +from .._core._synchronization import Lock as BaseLock +from .._core._synchronization import ( + ResourceGuard, + SemaphoreStatistics, +) +from .._core._synchronization import Semaphore as BaseSemaphore +from .._core._tasks import CancelScope as BaseCancelScope +from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType +from ..abc._eventloop import AsyncBackend, StrOrBytesPath +from ..streams.memory import MemoryObjectSendStream + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from exceptiongroup import BaseExceptionGroup + from typing_extensions import TypeVarTuple, Unpack + +T = TypeVar("T") +T_Retval = TypeVar("T_Retval") +T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType) +PosArgsT = TypeVarTuple("PosArgsT") +P = ParamSpec("P") + + +# +# Event loop +# + +RunVar = trio.lowlevel.RunVar + + +# +# Timeouts and cancellation +# + + +class CancelScope(BaseCancelScope): + def __new__( + cls, original: trio.CancelScope | None = None, **kwargs: object + ) -> CancelScope: + return object.__new__(cls) + + def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None: + self.__original = original or trio.CancelScope(**kwargs) + + def __enter__(self) -> CancelScope: + self.__original.__enter__() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + return self.__original.__exit__(exc_type, exc_val, exc_tb) + + def cancel(self, reason: str | None = None) -> None: + self.__original.cancel(reason) + + @property + def deadline(self) -> float: + return self.__original.deadline + + @deadline.setter + def deadline(self, value: float) -> None: + self.__original.deadline = value + + @property + def cancel_called(self) -> bool: + return self.__original.cancel_called + + @property + def cancelled_caught(self) -> bool: + return self.__original.cancelled_caught + + @property + def shield(self) -> bool: + return self.__original.shield + + @shield.setter + def shield(self, value: bool) -> None: + self.__original.shield = value + + +# +# Task groups +# + + +class TaskGroup(abc.TaskGroup): + def __init__(self) -> None: + self._active = False + self._nursery_manager = trio.open_nursery(strict_exception_groups=True) + self.cancel_scope = None # type: ignore[assignment] + + async def __aenter__(self) -> TaskGroup: + self._active = True + self._nursery = await self._nursery_manager.__aenter__() + self.cancel_scope = CancelScope(self._nursery.cancel_scope) + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + try: + # trio.Nursery.__exit__ returns bool; .open_nursery has wrong type + return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb) # type: ignore[return-value] + except BaseExceptionGroup as exc: + if not exc.split(trio.Cancelled)[1]: + raise trio.Cancelled._create() from exc + + raise + finally: + del exc_val, exc_tb + self._active = False + + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + self._nursery.start_soon(func, *args, name=name) + + async def start( + self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None + ) -> Any: + if not self._active: + raise RuntimeError( + "This task group is not active; no new tasks can be started." + ) + + return await self._nursery.start(func, *args, name=name) + + +# +# Subprocesses +# + + +@dataclass(eq=False) +class ReceiveStreamWrapper(abc.ByteReceiveStream): + _stream: trio.abc.ReceiveStream + + async def receive(self, max_bytes: int | None = None) -> bytes: + try: + data = await self._stream.receive_some(max_bytes) + except trio.ClosedResourceError as exc: + raise ClosedResourceError from exc.__cause__ + except trio.BrokenResourceError as exc: + raise BrokenResourceError from exc.__cause__ + + if data: + return bytes(data) + else: + raise EndOfStream + + async def aclose(self) -> None: + await self._stream.aclose() + + +@dataclass(eq=False) +class SendStreamWrapper(abc.ByteSendStream): + _stream: trio.abc.SendStream + + async def send(self, item: bytes) -> None: + try: + await self._stream.send_all(item) + except trio.ClosedResourceError as exc: + raise ClosedResourceError from exc.__cause__ + except trio.BrokenResourceError as exc: + raise BrokenResourceError from exc.__cause__ + + async def aclose(self) -> None: + await self._stream.aclose() + + +@dataclass(eq=False) +class Process(abc.Process): + _process: trio.Process + _stdin: abc.ByteSendStream | None + _stdout: abc.ByteReceiveStream | None + _stderr: abc.ByteReceiveStream | None + + async def aclose(self) -> None: + with CancelScope(shield=True): + if self._stdin: + await self._stdin.aclose() + if self._stdout: + await self._stdout.aclose() + if self._stderr: + await self._stderr.aclose() + + try: + await self.wait() + except BaseException: + self.kill() + with CancelScope(shield=True): + await self.wait() + raise + + async def wait(self) -> int: + return await self._process.wait() + + def terminate(self) -> None: + self._process.terminate() + + def kill(self) -> None: + self._process.kill() + + def send_signal(self, signal: Signals) -> None: + self._process.send_signal(signal) + + @property + def pid(self) -> int: + return self._process.pid + + @property + def returncode(self) -> int | None: + return self._process.returncode + + @property + def stdin(self) -> abc.ByteSendStream | None: + return self._stdin + + @property + def stdout(self) -> abc.ByteReceiveStream | None: + return self._stdout + + @property + def stderr(self) -> abc.ByteReceiveStream | None: + return self._stderr + + +class _ProcessPoolShutdownInstrument(trio.abc.Instrument): + def after_run(self) -> None: + super().after_run() + + +current_default_worker_process_limiter: trio.lowlevel.RunVar = RunVar( + "current_default_worker_process_limiter" +) + + +async def _shutdown_process_pool(workers: set[abc.Process]) -> None: + try: + await trio.sleep(math.inf) + except trio.Cancelled: + for process in workers: + if process.returncode is None: + process.kill() + + with CancelScope(shield=True): + for process in workers: + await process.aclose() + + +# +# Sockets and networking +# + + +class _TrioSocketMixin(Generic[T_SockAddr]): + def __init__(self, trio_socket: TrioSocketType) -> None: + self._trio_socket = trio_socket + self._closed = False + + def _check_closed(self) -> None: + if self._closed: + raise ClosedResourceError + if self._trio_socket.fileno() < 0: + raise BrokenResourceError + + @property + def _raw_socket(self) -> socket.socket: + return self._trio_socket._sock # type: ignore[attr-defined] + + async def aclose(self) -> None: + if self._trio_socket.fileno() >= 0: + self._closed = True + self._trio_socket.close() + + def _convert_socket_error(self, exc: BaseException) -> NoReturn: + if isinstance(exc, trio.ClosedResourceError): + raise ClosedResourceError from exc + elif self._trio_socket.fileno() < 0 and self._closed: + raise ClosedResourceError from None + elif isinstance(exc, OSError): + raise BrokenResourceError from exc + else: + raise exc + + +class SocketStream(_TrioSocketMixin, abc.SocketStream): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self, max_bytes: int = 65536) -> bytes: + with self._receive_guard: + try: + data = await self._trio_socket.recv(max_bytes) + except BaseException as exc: + self._convert_socket_error(exc) + + if data: + return data + else: + raise EndOfStream + + async def send(self, item: bytes) -> None: + with self._send_guard: + view = memoryview(item) + while view: + try: + bytes_sent = await self._trio_socket.send(view) + except BaseException as exc: + self._convert_socket_error(exc) + + view = view[bytes_sent:] + + async def send_eof(self) -> None: + self._trio_socket.shutdown(socket.SHUT_WR) + + +class UNIXSocketStream(SocketStream, abc.UNIXSocketStream): + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + if not isinstance(msglen, int) or msglen < 0: + raise ValueError("msglen must be a non-negative integer") + if not isinstance(maxfds, int) or maxfds < 1: + raise ValueError("maxfds must be a positive integer") + + fds = array.array("i") + await trio.lowlevel.checkpoint() + with self._receive_guard: + while True: + try: + message, ancdata, flags, addr = await self._trio_socket.recvmsg( + msglen, socket.CMSG_LEN(maxfds * fds.itemsize) + ) + except BaseException as exc: + self._convert_socket_error(exc) + else: + if not message and not ancdata: + raise EndOfStream + + break + + for cmsg_level, cmsg_type, cmsg_data in ancdata: + if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS: + raise RuntimeError( + f"Received unexpected ancillary data; message = {message!r}, " + f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}" + ) + + fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)]) + + return message, list(fds) + + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + if not message: + raise ValueError("message must not be empty") + if not fds: + raise ValueError("fds must not be empty") + + filenos: list[int] = [] + for fd in fds: + if isinstance(fd, int): + filenos.append(fd) + elif isinstance(fd, IOBase): + filenos.append(fd.fileno()) + + fdarray = array.array("i", filenos) + await trio.lowlevel.checkpoint() + with self._send_guard: + while True: + try: + await self._trio_socket.sendmsg( + [message], + [ + ( + socket.SOL_SOCKET, + socket.SCM_RIGHTS, + fdarray, + ) + ], + ) + break + except BaseException as exc: + self._convert_socket_error(exc) + + +class TCPSocketListener(_TrioSocketMixin, abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + super().__init__(trio.socket.from_stdlib_socket(raw_socket)) + self._accept_guard = ResourceGuard("accepting connections from") + + async def accept(self) -> SocketStream: + with self._accept_guard: + try: + trio_socket, _addr = await self._trio_socket.accept() + except BaseException as exc: + self._convert_socket_error(exc) + + trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + return SocketStream(trio_socket) + + +class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener): + def __init__(self, raw_socket: socket.socket): + super().__init__(trio.socket.from_stdlib_socket(raw_socket)) + self._accept_guard = ResourceGuard("accepting connections from") + + async def accept(self) -> UNIXSocketStream: + with self._accept_guard: + try: + trio_socket, _addr = await self._trio_socket.accept() + except BaseException as exc: + self._convert_socket_error(exc) + + return UNIXSocketStream(trio_socket) + + +class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> tuple[bytes, IPSockAddrType]: + with self._receive_guard: + try: + data, addr = await self._trio_socket.recvfrom(65536) + return data, convert_ipv6_sockaddr(addr) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: UDPPacketType) -> None: + with self._send_guard: + try: + await self._trio_socket.sendto(*item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> bytes: + with self._receive_guard: + try: + return await self._trio_socket.recv(65536) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: bytes) -> None: + with self._send_guard: + try: + await self._trio_socket.send(item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class UNIXDatagramSocket(_TrioSocketMixin[str], abc.UNIXDatagramSocket): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> UNIXDatagramPacketType: + with self._receive_guard: + try: + data, addr = await self._trio_socket.recvfrom(65536) + return data, addr + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: UNIXDatagramPacketType) -> None: + with self._send_guard: + try: + await self._trio_socket.sendto(*item) + except BaseException as exc: + self._convert_socket_error(exc) + + +class ConnectedUNIXDatagramSocket( + _TrioSocketMixin[str], abc.ConnectedUNIXDatagramSocket +): + def __init__(self, trio_socket: TrioSocketType) -> None: + super().__init__(trio_socket) + self._receive_guard = ResourceGuard("reading from") + self._send_guard = ResourceGuard("writing to") + + async def receive(self) -> bytes: + with self._receive_guard: + try: + return await self._trio_socket.recv(65536) + except BaseException as exc: + self._convert_socket_error(exc) + + async def send(self, item: bytes) -> None: + with self._send_guard: + try: + await self._trio_socket.send(item) + except BaseException as exc: + self._convert_socket_error(exc) + + +# +# Synchronization +# + + +class Event(BaseEvent): + def __new__(cls) -> Event: + return object.__new__(cls) + + def __init__(self) -> None: + self.__original = trio.Event() + + def is_set(self) -> bool: + return self.__original.is_set() + + async def wait(self) -> None: + return await self.__original.wait() + + def statistics(self) -> EventStatistics: + orig_statistics = self.__original.statistics() + return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting) + + def set(self) -> None: + self.__original.set() + + +class Lock(BaseLock): + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False) -> None: + self._fast_acquire = fast_acquire + self.__original = trio.Lock() + + @staticmethod + def _convert_runtime_error_msg(exc: RuntimeError) -> None: + if exc.args == ("attempt to re-acquire an already held Lock",): + exc.args = ("Attempted to acquire an already held Lock",) + + async def acquire(self) -> None: + if not self._fast_acquire: + try: + await self.__original.acquire() + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + return + + # This is the "fast path" where we don't let other tasks run + await trio.lowlevel.checkpoint_if_cancelled() + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + await self.__original._lot.park() + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + def acquire_nowait(self) -> None: + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + raise WouldBlock from None + except RuntimeError as exc: + self._convert_runtime_error_msg(exc) + raise + + def locked(self) -> bool: + return self.__original.locked() + + def release(self) -> None: + self.__original.release() + + def statistics(self) -> LockStatistics: + orig_statistics = self.__original.statistics() + owner = TrioTaskInfo(orig_statistics.owner) if orig_statistics.owner else None + return LockStatistics( + orig_statistics.locked, owner, orig_statistics.tasks_waiting + ) + + +class Semaphore(BaseSemaphore): + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> None: + super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire) + self.__original = trio.Semaphore(initial_value, max_value=max_value) + + async def acquire(self) -> None: + if not self._fast_acquire: + await self.__original.acquire() + return + + # This is the "fast path" where we don't let other tasks run + await trio.lowlevel.checkpoint_if_cancelled() + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + await self.__original._lot.park() + + def acquire_nowait(self) -> None: + try: + self.__original.acquire_nowait() + except trio.WouldBlock: + raise WouldBlock from None + + @property + def max_value(self) -> int | None: + return self.__original.max_value + + @property + def value(self) -> int: + return self.__original.value + + def release(self) -> None: + self.__original.release() + + def statistics(self) -> SemaphoreStatistics: + orig_statistics = self.__original.statistics() + return SemaphoreStatistics(orig_statistics.tasks_waiting) + + +class CapacityLimiter(BaseCapacityLimiter): + def __new__( + cls, + total_tokens: float | None = None, + *, + original: trio.CapacityLimiter | None = None, + ) -> CapacityLimiter: + return object.__new__(cls) + + def __init__( + self, + total_tokens: float | None = None, + *, + original: trio.CapacityLimiter | None = None, + ) -> None: + if original is not None: + self.__original = original + else: + assert total_tokens is not None + self.__original = trio.CapacityLimiter(total_tokens) + + async def __aenter__(self) -> None: + return await self.__original.__aenter__() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.__original.__aexit__(exc_type, exc_val, exc_tb) + + @property + def total_tokens(self) -> float: + return self.__original.total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + self.__original.total_tokens = value + + @property + def borrowed_tokens(self) -> int: + return self.__original.borrowed_tokens + + @property + def available_tokens(self) -> float: + return self.__original.available_tokens + + def acquire_nowait(self) -> None: + self.__original.acquire_nowait() + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + self.__original.acquire_on_behalf_of_nowait(borrower) + + async def acquire(self) -> None: + await self.__original.acquire() + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await self.__original.acquire_on_behalf_of(borrower) + + def release(self) -> None: + return self.__original.release() + + def release_on_behalf_of(self, borrower: object) -> None: + return self.__original.release_on_behalf_of(borrower) + + def statistics(self) -> CapacityLimiterStatistics: + orig = self.__original.statistics() + return CapacityLimiterStatistics( + borrowed_tokens=orig.borrowed_tokens, + total_tokens=orig.total_tokens, + borrowers=tuple(orig.borrowers), + tasks_waiting=orig.tasks_waiting, + ) + + +_capacity_limiter_wrapper: trio.lowlevel.RunVar = RunVar("_capacity_limiter_wrapper") + + +# +# Signal handling +# + + +class _SignalReceiver: + _iterator: AsyncIterator[int] + + def __init__(self, signals: tuple[Signals, ...]): + self._signals = signals + + def __enter__(self) -> _SignalReceiver: + self._cm = trio.open_signal_receiver(*self._signals) + self._iterator = self._cm.__enter__() + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool | None: + return self._cm.__exit__(exc_type, exc_val, exc_tb) + + def __aiter__(self) -> _SignalReceiver: + return self + + async def __anext__(self) -> Signals: + signum = await self._iterator.__anext__() + return Signals(signum) + + +# +# Testing and debugging +# + + +class TestRunner(abc.TestRunner): + def __init__(self, **options: Any) -> None: + from queue import Queue + + self._call_queue: Queue[Callable[[], object]] = Queue() + self._send_stream: MemoryObjectSendStream | None = None + self._options = options + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: types.TracebackType | None, + ) -> None: + if self._send_stream: + self._send_stream.close() + while self._send_stream is not None: + self._call_queue.get()() + + async def _run_tests_and_fixtures(self) -> None: + self._send_stream, receive_stream = create_memory_object_stream(1) + with receive_stream: + async for coro, outcome_holder in receive_stream: + try: + retval = await coro + except BaseException as exc: + outcome_holder.append(Error(exc)) + else: + outcome_holder.append(Value(retval)) + + def _main_task_finished(self, outcome: object) -> None: + self._send_stream = None + + def _call_in_runner_task( + self, + func: Callable[P, Awaitable[T_Retval]], + /, + *args: P.args, + **kwargs: P.kwargs, + ) -> T_Retval: + if self._send_stream is None: + trio.lowlevel.start_guest_run( + self._run_tests_and_fixtures, + run_sync_soon_threadsafe=self._call_queue.put, + done_callback=self._main_task_finished, + **self._options, + ) + while self._send_stream is None: + self._call_queue.get()() + + outcome_holder: list[Outcome] = [] + self._send_stream.send_nowait((func(*args, **kwargs), outcome_holder)) + while not outcome_holder: + self._call_queue.get()() + + return outcome_holder[0].unwrap() + + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]], + kwargs: dict[str, Any], + ) -> Iterable[T_Retval]: + asyncgen = fixture_func(**kwargs) + fixturevalue: T_Retval = self._call_in_runner_task(asyncgen.asend, None) + + yield fixturevalue + + try: + self._call_in_runner_task(asyncgen.asend, None) + except StopAsyncIteration: + pass + else: + self._call_in_runner_task(asyncgen.aclose) + raise RuntimeError("Async generator fixture did not stop") + + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]], + kwargs: dict[str, Any], + ) -> T_Retval: + return self._call_in_runner_task(fixture_func, **kwargs) + + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + self._call_in_runner_task(test_func, **kwargs) + + +class TrioTaskInfo(TaskInfo): + def __init__(self, task: trio.lowlevel.Task): + parent_id = None + if task.parent_nursery and task.parent_nursery.parent_task: + parent_id = id(task.parent_nursery.parent_task) + + super().__init__(id(task), parent_id, task.name, task.coro) + self._task = weakref.proxy(task) + + def has_pending_cancellation(self) -> bool: + try: + return self._task._cancel_status.effectively_cancelled + except ReferenceError: + # If the task is no longer around, it surely doesn't have a cancellation + # pending + return False + + +class TrioBackend(AsyncBackend): + @classmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + return trio.run(func, *args) + + @classmethod + def current_token(cls) -> object: + return trio.lowlevel.current_trio_token() + + @classmethod + def current_time(cls) -> float: + return trio.current_time() + + @classmethod + def cancelled_exception_class(cls) -> type[BaseException]: + return trio.Cancelled + + @classmethod + async def checkpoint(cls) -> None: + await trio.lowlevel.checkpoint() + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + await trio.lowlevel.checkpoint_if_cancelled() + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + await trio.lowlevel.cancel_shielded_checkpoint() + + @classmethod + async def sleep(cls, delay: float) -> None: + await trio.sleep(delay) + + @classmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> abc.CancelScope: + return CancelScope(deadline=deadline, shield=shield) + + @classmethod + def current_effective_deadline(cls) -> float: + return trio.current_effective_deadline() + + @classmethod + def create_task_group(cls) -> abc.TaskGroup: + return TaskGroup() + + @classmethod + def create_event(cls) -> abc.Event: + return Event() + + @classmethod + def create_lock(cls, *, fast_acquire: bool) -> Lock: + return Lock(fast_acquire=fast_acquire) + + @classmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> abc.Semaphore: + return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire) + + @classmethod + def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter: + return CapacityLimiter(total_tokens) + + @classmethod + async def run_sync_in_worker_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: abc.CapacityLimiter | None = None, + ) -> T_Retval: + def wrapper() -> T_Retval: + with claim_worker_thread(TrioBackend, token): + return func(*args) + + token = TrioBackend.current_token() + return await run_sync( + wrapper, + abandon_on_cancel=abandon_on_cancel, + limiter=cast(trio.CapacityLimiter, limiter), + ) + + @classmethod + def check_cancelled(cls) -> None: + trio.from_thread.check_cancelled() + + @classmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + trio_token = cast("trio.lowlevel.TrioToken | None", token) + try: + return trio.from_thread.run(func, *args, trio_token=trio_token) + except trio.RunFinishedError: + raise RunFinishedError from None + + @classmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + trio_token = cast("trio.lowlevel.TrioToken | None", token) + try: + return trio.from_thread.run_sync(func, *args, trio_token=trio_token) + except trio.RunFinishedError: + raise RunFinishedError from None + + @classmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + def convert_item(item: StrOrBytesPath) -> str: + str_or_bytes = os.fspath(item) + if isinstance(str_or_bytes, str): + return str_or_bytes + else: + return os.fsdecode(str_or_bytes) + + if isinstance(command, (str, bytes, PathLike)): + process = await trio.lowlevel.open_process( + convert_item(command), + stdin=stdin, + stdout=stdout, + stderr=stderr, + shell=True, + **kwargs, + ) + else: + process = await trio.lowlevel.open_process( + [convert_item(item) for item in command], + stdin=stdin, + stdout=stdout, + stderr=stderr, + shell=False, + **kwargs, + ) + + stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None + stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None + stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None + return Process(process, stdin_stream, stdout_stream, stderr_stream) + + @classmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None: + trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers) + + @classmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> SocketStream: + family = socket.AF_INET6 if ":" in host else socket.AF_INET + trio_socket = trio.socket.socket(family) + trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + if local_address: + await trio_socket.bind(local_address) + + try: + await trio_socket.connect((host, port)) + except BaseException: + trio_socket.close() + raise + + return SocketStream(trio_socket) + + @classmethod + async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream: + trio_socket = trio.socket.socket(socket.AF_UNIX) + try: + await trio_socket.connect(path) + except BaseException: + trio_socket.close() + raise + + return UNIXSocketStream(trio_socket) + + @classmethod + def create_tcp_listener(cls, sock: socket.socket) -> abc.SocketListener: + return TCPSocketListener(sock) + + @classmethod + def create_unix_listener(cls, sock: socket.socket) -> abc.SocketListener: + return UNIXSocketListener(sock) + + @classmethod + async def create_udp_socket( + cls, + family: socket.AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM) + + if reuse_port: + trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + + if local_address: + await trio_socket.bind(local_address) + + if remote_address: + await trio_socket.connect(remote_address) + return ConnectedUDPSocket(trio_socket) + else: + return UDPSocket(trio_socket) + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: None + ) -> abc.UNIXDatagramSocket: ... + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: str | bytes + ) -> abc.ConnectedUNIXDatagramSocket: ... + + @classmethod + async def create_unix_datagram_socket( + cls, raw_socket: socket.socket, remote_path: str | bytes | None + ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket: + trio_socket = trio.socket.from_stdlib_socket(raw_socket) + + if remote_path: + await trio_socket.connect(remote_path) + return ConnectedUNIXDatagramSocket(trio_socket) + else: + return UNIXDatagramSocket(trio_socket) + + @classmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + return await trio.socket.getaddrinfo(host, port, family, type, proto, flags) + + @classmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + return await trio.socket.getnameinfo(sockaddr, flags) + + @classmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + try: + await wait_readable(obj) + except trio.ClosedResourceError as exc: + raise ClosedResourceError().with_traceback(exc.__traceback__) from None + except trio.BusyResourceError: + raise BusyResourceError("reading from") from None + + @classmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + try: + await wait_writable(obj) + except trio.ClosedResourceError as exc: + raise ClosedResourceError().with_traceback(exc.__traceback__) from None + except trio.BusyResourceError: + raise BusyResourceError("writing to") from None + + @classmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + notify_closing(obj) + + @classmethod + async def wrap_listener_socket(cls, sock: socket.socket) -> abc.SocketListener: + return TCPSocketListener(sock) + + @classmethod + async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream: + trio_sock = trio.socket.from_stdlib_socket(sock) + return SocketStream(trio_sock) + + @classmethod + async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UNIXSocketStream(trio_sock) + + @classmethod + async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UDPSocket(trio_sock) + + @classmethod + async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return ConnectedUDPSocket(trio_sock) + + @classmethod + async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return UNIXDatagramSocket(trio_sock) + + @classmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket.socket + ) -> ConnectedUNIXDatagramSocket: + trio_sock = trio.socket.from_stdlib_socket(sock) + return ConnectedUNIXDatagramSocket(trio_sock) + + @classmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + try: + return _capacity_limiter_wrapper.get() + except LookupError: + limiter = CapacityLimiter( + original=trio.to_thread.current_default_thread_limiter() + ) + _capacity_limiter_wrapper.set(limiter) + return limiter + + @classmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + return _SignalReceiver(signals) + + @classmethod + def get_current_task(cls) -> TaskInfo: + task = current_task() + return TrioTaskInfo(task) + + @classmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + root_task = current_root_task() + assert root_task + task_infos = [TrioTaskInfo(root_task)] + nurseries = root_task.child_nurseries + while nurseries: + new_nurseries: list[trio.Nursery] = [] + for nursery in nurseries: + for task in nursery.child_tasks: + task_infos.append(TrioTaskInfo(task)) + new_nurseries.extend(task.child_nurseries) + + nurseries = new_nurseries + + return task_infos + + @classmethod + async def wait_all_tasks_blocked(cls) -> None: + from trio.testing import wait_all_tasks_blocked + + await wait_all_tasks_blocked() + + @classmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + return TestRunner(**options) + + +backend_class = TrioBackend diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__init__.py b/.venv/lib/python3.10/site-packages/anyio/_core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..d66f08e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc new file mode 100644 index 0000000..58508b6 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-310.pyc new file mode 100644 index 0000000..854d645 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_eventloop.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_eventloop.cpython-310.pyc new file mode 100644 index 0000000..2139d44 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_eventloop.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_exceptions.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_exceptions.cpython-310.pyc new file mode 100644 index 0000000..7d9120e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_exceptions.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_fileio.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_fileio.cpython-310.pyc new file mode 100644 index 0000000..6ff7b9e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_fileio.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_resources.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_resources.cpython-310.pyc new file mode 100644 index 0000000..ce94b1a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_resources.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_signals.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_signals.cpython-310.pyc new file mode 100644 index 0000000..1ec609d Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_signals.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_sockets.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_sockets.cpython-310.pyc new file mode 100644 index 0000000..714b32b Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_sockets.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_streams.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_streams.cpython-310.pyc new file mode 100644 index 0000000..f03a25a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_streams.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-310.pyc new file mode 100644 index 0000000..173f158 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_synchronization.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_synchronization.cpython-310.pyc new file mode 100644 index 0000000..652e4c3 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_synchronization.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tasks.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tasks.cpython-310.pyc new file mode 100644 index 0000000..024bfb6 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tasks.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tempfile.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tempfile.cpython-310.pyc new file mode 100644 index 0000000..1578bea Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_tempfile.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_testing.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_testing.cpython-310.pyc new file mode 100644 index 0000000..b613057 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_testing.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_typedattr.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_typedattr.cpython-310.pyc new file mode 100644 index 0000000..5718a85 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/_core/__pycache__/_typedattr.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_asyncio_selector_thread.py b/.venv/lib/python3.10/site-packages/anyio/_core/_asyncio_selector_thread.py new file mode 100644 index 0000000..9f35bae --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_asyncio_selector_thread.py @@ -0,0 +1,167 @@ +from __future__ import annotations + +import asyncio +import socket +import threading +from collections.abc import Callable +from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + +_selector_lock = threading.Lock() +_selector: Selector | None = None + + +class Selector: + def __init__(self) -> None: + self._thread = threading.Thread(target=self.run, name="AnyIO socket selector") + self._selector = DefaultSelector() + self._send, self._receive = socket.socketpair() + self._send.setblocking(False) + self._receive.setblocking(False) + # This somewhat reduces the amount of memory wasted queueing up data + # for wakeups. With these settings, maximum number of 1-byte sends + # before getting BlockingIOError: + # Linux 4.8: 6 + # macOS (darwin 15.5): 1 + # Windows 10: 525347 + # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send + # blocking, even on non-blocking sockets, so don't do that.) + self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1) + self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1) + # On Windows this is a TCP socket so this might matter. On other + # platforms this fails b/c AF_UNIX sockets aren't actually TCP. + try: + self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + except OSError: + pass + + self._selector.register(self._receive, EVENT_READ) + self._closed = False + + def start(self) -> None: + self._thread.start() + threading._register_atexit(self._stop) # type: ignore[attr-defined] + + def _stop(self) -> None: + global _selector + self._closed = True + self._notify_self() + self._send.close() + self._thread.join() + self._selector.unregister(self._receive) + self._receive.close() + self._selector.close() + _selector = None + assert not self._selector.get_map(), ( + "selector still has registered file descriptors after shutdown" + ) + + def _notify_self(self) -> None: + try: + self._send.send(b"\x00") + except BlockingIOError: + pass + + def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None: + loop = asyncio.get_running_loop() + try: + key = self._selector.get_key(fd) + except KeyError: + self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)}) + else: + if EVENT_READ in key.data: + raise ValueError( + "this file descriptor is already registered for reading" + ) + + key.data[EVENT_READ] = loop, callback + self._selector.modify(fd, key.events | EVENT_READ, key.data) + + self._notify_self() + + def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None: + loop = asyncio.get_running_loop() + try: + key = self._selector.get_key(fd) + except KeyError: + self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)}) + else: + if EVENT_WRITE in key.data: + raise ValueError( + "this file descriptor is already registered for writing" + ) + + key.data[EVENT_WRITE] = loop, callback + self._selector.modify(fd, key.events | EVENT_WRITE, key.data) + + self._notify_self() + + def remove_reader(self, fd: FileDescriptorLike) -> bool: + try: + key = self._selector.get_key(fd) + except KeyError: + return False + + if new_events := key.events ^ EVENT_READ: + del key.data[EVENT_READ] + self._selector.modify(fd, new_events, key.data) + else: + self._selector.unregister(fd) + + return True + + def remove_writer(self, fd: FileDescriptorLike) -> bool: + try: + key = self._selector.get_key(fd) + except KeyError: + return False + + if new_events := key.events ^ EVENT_WRITE: + del key.data[EVENT_WRITE] + self._selector.modify(fd, new_events, key.data) + else: + self._selector.unregister(fd) + + return True + + def run(self) -> None: + while not self._closed: + for key, events in self._selector.select(): + if key.fileobj is self._receive: + try: + while self._receive.recv(4096): + pass + except BlockingIOError: + pass + + continue + + if events & EVENT_READ: + loop, callback = key.data[EVENT_READ] + self.remove_reader(key.fd) + try: + loop.call_soon_threadsafe(callback) + except RuntimeError: + pass # the loop was already closed + + if events & EVENT_WRITE: + loop, callback = key.data[EVENT_WRITE] + self.remove_writer(key.fd) + try: + loop.call_soon_threadsafe(callback) + except RuntimeError: + pass # the loop was already closed + + +def get_selector() -> Selector: + global _selector + + with _selector_lock: + if _selector is None: + _selector = Selector() + _selector.start() + + return _selector diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_contextmanagers.py b/.venv/lib/python3.10/site-packages/anyio/_core/_contextmanagers.py new file mode 100644 index 0000000..302f32b --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_contextmanagers.py @@ -0,0 +1,200 @@ +from __future__ import annotations + +from abc import abstractmethod +from contextlib import AbstractAsyncContextManager, AbstractContextManager +from inspect import isasyncgen, iscoroutine, isgenerator +from types import TracebackType +from typing import Protocol, TypeVar, cast, final + +_T_co = TypeVar("_T_co", covariant=True) +_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None") + + +class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]): + def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ... + + +class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]): + def __asynccontextmanager__( + self, + ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ... + + +class ContextManagerMixin: + """ + Mixin class providing context manager functionality via a generator-based + implementation. + + This class allows you to implement a context manager via :meth:`__contextmanager__` + which should return a generator. The mechanics are meant to mirror those of + :func:`@contextmanager `. + + .. note:: Classes using this mix-in are not reentrant as context managers, meaning + that once you enter it, you can't re-enter before first exiting it. + + .. seealso:: :doc:`contextmanagers` + """ + + __cm: AbstractContextManager[object, bool | None] | None = None + + @final + def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, ContextManagerMixin) + if self.__cm is not None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has already been entered" + ) + + cm = self.__contextmanager__() + if not isinstance(cm, AbstractContextManager): + if isgenerator(cm): + raise TypeError( + "__contextmanager__() returned a generator object instead of " + "a context manager. Did you forget to add the @contextmanager " + "decorator?" + ) + + raise TypeError( + f"__contextmanager__() did not return a context manager object, " + f"but {cm.__class__!r}" + ) + + if cm is self: + raise TypeError( + f"{self.__class__.__qualname__}.__contextmanager__() returned " + f"self. Did you forget to add the @contextmanager decorator and a " + f"'yield' statement?" + ) + + value = cm.__enter__() + self.__cm = cm + return value + + @final + def __exit__( + self: _SupportsCtxMgr[object, _ExitT_co], + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> _ExitT_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, ContextManagerMixin) + if self.__cm is None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has not been entered yet" + ) + + # Prevent circular references + cm = self.__cm + del self.__cm + + return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb)) + + @abstractmethod + def __contextmanager__(self) -> AbstractContextManager[object, bool | None]: + """ + Implement your context manager logic here. + + This method **must** be decorated with + :func:`@contextmanager `. + + .. note:: Remember that the ``yield`` will raise any exception raised in the + enclosed context block, so use a ``finally:`` block to clean up resources! + + :return: a context manager object + """ + + +class AsyncContextManagerMixin: + """ + Mixin class providing async context manager functionality via a generator-based + implementation. + + This class allows you to implement a context manager via + :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of + :func:`@asynccontextmanager `. + + .. note:: Classes using this mix-in are not reentrant as context managers, meaning + that once you enter it, you can't re-enter before first exiting it. + + .. seealso:: :doc:`contextmanagers` + """ + + __cm: AbstractAsyncContextManager[object, bool | None] | None = None + + @final + async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co: + # Needed for mypy to assume self still has the __cm member + assert isinstance(self, AsyncContextManagerMixin) + if self.__cm is not None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has already been entered" + ) + + cm = self.__asynccontextmanager__() + if not isinstance(cm, AbstractAsyncContextManager): + if isasyncgen(cm): + raise TypeError( + "__asynccontextmanager__() returned an async generator instead of " + "an async context manager. Did you forget to add the " + "@asynccontextmanager decorator?" + ) + elif iscoroutine(cm): + cm.close() + raise TypeError( + "__asynccontextmanager__() returned a coroutine object instead of " + "an async context manager. Did you forget to add the " + "@asynccontextmanager decorator and a 'yield' statement?" + ) + + raise TypeError( + f"__asynccontextmanager__() did not return an async context manager, " + f"but {cm.__class__!r}" + ) + + if cm is self: + raise TypeError( + f"{self.__class__.__qualname__}.__asynccontextmanager__() returned " + f"self. Did you forget to add the @asynccontextmanager decorator and a " + f"'yield' statement?" + ) + + value = await cm.__aenter__() + self.__cm = cm + return value + + @final + async def __aexit__( + self: _SupportsAsyncCtxMgr[object, _ExitT_co], + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> _ExitT_co: + assert isinstance(self, AsyncContextManagerMixin) + if self.__cm is None: + raise RuntimeError( + f"this {self.__class__.__qualname__} has not been entered yet" + ) + + # Prevent circular references + cm = self.__cm + del self.__cm + + return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb)) + + @abstractmethod + def __asynccontextmanager__( + self, + ) -> AbstractAsyncContextManager[object, bool | None]: + """ + Implement your async context manager logic here. + + This method **must** be decorated with + :func:`@asynccontextmanager `. + + .. note:: Remember that the ``yield`` will raise any exception raised in the + enclosed context block, so use a ``finally:`` block to clean up resources! + + :return: an async context manager object + """ diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_eventloop.py b/.venv/lib/python3.10/site-packages/anyio/_core/_eventloop.py new file mode 100644 index 0000000..59a69cc --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_eventloop.py @@ -0,0 +1,234 @@ +from __future__ import annotations + +import math +import sys +import threading +from collections.abc import Awaitable, Callable, Generator +from contextlib import contextmanager +from contextvars import Token +from importlib import import_module +from typing import TYPE_CHECKING, Any, TypeVar + +from ._exceptions import NoEventLoopError + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +sniffio: Any +try: + import sniffio +except ModuleNotFoundError: + sniffio = None + +if TYPE_CHECKING: + from ..abc import AsyncBackend + +# This must be updated when new backends are introduced +BACKENDS = "asyncio", "trio" + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") + +threadlocals = threading.local() +loaded_backends: dict[str, type[AsyncBackend]] = {} + + +def run( + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + *args: Unpack[PosArgsT], + backend: str = "asyncio", + backend_options: dict[str, Any] | None = None, +) -> T_Retval: + """ + Run the given coroutine function in an asynchronous event loop. + + The current thread must not be already running an event loop. + + :param func: a coroutine function + :param args: positional arguments to ``func`` + :param backend: name of the asynchronous event loop implementation – currently + either ``asyncio`` or ``trio`` + :param backend_options: keyword arguments to call the backend ``run()`` + implementation with (documented :ref:`here `) + :return: the return value of the coroutine function + :raises RuntimeError: if an asynchronous event loop is already running in this + thread + :raises LookupError: if the named backend is not found + + """ + if asynclib_name := current_async_library(): + raise RuntimeError(f"Already running {asynclib_name} in this thread") + + try: + async_backend = get_async_backend(backend) + except ImportError as exc: + raise LookupError(f"No such backend: {backend}") from exc + + token = None + if asynclib_name is None: + # Since we're in control of the event loop, we can cache the name of the async + # library + token = set_current_async_library(backend) + + try: + backend_options = backend_options or {} + return async_backend.run(func, args, {}, backend_options) + finally: + reset_current_async_library(token) + + +async def sleep(delay: float) -> None: + """ + Pause the current task for the specified duration. + + :param delay: the duration, in seconds + + """ + return await get_async_backend().sleep(delay) + + +async def sleep_forever() -> None: + """ + Pause the current task until it's cancelled. + + This is a shortcut for ``sleep(math.inf)``. + + .. versionadded:: 3.1 + + """ + await sleep(math.inf) + + +async def sleep_until(deadline: float) -> None: + """ + Pause the current task until the given time. + + :param deadline: the absolute time to wake up at (according to the internal + monotonic clock of the event loop) + + .. versionadded:: 3.1 + + """ + now = current_time() + await sleep(max(deadline - now, 0)) + + +def current_time() -> float: + """ + Return the current value of the event loop's internal clock. + + :return: the clock value (seconds) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().current_time() + + +def get_all_backends() -> tuple[str, ...]: + """Return a tuple of the names of all built-in backends.""" + return BACKENDS + + +def get_available_backends() -> tuple[str, ...]: + """ + Test for the availability of built-in backends. + + :return a tuple of the built-in backend names that were successfully imported + + .. versionadded:: 4.12 + + """ + available_backends: list[str] = [] + for backend_name in get_all_backends(): + try: + get_async_backend(backend_name) + except ImportError: + continue + + available_backends.append(backend_name) + + return tuple(available_backends) + + +def get_cancelled_exc_class() -> type[BaseException]: + """ + Return the current async library's cancellation exception class. + + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().cancelled_exception_class() + + +# +# Private API +# + + +@contextmanager +def claim_worker_thread( + backend_class: type[AsyncBackend], token: object +) -> Generator[Any, None, None]: + from ..lowlevel import EventLoopToken + + threadlocals.current_token = EventLoopToken(backend_class, token) + try: + yield + finally: + del threadlocals.current_token + + +def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]: + if asynclib_name is None: + asynclib_name = current_async_library() + if not asynclib_name: + raise NoEventLoopError( + f"Not currently running on any asynchronous event loop. " + f"Available async backends: {', '.join(get_all_backends())}" + ) + + # We use our own dict instead of sys.modules to get the already imported back-end + # class because the appropriate modules in sys.modules could potentially be only + # partially initialized + try: + return loaded_backends[asynclib_name] + except KeyError: + module = import_module(f"anyio._backends._{asynclib_name}") + loaded_backends[asynclib_name] = module.backend_class + return module.backend_class + + +def current_async_library() -> str | None: + if sniffio is None: + # If sniffio is not installed, we assume we're either running asyncio or nothing + import asyncio + + try: + asyncio.get_running_loop() + return "asyncio" + except RuntimeError: + pass + else: + try: + return sniffio.current_async_library() + except sniffio.AsyncLibraryNotFoundError: + pass + + return None + + +def set_current_async_library(asynclib_name: str | None) -> Token | None: + # no-op if sniffio is not installed + if sniffio is None: + return None + + return sniffio.current_async_library_cvar.set(asynclib_name) + + +def reset_current_async_library(token: Token | None) -> None: + if token is not None: + sniffio.current_async_library_cvar.reset(token) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_exceptions.py b/.venv/lib/python3.10/site-packages/anyio/_core/_exceptions.py new file mode 100644 index 0000000..3776bed --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_exceptions.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import sys +from collections.abc import Generator +from textwrap import dedent +from typing import Any + +if sys.version_info < (3, 11): + from exceptiongroup import BaseExceptionGroup + + +class BrokenResourceError(Exception): + """ + Raised when trying to use a resource that has been rendered unusable due to external + causes (e.g. a send stream whose peer has disconnected). + """ + + +class BrokenWorkerProcess(Exception): + """ + Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or + otherwise misbehaves. + """ + + +class BrokenWorkerInterpreter(Exception): + """ + Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is + raised in the subinterpreter. + """ + + def __init__(self, excinfo: Any): + # This was adapted from concurrent.futures.interpreter.ExecutionFailed + msg = excinfo.formatted + if not msg: + if excinfo.type and excinfo.msg: + msg = f"{excinfo.type.__name__}: {excinfo.msg}" + else: + msg = excinfo.type.__name__ or excinfo.msg + + super().__init__(msg) + self.excinfo = excinfo + + def __str__(self) -> str: + try: + formatted = self.excinfo.errdisplay + except Exception: + return super().__str__() + else: + return dedent( + f""" + {super().__str__()} + + Uncaught in the interpreter: + + {formatted} + """.strip() + ) + + +class BusyResourceError(Exception): + """ + Raised when two tasks are trying to read from or write to the same resource + concurrently. + """ + + def __init__(self, action: str): + super().__init__(f"Another task is already {action} this resource") + + +class ClosedResourceError(Exception): + """Raised when trying to use a resource that has been closed.""" + + +class ConnectionFailed(OSError): + """ + Raised when a connection attempt fails. + + .. note:: This class inherits from :exc:`OSError` for backwards compatibility. + """ + + +def iterate_exceptions( + exception: BaseException, +) -> Generator[BaseException, None, None]: + if isinstance(exception, BaseExceptionGroup): + for exc in exception.exceptions: + yield from iterate_exceptions(exc) + else: + yield exception + + +class DelimiterNotFound(Exception): + """ + Raised during + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the + maximum number of bytes has been read without the delimiter being found. + """ + + def __init__(self, max_bytes: int) -> None: + super().__init__( + f"The delimiter was not found among the first {max_bytes} bytes" + ) + + +class EndOfStream(Exception): + """ + Raised when trying to read from a stream that has been closed from the other end. + """ + + +class IncompleteRead(Exception): + """ + Raised during + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or + :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the + connection is closed before the requested amount of bytes has been read. + """ + + def __init__(self) -> None: + super().__init__( + "The stream was closed before the read operation could be completed" + ) + + +class TypedAttributeLookupError(LookupError): + """ + Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute + is not found and no default value has been given. + """ + + +class WouldBlock(Exception): + """Raised by ``X_nowait`` functions if ``X()`` would block.""" + + +class NoEventLoopError(RuntimeError): + """ + Raised by several functions that require an event loop to be running in the current + thread when there is no running event loop. + + This is also raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` + if not calling from an AnyIO worker thread, and no ``token`` was passed. + """ + + +class RunFinishedError(RuntimeError): + """ + Raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` if the event + loop associated with the explicitly passed token has already finished. + """ + + def __init__(self) -> None: + super().__init__( + "The event loop associated with the given token has already finished" + ) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_fileio.py b/.venv/lib/python3.10/site-packages/anyio/_core/_fileio.py new file mode 100644 index 0000000..3bb8c84 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_fileio.py @@ -0,0 +1,799 @@ +from __future__ import annotations + +import os +import pathlib +import sys +from collections.abc import ( + AsyncIterator, + Callable, + Iterable, + Iterator, + Sequence, +) +from dataclasses import dataclass +from functools import partial +from os import PathLike +from typing import ( + IO, + TYPE_CHECKING, + Any, + AnyStr, + ClassVar, + Final, + Generic, + overload, +) + +from .. import to_thread +from ..abc import AsyncResource + +if TYPE_CHECKING: + from types import ModuleType + + from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer +else: + ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object + + +class AsyncFile(AsyncResource, Generic[AnyStr]): + """ + An asynchronous file object. + + This class wraps a standard file object and provides async friendly versions of the + following blocking methods (where available on the original file object): + + * read + * read1 + * readline + * readlines + * readinto + * readinto1 + * write + * writelines + * truncate + * seek + * tell + * flush + + All other methods are directly passed through. + + This class supports the asynchronous context manager protocol which closes the + underlying file at the end of the context block. + + This class also supports asynchronous iteration:: + + async with await open_file(...) as f: + async for line in f: + print(line) + """ + + def __init__(self, fp: IO[AnyStr]) -> None: + self._fp: Any = fp + + def __getattr__(self, name: str) -> object: + return getattr(self._fp, name) + + @property + def wrapped(self) -> IO[AnyStr]: + """The wrapped file object.""" + return self._fp + + async def __aiter__(self) -> AsyncIterator[AnyStr]: + while True: + line = await self.readline() + if line: + yield line + else: + break + + async def aclose(self) -> None: + return await to_thread.run_sync(self._fp.close) + + async def read(self, size: int = -1) -> AnyStr: + return await to_thread.run_sync(self._fp.read, size) + + async def read1(self: AsyncFile[bytes], size: int = -1) -> bytes: + return await to_thread.run_sync(self._fp.read1, size) + + async def readline(self) -> AnyStr: + return await to_thread.run_sync(self._fp.readline) + + async def readlines(self) -> list[AnyStr]: + return await to_thread.run_sync(self._fp.readlines) + + async def readinto(self: AsyncFile[bytes], b: WriteableBuffer) -> int: + return await to_thread.run_sync(self._fp.readinto, b) + + async def readinto1(self: AsyncFile[bytes], b: WriteableBuffer) -> int: + return await to_thread.run_sync(self._fp.readinto1, b) + + @overload + async def write(self: AsyncFile[bytes], b: ReadableBuffer) -> int: ... + + @overload + async def write(self: AsyncFile[str], b: str) -> int: ... + + async def write(self, b: ReadableBuffer | str) -> int: + return await to_thread.run_sync(self._fp.write, b) + + @overload + async def writelines( + self: AsyncFile[bytes], lines: Iterable[ReadableBuffer] + ) -> None: ... + + @overload + async def writelines(self: AsyncFile[str], lines: Iterable[str]) -> None: ... + + async def writelines(self, lines: Iterable[ReadableBuffer] | Iterable[str]) -> None: + return await to_thread.run_sync(self._fp.writelines, lines) + + async def truncate(self, size: int | None = None) -> int: + return await to_thread.run_sync(self._fp.truncate, size) + + async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int: + return await to_thread.run_sync(self._fp.seek, offset, whence) + + async def tell(self) -> int: + return await to_thread.run_sync(self._fp.tell) + + async def flush(self) -> None: + return await to_thread.run_sync(self._fp.flush) + + +@overload +async def open_file( + file: str | PathLike[str] | int, + mode: OpenBinaryMode, + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: Callable[[str, int], int] | None = ..., +) -> AsyncFile[bytes]: ... + + +@overload +async def open_file( + file: str | PathLike[str] | int, + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + closefd: bool = ..., + opener: Callable[[str, int], int] | None = ..., +) -> AsyncFile[str]: ... + + +async def open_file( + file: str | PathLike[str] | int, + mode: str = "r", + buffering: int = -1, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + closefd: bool = True, + opener: Callable[[str, int], int] | None = None, +) -> AsyncFile[Any]: + """ + Open a file asynchronously. + + The arguments are exactly the same as for the builtin :func:`open`. + + :return: an asynchronous file object + + """ + fp = await to_thread.run_sync( + open, file, mode, buffering, encoding, errors, newline, closefd, opener + ) + return AsyncFile(fp) + + +def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]: + """ + Wrap an existing file as an asynchronous file. + + :param file: an existing file-like object + :return: an asynchronous file object + + """ + return AsyncFile(file) + + +@dataclass(eq=False) +class _PathIterator(AsyncIterator["Path"]): + iterator: Iterator[PathLike[str]] + + async def __anext__(self) -> Path: + nextval = await to_thread.run_sync( + next, self.iterator, None, abandon_on_cancel=True + ) + if nextval is None: + raise StopAsyncIteration from None + + return Path(nextval) + + +class Path: + """ + An asynchronous version of :class:`pathlib.Path`. + + This class cannot be substituted for :class:`pathlib.Path` or + :class:`pathlib.PurePath`, but it is compatible with the :class:`os.PathLike` + interface. + + It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for + the deprecated :meth:`~pathlib.Path.link_to` method. + + Some methods may be unavailable or have limited functionality, based on the Python + version: + + * :meth:`~pathlib.Path.copy` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.copy_into` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.from_uri` (available on Python 3.13 or later) + * :meth:`~pathlib.PurePath.full_match` (available on Python 3.13 or later) + * :attr:`~pathlib.Path.info` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.is_junction` (available on Python 3.12 or later) + * :meth:`~pathlib.PurePath.match` (the ``case_sensitive`` parameter is only + available on Python 3.13 or later) + * :meth:`~pathlib.Path.move` (available on Python 3.14 or later) + * :meth:`~pathlib.Path.move_into` (available on Python 3.14 or later) + * :meth:`~pathlib.PurePath.relative_to` (the ``walk_up`` parameter is only available + on Python 3.12 or later) + * :meth:`~pathlib.Path.walk` (available on Python 3.12 or later) + + Any methods that do disk I/O need to be awaited on. These methods are: + + * :meth:`~pathlib.Path.absolute` + * :meth:`~pathlib.Path.chmod` + * :meth:`~pathlib.Path.cwd` + * :meth:`~pathlib.Path.exists` + * :meth:`~pathlib.Path.expanduser` + * :meth:`~pathlib.Path.group` + * :meth:`~pathlib.Path.hardlink_to` + * :meth:`~pathlib.Path.home` + * :meth:`~pathlib.Path.is_block_device` + * :meth:`~pathlib.Path.is_char_device` + * :meth:`~pathlib.Path.is_dir` + * :meth:`~pathlib.Path.is_fifo` + * :meth:`~pathlib.Path.is_file` + * :meth:`~pathlib.Path.is_junction` + * :meth:`~pathlib.Path.is_mount` + * :meth:`~pathlib.Path.is_socket` + * :meth:`~pathlib.Path.is_symlink` + * :meth:`~pathlib.Path.lchmod` + * :meth:`~pathlib.Path.lstat` + * :meth:`~pathlib.Path.mkdir` + * :meth:`~pathlib.Path.open` + * :meth:`~pathlib.Path.owner` + * :meth:`~pathlib.Path.read_bytes` + * :meth:`~pathlib.Path.read_text` + * :meth:`~pathlib.Path.readlink` + * :meth:`~pathlib.Path.rename` + * :meth:`~pathlib.Path.replace` + * :meth:`~pathlib.Path.resolve` + * :meth:`~pathlib.Path.rmdir` + * :meth:`~pathlib.Path.samefile` + * :meth:`~pathlib.Path.stat` + * :meth:`~pathlib.Path.symlink_to` + * :meth:`~pathlib.Path.touch` + * :meth:`~pathlib.Path.unlink` + * :meth:`~pathlib.Path.walk` + * :meth:`~pathlib.Path.write_bytes` + * :meth:`~pathlib.Path.write_text` + + Additionally, the following methods return an async iterator yielding + :class:`~.Path` objects: + + * :meth:`~pathlib.Path.glob` + * :meth:`~pathlib.Path.iterdir` + * :meth:`~pathlib.Path.rglob` + """ + + __slots__ = "_path", "__weakref__" + + __weakref__: Any + + def __init__(self, *args: str | PathLike[str]) -> None: + self._path: Final[pathlib.Path] = pathlib.Path(*args) + + def __fspath__(self) -> str: + return self._path.__fspath__() + + if sys.version_info >= (3, 15): + + def __vfspath__(self) -> str: + return self._path.__vfspath__() + + def __str__(self) -> str: + return self._path.__str__() + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.as_posix()!r})" + + def __bytes__(self) -> bytes: + return self._path.__bytes__() + + def __hash__(self) -> int: + return self._path.__hash__() + + def __eq__(self, other: object) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__eq__(target) + + def __lt__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__lt__(target) + + def __le__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__le__(target) + + def __gt__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__gt__(target) + + def __ge__(self, other: pathlib.PurePath | Path) -> bool: + target = other._path if isinstance(other, Path) else other + return self._path.__ge__(target) + + def __truediv__(self, other: str | PathLike[str]) -> Path: + return Path(self._path / other) + + def __rtruediv__(self, other: str | PathLike[str]) -> Path: + return Path(other) / self + + @property + def parts(self) -> tuple[str, ...]: + return self._path.parts + + @property + def drive(self) -> str: + return self._path.drive + + @property + def root(self) -> str: + return self._path.root + + @property + def anchor(self) -> str: + return self._path.anchor + + @property + def parents(self) -> Sequence[Path]: + return tuple(Path(p) for p in self._path.parents) + + @property + def parent(self) -> Path: + return Path(self._path.parent) + + @property + def name(self) -> str: + return self._path.name + + @property + def suffix(self) -> str: + return self._path.suffix + + @property + def suffixes(self) -> list[str]: + return self._path.suffixes + + @property + def stem(self) -> str: + return self._path.stem + + async def absolute(self) -> Path: + path = await to_thread.run_sync(self._path.absolute) + return Path(path) + + def as_posix(self) -> str: + return self._path.as_posix() + + def as_uri(self) -> str: + return self._path.as_uri() + + if sys.version_info >= (3, 13): + parser: ClassVar[ModuleType] = pathlib.Path.parser + + @classmethod + def from_uri(cls, uri: str) -> Path: + return Path(pathlib.Path.from_uri(uri)) + + def full_match( + self, path_pattern: str, *, case_sensitive: bool | None = None + ) -> bool: + return self._path.full_match(path_pattern, case_sensitive=case_sensitive) + + def match( + self, path_pattern: str, *, case_sensitive: bool | None = None + ) -> bool: + return self._path.match(path_pattern, case_sensitive=case_sensitive) + else: + + def match(self, path_pattern: str) -> bool: + return self._path.match(path_pattern) + + if sys.version_info >= (3, 14): + + @property + def info(self) -> Any: # TODO: add return type annotation when Typeshed gets it + return self._path.info + + async def copy( + self, + target: str | os.PathLike[str], + *, + follow_symlinks: bool = True, + preserve_metadata: bool = False, + ) -> Path: + func = partial( + self._path.copy, + follow_symlinks=follow_symlinks, + preserve_metadata=preserve_metadata, + ) + return Path(await to_thread.run_sync(func, pathlib.Path(target))) + + async def copy_into( + self, + target_dir: str | os.PathLike[str], + *, + follow_symlinks: bool = True, + preserve_metadata: bool = False, + ) -> Path: + func = partial( + self._path.copy_into, + follow_symlinks=follow_symlinks, + preserve_metadata=preserve_metadata, + ) + return Path(await to_thread.run_sync(func, pathlib.Path(target_dir))) + + async def move(self, target: str | os.PathLike[str]) -> Path: + # Upstream does not handle anyio.Path properly as a PathLike + target = pathlib.Path(target) + return Path(await to_thread.run_sync(self._path.move, target)) + + async def move_into( + self, + target_dir: str | os.PathLike[str], + ) -> Path: + return Path(await to_thread.run_sync(self._path.move_into, target_dir)) + + def is_relative_to(self, other: str | PathLike[str]) -> bool: + try: + self.relative_to(other) + return True + except ValueError: + return False + + async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None: + func = partial(os.chmod, follow_symlinks=follow_symlinks) + return await to_thread.run_sync(func, self._path, mode) + + @classmethod + async def cwd(cls) -> Path: + path = await to_thread.run_sync(pathlib.Path.cwd) + return cls(path) + + async def exists(self) -> bool: + return await to_thread.run_sync(self._path.exists, abandon_on_cancel=True) + + async def expanduser(self) -> Path: + return Path( + await to_thread.run_sync(self._path.expanduser, abandon_on_cancel=True) + ) + + if sys.version_info < (3, 12): + # Python 3.11 and earlier + def glob(self, pattern: str) -> AsyncIterator[Path]: + gen = self._path.glob(pattern) + return _PathIterator(gen) + elif (3, 12) <= sys.version_info < (3, 13): + # changed in Python 3.12: + # - The case_sensitive parameter was added. + def glob( + self, + pattern: str, + *, + case_sensitive: bool | None = None, + ) -> AsyncIterator[Path]: + gen = self._path.glob(pattern, case_sensitive=case_sensitive) + return _PathIterator(gen) + elif sys.version_info >= (3, 13): + # Changed in Python 3.13: + # - The recurse_symlinks parameter was added. + # - The pattern parameter accepts a path-like object. + def glob( # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block + self, + pattern: str | PathLike[str], + *, + case_sensitive: bool | None = None, + recurse_symlinks: bool = False, + ) -> AsyncIterator[Path]: + gen = self._path.glob( + pattern, # type: ignore[arg-type] + case_sensitive=case_sensitive, + recurse_symlinks=recurse_symlinks, + ) + return _PathIterator(gen) + + async def group(self) -> str: + return await to_thread.run_sync(self._path.group, abandon_on_cancel=True) + + async def hardlink_to( + self, target: str | bytes | PathLike[str] | PathLike[bytes] + ) -> None: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(os.link, target, self) + + @classmethod + async def home(cls) -> Path: + home_path = await to_thread.run_sync(pathlib.Path.home) + return cls(home_path) + + def is_absolute(self) -> bool: + return self._path.is_absolute() + + async def is_block_device(self) -> bool: + return await to_thread.run_sync( + self._path.is_block_device, abandon_on_cancel=True + ) + + async def is_char_device(self) -> bool: + return await to_thread.run_sync( + self._path.is_char_device, abandon_on_cancel=True + ) + + async def is_dir(self) -> bool: + return await to_thread.run_sync(self._path.is_dir, abandon_on_cancel=True) + + async def is_fifo(self) -> bool: + return await to_thread.run_sync(self._path.is_fifo, abandon_on_cancel=True) + + async def is_file(self) -> bool: + return await to_thread.run_sync(self._path.is_file, abandon_on_cancel=True) + + if sys.version_info >= (3, 12): + + async def is_junction(self) -> bool: + return await to_thread.run_sync(self._path.is_junction) + + async def is_mount(self) -> bool: + return await to_thread.run_sync( + os.path.ismount, self._path, abandon_on_cancel=True + ) + + if sys.version_info < (3, 15): + + def is_reserved(self) -> bool: + return self._path.is_reserved() + + async def is_socket(self) -> bool: + return await to_thread.run_sync(self._path.is_socket, abandon_on_cancel=True) + + async def is_symlink(self) -> bool: + return await to_thread.run_sync(self._path.is_symlink, abandon_on_cancel=True) + + async def iterdir(self) -> AsyncIterator[Path]: + gen = ( + self._path.iterdir() + if sys.version_info < (3, 13) + else await to_thread.run_sync(self._path.iterdir, abandon_on_cancel=True) + ) + async for path in _PathIterator(gen): + yield path + + def joinpath(self, *args: str | PathLike[str]) -> Path: + return Path(self._path.joinpath(*args)) + + async def lchmod(self, mode: int) -> None: + await to_thread.run_sync(self._path.lchmod, mode) + + async def lstat(self) -> os.stat_result: + return await to_thread.run_sync(self._path.lstat, abandon_on_cancel=True) + + async def mkdir( + self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False + ) -> None: + await to_thread.run_sync(self._path.mkdir, mode, parents, exist_ok) + + @overload + async def open( + self, + mode: OpenBinaryMode, + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + ) -> AsyncFile[bytes]: ... + + @overload + async def open( + self, + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + errors: str | None = ..., + newline: str | None = ..., + ) -> AsyncFile[str]: ... + + async def open( + self, + mode: str = "r", + buffering: int = -1, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + ) -> AsyncFile[Any]: + fp = await to_thread.run_sync( + self._path.open, mode, buffering, encoding, errors, newline + ) + return AsyncFile(fp) + + async def owner(self) -> str: + return await to_thread.run_sync(self._path.owner, abandon_on_cancel=True) + + async def read_bytes(self) -> bytes: + return await to_thread.run_sync(self._path.read_bytes) + + async def read_text( + self, encoding: str | None = None, errors: str | None = None + ) -> str: + return await to_thread.run_sync(self._path.read_text, encoding, errors) + + if sys.version_info >= (3, 12): + + def relative_to( + self, *other: str | PathLike[str], walk_up: bool = False + ) -> Path: + # relative_to() should work with any PathLike but it doesn't + others = [pathlib.Path(other) for other in other] + return Path(self._path.relative_to(*others, walk_up=walk_up)) + + else: + + def relative_to(self, *other: str | PathLike[str]) -> Path: + return Path(self._path.relative_to(*other)) + + async def readlink(self) -> Path: + target = await to_thread.run_sync(os.readlink, self._path) + return Path(target) + + async def rename(self, target: str | pathlib.PurePath | Path) -> Path: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.rename, target) + return Path(target) + + async def replace(self, target: str | pathlib.PurePath | Path) -> Path: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.replace, target) + return Path(target) + + async def resolve(self, strict: bool = False) -> Path: + func = partial(self._path.resolve, strict=strict) + return Path(await to_thread.run_sync(func, abandon_on_cancel=True)) + + if sys.version_info < (3, 12): + # Pre Python 3.12 + def rglob(self, pattern: str) -> AsyncIterator[Path]: + gen = self._path.rglob(pattern) + return _PathIterator(gen) + elif (3, 12) <= sys.version_info < (3, 13): + # Changed in Python 3.12: + # - The case_sensitive parameter was added. + def rglob( + self, pattern: str, *, case_sensitive: bool | None = None + ) -> AsyncIterator[Path]: + gen = self._path.rglob(pattern, case_sensitive=case_sensitive) + return _PathIterator(gen) + elif sys.version_info >= (3, 13): + # Changed in Python 3.13: + # - The recurse_symlinks parameter was added. + # - The pattern parameter accepts a path-like object. + def rglob( # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block + self, + pattern: str | PathLike[str], + *, + case_sensitive: bool | None = None, + recurse_symlinks: bool = False, + ) -> AsyncIterator[Path]: + gen = self._path.rglob( + pattern, # type: ignore[arg-type] + case_sensitive=case_sensitive, + recurse_symlinks=recurse_symlinks, + ) + return _PathIterator(gen) + + async def rmdir(self) -> None: + await to_thread.run_sync(self._path.rmdir) + + async def samefile(self, other_path: str | PathLike[str]) -> bool: + if isinstance(other_path, Path): + other_path = other_path._path + + return await to_thread.run_sync( + self._path.samefile, other_path, abandon_on_cancel=True + ) + + async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result: + func = partial(os.stat, follow_symlinks=follow_symlinks) + return await to_thread.run_sync(func, self._path, abandon_on_cancel=True) + + async def symlink_to( + self, + target: str | bytes | PathLike[str] | PathLike[bytes], + target_is_directory: bool = False, + ) -> None: + if isinstance(target, Path): + target = target._path + + await to_thread.run_sync(self._path.symlink_to, target, target_is_directory) + + async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None: + await to_thread.run_sync(self._path.touch, mode, exist_ok) + + async def unlink(self, missing_ok: bool = False) -> None: + try: + await to_thread.run_sync(self._path.unlink) + except FileNotFoundError: + if not missing_ok: + raise + + if sys.version_info >= (3, 12): + + async def walk( + self, + top_down: bool = True, + on_error: Callable[[OSError], object] | None = None, + follow_symlinks: bool = False, + ) -> AsyncIterator[tuple[Path, list[str], list[str]]]: + def get_next_value() -> tuple[pathlib.Path, list[str], list[str]] | None: + try: + return next(gen) + except StopIteration: + return None + + gen = self._path.walk(top_down, on_error, follow_symlinks) + while True: + value = await to_thread.run_sync(get_next_value) + if value is None: + return + + root, dirs, paths = value + yield Path(root), dirs, paths + + def with_name(self, name: str) -> Path: + return Path(self._path.with_name(name)) + + def with_stem(self, stem: str) -> Path: + return Path(self._path.with_name(stem + self._path.suffix)) + + def with_suffix(self, suffix: str) -> Path: + return Path(self._path.with_suffix(suffix)) + + def with_segments(self, *pathsegments: str | PathLike[str]) -> Path: + return Path(*pathsegments) + + async def write_bytes(self, data: bytes) -> int: + return await to_thread.run_sync(self._path.write_bytes, data) + + async def write_text( + self, + data: str, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + ) -> int: + return await to_thread.run_sync( + self._path.write_text, data, encoding, errors, newline + ) + + +PathLike.register(Path) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_resources.py b/.venv/lib/python3.10/site-packages/anyio/_core/_resources.py new file mode 100644 index 0000000..b9a5344 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_resources.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from ..abc import AsyncResource +from ._tasks import CancelScope + + +async def aclose_forcefully(resource: AsyncResource) -> None: + """ + Close an asynchronous resource in a cancelled scope. + + Doing this closes the resource without waiting on anything. + + :param resource: the resource to close + + """ + with CancelScope() as scope: + scope.cancel() + await resource.aclose() diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_signals.py b/.venv/lib/python3.10/site-packages/anyio/_core/_signals.py new file mode 100644 index 0000000..e24c79e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_signals.py @@ -0,0 +1,29 @@ +from __future__ import annotations + +from collections.abc import AsyncIterator +from contextlib import AbstractContextManager +from signal import Signals + +from ._eventloop import get_async_backend + + +def open_signal_receiver( + *signals: Signals, +) -> AbstractContextManager[AsyncIterator[Signals]]: + """ + Start receiving operating system signals. + + :param signals: signals to receive (e.g. ``signal.SIGINT``) + :return: an asynchronous context manager for an asynchronous iterator which yields + signal numbers + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. warning:: Windows does not support signals natively so it is best to avoid + relying on this in cross-platform applications. + + .. warning:: On asyncio, this permanently replaces any previous signal handler for + the given signals, as set via :meth:`~asyncio.loop.add_signal_handler`. + + """ + return get_async_backend().open_signal_receiver(*signals) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_sockets.py b/.venv/lib/python3.10/site-packages/anyio/_core/_sockets.py new file mode 100644 index 0000000..6c99b3a --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_sockets.py @@ -0,0 +1,1003 @@ +from __future__ import annotations + +import errno +import os +import socket +import ssl +import stat +import sys +from collections.abc import Awaitable +from dataclasses import dataclass +from ipaddress import IPv4Address, IPv6Address, ip_address +from os import PathLike, chmod +from socket import AddressFamily, SocketKind +from typing import TYPE_CHECKING, Any, Literal, cast, overload + +from .. import ConnectionFailed, to_thread +from ..abc import ( + ByteStreamConnectable, + ConnectedUDPSocket, + ConnectedUNIXDatagramSocket, + IPAddressType, + IPSockAddrType, + SocketListener, + SocketStream, + UDPSocket, + UNIXDatagramSocket, + UNIXSocketStream, +) +from ..streams.stapled import MultiListener +from ..streams.tls import TLSConnectable, TLSStream +from ._eventloop import get_async_backend +from ._resources import aclose_forcefully +from ._synchronization import Event +from ._tasks import create_task_group, move_on_after + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike +else: + FileDescriptorLike = object + +if sys.version_info < (3, 11): + from exceptiongroup import ExceptionGroup + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + +if sys.version_info < (3, 13): + from typing_extensions import deprecated +else: + from warnings import deprecated + +IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41) # https://bugs.python.org/issue29515 + +AnyIPAddressFamily = Literal[ + AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6 +] +IPAddressFamily = Literal[AddressFamily.AF_INET, AddressFamily.AF_INET6] + + +# tls_hostname given +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str, + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# ssl_context given +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + ssl_context: ssl.SSLContext, + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# tls=True +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + tls: Literal[True], + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> TLSStream: ... + + +# tls=False +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + tls: Literal[False], + ssl_context: ssl.SSLContext | None = ..., + tls_standard_compatible: bool = ..., + tls_hostname: str | None = ..., + happy_eyeballs_delay: float = ..., +) -> SocketStream: ... + + +# No TLS arguments +@overload +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = ..., + happy_eyeballs_delay: float = ..., +) -> SocketStream: ... + + +async def connect_tcp( + remote_host: IPAddressType, + remote_port: int, + *, + local_host: IPAddressType | None = None, + tls: bool = False, + ssl_context: ssl.SSLContext | None = None, + tls_standard_compatible: bool = True, + tls_hostname: str | None = None, + happy_eyeballs_delay: float = 0.25, +) -> SocketStream | TLSStream: + """ + Connect to a host using the TCP protocol. + + This function implements the stateless version of the Happy Eyeballs algorithm (RFC + 6555). If ``remote_host`` is a host name that resolves to multiple IP addresses, + each one is tried until one connection attempt succeeds. If the first attempt does + not connected within 250 milliseconds, a second attempt is started using the next + address in the list, and so on. On IPv6 enabled systems, an IPv6 address (if + available) is tried first. + + When the connection has been established, a TLS handshake will be done if either + ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``. + + :param remote_host: the IP address or host name to connect to + :param remote_port: port on the target host to connect to + :param local_host: the interface address or name to bind the socket to before + connecting + :param tls: ``True`` to do a TLS handshake with the connected stream and return a + :class:`~anyio.streams.tls.TLSStream` instead + :param ssl_context: the SSL context object to use (if omitted, a default context is + created) + :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake + before closing the stream and requires that the server does this as well. + Otherwise, :exc:`~ssl.SSLEOFError` may be raised during reads from the stream. + Some protocols, such as HTTP, require this option to be ``False``. + See :meth:`~ssl.SSLContext.wrap_socket` for details. + :param tls_hostname: host name to check the server certificate against (defaults to + the value of ``remote_host``) + :param happy_eyeballs_delay: delay (in seconds) before starting the next connection + attempt + :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream + :raises ConnectionFailed: if the connection fails + + """ + # Placed here due to https://github.com/python/mypy/issues/7057 + connected_stream: SocketStream | None = None + + async def try_connect(remote_host: str, event: Event) -> None: + nonlocal connected_stream + try: + stream = await asynclib.connect_tcp(remote_host, remote_port, local_address) + except OSError as exc: + oserrors.append(exc) + return + else: + if connected_stream is None: + connected_stream = stream + tg.cancel_scope.cancel() + else: + await stream.aclose() + finally: + event.set() + + asynclib = get_async_backend() + local_address: IPSockAddrType | None = None + family = socket.AF_UNSPEC + if local_host: + gai_res = await getaddrinfo(str(local_host), None) + family, *_, local_address = gai_res[0] + + target_host = str(remote_host) + try: + addr_obj = ip_address(remote_host) + except ValueError: + addr_obj = None + + if addr_obj is not None: + if isinstance(addr_obj, IPv6Address): + target_addrs = [(socket.AF_INET6, addr_obj.compressed)] + else: + target_addrs = [(socket.AF_INET, addr_obj.compressed)] + else: + # getaddrinfo() will raise an exception if name resolution fails + gai_res = await getaddrinfo( + target_host, remote_port, family=family, type=socket.SOCK_STREAM + ) + + # Organize the list so that the first address is an IPv6 address (if available) + # and the second one is an IPv4 addresses. The rest can be in whatever order. + v6_found = v4_found = False + target_addrs = [] + for af, *_, sa in gai_res: + if af == socket.AF_INET6 and not v6_found: + v6_found = True + target_addrs.insert(0, (af, sa[0])) + elif af == socket.AF_INET and not v4_found and v6_found: + v4_found = True + target_addrs.insert(1, (af, sa[0])) + else: + target_addrs.append((af, sa[0])) + + oserrors: list[OSError] = [] + try: + async with create_task_group() as tg: + for _af, addr in target_addrs: + event = Event() + tg.start_soon(try_connect, addr, event) + with move_on_after(happy_eyeballs_delay): + await event.wait() + + if connected_stream is None: + cause = ( + oserrors[0] + if len(oserrors) == 1 + else ExceptionGroup("multiple connection attempts failed", oserrors) + ) + raise OSError("All connection attempts failed") from cause + finally: + oserrors.clear() + + if tls or tls_hostname or ssl_context: + try: + return await TLSStream.wrap( + connected_stream, + server_side=False, + hostname=tls_hostname or str(remote_host), + ssl_context=ssl_context, + standard_compatible=tls_standard_compatible, + ) + except BaseException: + await aclose_forcefully(connected_stream) + raise + + return connected_stream + + +async def connect_unix(path: str | bytes | PathLike[Any]) -> UNIXSocketStream: + """ + Connect to the given UNIX socket. + + Not available on Windows. + + :param path: path to the socket + :return: a socket stream object + :raises ConnectionFailed: if the connection fails + + """ + path = os.fspath(path) + return await get_async_backend().connect_unix(path) + + +async def create_tcp_listener( + *, + local_host: IPAddressType | None = None, + local_port: int = 0, + family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC, + backlog: int = 65536, + reuse_port: bool = False, +) -> MultiListener[SocketStream]: + """ + Create a TCP socket listener. + + :param local_port: port number to listen on + :param local_host: IP address of the interface to listen on. If omitted, listen on + all IPv4 and IPv6 interfaces. To listen on all interfaces on a specific address + family, use ``0.0.0.0`` for IPv4 or ``::`` for IPv6. + :param family: address family (used if ``local_host`` was omitted) + :param backlog: maximum number of queued incoming connections (up to a maximum of + 2**16, or 65536) + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a multi-listener object containing one or more socket listeners + :raises OSError: if there's an error creating a socket, or binding to one or more + interfaces failed + + """ + asynclib = get_async_backend() + backlog = min(backlog, 65536) + local_host = str(local_host) if local_host is not None else None + + def setup_raw_socket( + fam: AddressFamily, + bind_addr: tuple[str, int] | tuple[str, int, int, int], + *, + v6only: bool = True, + ) -> socket.socket: + sock = socket.socket(fam) + try: + sock.setblocking(False) + + if fam == AddressFamily.AF_INET6: + sock.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, v6only) + + # For Windows, enable exclusive address use. For others, enable address + # reuse. + if sys.platform == "win32": + sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1) + else: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + + if reuse_port: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + + # Workaround for #554 + if fam == socket.AF_INET6 and "%" in bind_addr[0]: + addr, scope_id = bind_addr[0].split("%", 1) + bind_addr = (addr, bind_addr[1], 0, int(scope_id)) + + sock.bind(bind_addr) + sock.listen(backlog) + except BaseException: + sock.close() + raise + + return sock + + # We passing type=0 on non-Windows platforms as a workaround for a uvloop bug + # where we don't get the correct scope ID for IPv6 link-local addresses when passing + # type=socket.SOCK_STREAM to getaddrinfo(): + # https://github.com/MagicStack/uvloop/issues/539 + gai_res = await getaddrinfo( + local_host, + local_port, + family=family, + type=socket.SOCK_STREAM if sys.platform == "win32" else 0, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + + # The set comprehension is here to work around a glibc bug: + # https://sourceware.org/bugzilla/show_bug.cgi?id=14969 + sockaddrs = sorted({res for res in gai_res if res[1] == SocketKind.SOCK_STREAM}) + + # Special case for dual-stack binding on the "any" interface + if ( + local_host is None + and family == AddressFamily.AF_UNSPEC + and socket.has_dualstack_ipv6() + and any(fam == AddressFamily.AF_INET6 for fam, *_ in gai_res) + ): + raw_socket = setup_raw_socket( + AddressFamily.AF_INET6, ("::", local_port), v6only=False + ) + listener = asynclib.create_tcp_listener(raw_socket) + return MultiListener([listener]) + + errors: list[OSError] = [] + try: + for _ in range(len(sockaddrs)): + listeners: list[SocketListener] = [] + bound_ephemeral_port = local_port + try: + for fam, *_, sockaddr in sockaddrs: + sockaddr = sockaddr[0], bound_ephemeral_port, *sockaddr[2:] + raw_socket = setup_raw_socket(fam, sockaddr) + + # Store the assigned port if an ephemeral port was requested, so + # we'll bind to the same port on all interfaces + if local_port == 0 and len(gai_res) > 1: + bound_ephemeral_port = raw_socket.getsockname()[1] + + listeners.append(asynclib.create_tcp_listener(raw_socket)) + except BaseException as exc: + for listener in listeners: + await listener.aclose() + + # If an ephemeral port was requested but binding the assigned port + # failed for another interface, rotate the address list and try again + if ( + isinstance(exc, OSError) + and exc.errno == errno.EADDRINUSE + and local_port == 0 + and bound_ephemeral_port + ): + errors.append(exc) + sockaddrs.append(sockaddrs.pop(0)) + continue + + raise + + return MultiListener(listeners) + + raise OSError( + f"Could not create {len(sockaddrs)} listeners with a consistent port" + ) from ExceptionGroup("Several bind attempts failed", errors) + finally: + del errors # Prevent reference cycles + + +async def create_unix_listener( + path: str | bytes | PathLike[Any], + *, + mode: int | None = None, + backlog: int = 65536, +) -> SocketListener: + """ + Create a UNIX socket listener. + + Not available on Windows. + + :param path: path of the socket + :param mode: permissions to set on the socket + :param backlog: maximum number of queued incoming connections (up to a maximum of + 2**16, or 65536) + :return: a listener object + + .. versionchanged:: 3.0 + If a socket already exists on the file system in the given path, it will be + removed first. + + """ + backlog = min(backlog, 65536) + raw_socket = await setup_unix_local_socket(path, mode, socket.SOCK_STREAM) + try: + raw_socket.listen(backlog) + return get_async_backend().create_unix_listener(raw_socket) + except BaseException: + raw_socket.close() + raise + + +async def create_udp_socket( + family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC, + *, + local_host: IPAddressType | None = None, + local_port: int = 0, + reuse_port: bool = False, +) -> UDPSocket: + """ + Create a UDP socket. + + If ``port`` has been given, the socket will be bound to this port on the local + machine, making this socket suitable for providing UDP based services. + + :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically + determined from ``local_host`` if omitted + :param local_host: IP address or host name of the local interface to bind to + :param local_port: local port to bind to + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a UDP socket + + """ + if family is AddressFamily.AF_UNSPEC and not local_host: + raise ValueError('Either "family" or "local_host" must be given') + + if local_host: + gai_res = await getaddrinfo( + str(local_host), + local_port, + family=family, + type=socket.SOCK_DGRAM, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + local_address = gai_res[0][-1] + elif family is AddressFamily.AF_INET6: + local_address = ("::", 0) + else: + local_address = ("0.0.0.0", 0) + + sock = await get_async_backend().create_udp_socket( + family, local_address, None, reuse_port + ) + return cast(UDPSocket, sock) + + +async def create_connected_udp_socket( + remote_host: IPAddressType, + remote_port: int, + *, + family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC, + local_host: IPAddressType | None = None, + local_port: int = 0, + reuse_port: bool = False, +) -> ConnectedUDPSocket: + """ + Create a connected UDP socket. + + Connected UDP sockets can only communicate with the specified remote host/port, an + any packets sent from other sources are dropped. + + :param remote_host: remote host to set as the default target + :param remote_port: port on the remote host to set as the default target + :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically + determined from ``local_host`` or ``remote_host`` if omitted + :param local_host: IP address or host name of the local interface to bind to + :param local_port: local port to bind to + :param reuse_port: ``True`` to allow multiple sockets to bind to the same + address/port (not supported on Windows) + :return: a connected UDP socket + + """ + local_address = None + if local_host: + gai_res = await getaddrinfo( + str(local_host), + local_port, + family=family, + type=socket.SOCK_DGRAM, + flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG, + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + local_address = gai_res[0][-1] + + gai_res = await getaddrinfo( + str(remote_host), remote_port, family=family, type=socket.SOCK_DGRAM + ) + family = cast(AnyIPAddressFamily, gai_res[0][0]) + remote_address = gai_res[0][-1] + + sock = await get_async_backend().create_udp_socket( + family, local_address, remote_address, reuse_port + ) + return cast(ConnectedUDPSocket, sock) + + +async def create_unix_datagram_socket( + *, + local_path: None | str | bytes | PathLike[Any] = None, + local_mode: int | None = None, +) -> UNIXDatagramSocket: + """ + Create a UNIX datagram socket. + + Not available on Windows. + + If ``local_path`` has been given, the socket will be bound to this path, making this + socket suitable for receiving datagrams from other processes. Other processes can + send datagrams to this socket only if ``local_path`` is set. + + If a socket already exists on the file system in the ``local_path``, it will be + removed first. + + :param local_path: the path on which to bind to + :param local_mode: permissions to set on the local socket + :return: a UNIX datagram socket + + """ + raw_socket = await setup_unix_local_socket( + local_path, local_mode, socket.SOCK_DGRAM + ) + return await get_async_backend().create_unix_datagram_socket(raw_socket, None) + + +async def create_connected_unix_datagram_socket( + remote_path: str | bytes | PathLike[Any], + *, + local_path: None | str | bytes | PathLike[Any] = None, + local_mode: int | None = None, +) -> ConnectedUNIXDatagramSocket: + """ + Create a connected UNIX datagram socket. + + Connected datagram sockets can only communicate with the specified remote path. + + If ``local_path`` has been given, the socket will be bound to this path, making + this socket suitable for receiving datagrams from other processes. Other processes + can send datagrams to this socket only if ``local_path`` is set. + + If a socket already exists on the file system in the ``local_path``, it will be + removed first. + + :param remote_path: the path to set as the default target + :param local_path: the path on which to bind to + :param local_mode: permissions to set on the local socket + :return: a connected UNIX datagram socket + + """ + remote_path = os.fspath(remote_path) + raw_socket = await setup_unix_local_socket( + local_path, local_mode, socket.SOCK_DGRAM + ) + return await get_async_backend().create_unix_datagram_socket( + raw_socket, remote_path + ) + + +async def getaddrinfo( + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, +) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int]]]: + """ + Look up a numeric IP address given a host name. + + Internationalized domain names are translated according to the (non-transitional) + IDNA 2008 standard. + + .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of + (host, port), unlike what :func:`socket.getaddrinfo` does. + + :param host: host name + :param port: port number + :param family: socket family (`'AF_INET``, ...) + :param type: socket type (``SOCK_STREAM``, ...) + :param proto: protocol number + :param flags: flags to pass to upstream ``getaddrinfo()`` + :return: list of tuples containing (family, type, proto, canonname, sockaddr) + + .. seealso:: :func:`socket.getaddrinfo` + + """ + # Handle unicode hostnames + if isinstance(host, str): + try: + encoded_host: bytes | None = host.encode("ascii") + except UnicodeEncodeError: + import idna + + encoded_host = idna.encode(host, uts46=True) + else: + encoded_host = host + + gai_res = await get_async_backend().getaddrinfo( + encoded_host, port, family=family, type=type, proto=proto, flags=flags + ) + return [ + (family, type, proto, canonname, convert_ipv6_sockaddr(sockaddr)) + for family, type, proto, canonname, sockaddr in gai_res + # filter out IPv6 results when IPv6 is disabled + if not isinstance(sockaddr[0], int) + ] + + +def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[tuple[str, str]]: + """ + Look up the host name of an IP address. + + :param sockaddr: socket address (e.g. (ipaddress, port) for IPv4) + :param flags: flags to pass to upstream ``getnameinfo()`` + :return: a tuple of (host name, service name) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. seealso:: :func:`socket.getnameinfo` + + """ + return get_async_backend().getnameinfo(sockaddr, flags) + + +@deprecated("This function is deprecated; use `wait_readable` instead") +def wait_socket_readable(sock: socket.socket) -> Awaitable[None]: + """ + .. deprecated:: 4.7.0 + Use :func:`wait_readable` instead. + + Wait until the given socket has data to be read. + + .. warning:: Only use this on raw sockets that have not been wrapped by any higher + level constructs like socket streams! + + :param sock: a socket object + :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the + socket to become readable + :raises ~anyio.BusyResourceError: if another task is already waiting for the socket + to become readable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_readable(sock.fileno()) + + +@deprecated("This function is deprecated; use `wait_writable` instead") +def wait_socket_writable(sock: socket.socket) -> Awaitable[None]: + """ + .. deprecated:: 4.7.0 + Use :func:`wait_writable` instead. + + Wait until the given socket can be written to. + + This does **NOT** work on Windows when using the asyncio backend with a proactor + event loop (default on py3.8+). + + .. warning:: Only use this on raw sockets that have not been wrapped by any higher + level constructs like socket streams! + + :param sock: a socket object + :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the + socket to become writable + :raises ~anyio.BusyResourceError: if another task is already waiting for the socket + to become writable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_writable(sock.fileno()) + + +def wait_readable(obj: FileDescriptorLike) -> Awaitable[None]: + """ + Wait until the given object has data to be read. + + On Unix systems, ``obj`` must either be an integer file descriptor, or else an + object with a ``.fileno()`` method which returns an integer file descriptor. Any + kind of file descriptor can be passed, though the exact semantics will depend on + your kernel. For example, this probably won't do anything useful for on-disk files. + + On Windows systems, ``obj`` must either be an integer ``SOCKET`` handle, or else an + object with a ``.fileno()`` method which returns an integer ``SOCKET`` handle. File + descriptors aren't supported, and neither are handles that refer to anything besides + a ``SOCKET``. + + On backends where this functionality is not natively provided (asyncio + ``ProactorEventLoop`` on Windows), it is provided using a separate selector thread + which is set to shut down when the interpreter shuts down. + + .. warning:: Don't use this on raw sockets that have been wrapped by any higher + level constructs like socket streams! + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the + object to become readable + :raises ~anyio.BusyResourceError: if another task is already waiting for the object + to become readable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().wait_readable(obj) + + +def wait_writable(obj: FileDescriptorLike) -> Awaitable[None]: + """ + Wait until the given object can be written to. + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the + object to become writable + :raises ~anyio.BusyResourceError: if another task is already waiting for the object + to become writable + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. seealso:: See the documentation of :func:`wait_readable` for the definition of + ``obj`` and notes on backend compatibility. + + .. warning:: Don't use this on raw sockets that have been wrapped by any higher + level constructs like socket streams! + + """ + return get_async_backend().wait_writable(obj) + + +def notify_closing(obj: FileDescriptorLike) -> None: + """ + Call this before closing a file descriptor (on Unix) or socket (on + Windows). This will cause any `wait_readable` or `wait_writable` + calls on the given object to immediately wake up and raise + `~anyio.ClosedResourceError`. + + This doesn't actually close the object – you still have to do that + yourself afterwards. Also, you want to be careful to make sure no + new tasks start waiting on the object in between when you call this + and when it's actually closed. So to close something properly, you + usually want to do these steps in order: + + 1. Explicitly mark the object as closed, so that any new attempts + to use it will abort before they start. + 2. Call `notify_closing` to wake up any already-existing users. + 3. Actually close the object. + + It's also possible to do them in a different order if that's more + convenient, *but only if* you make sure not to have any checkpoints in + between the steps. This way they all happen in a single atomic + step, so other tasks won't be able to tell what order they happened + in anyway. + + :param obj: an object with a ``.fileno()`` method or an integer handle + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + get_async_backend().notify_closing(obj) + + +# +# Private API +# + + +def convert_ipv6_sockaddr( + sockaddr: tuple[str, int, int, int] | tuple[str, int], +) -> tuple[str, int]: + """ + Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format. + + If the scope ID is nonzero, it is added to the address, separated with ``%``. + Otherwise the flow id and scope id are simply cut off from the tuple. + Any other kinds of socket addresses are returned as-is. + + :param sockaddr: the result of :meth:`~socket.socket.getsockname` + :return: the converted socket address + + """ + # This is more complicated than it should be because of MyPy + if isinstance(sockaddr, tuple) and len(sockaddr) == 4: + host, port, flowinfo, scope_id = sockaddr + if scope_id: + # PyPy (as of v7.3.11) leaves the interface name in the result, so + # we discard it and only get the scope ID from the end + # (https://foss.heptapod.net/pypy/pypy/-/issues/3938) + host = host.split("%")[0] + + # Add scope_id to the address + return f"{host}%{scope_id}", port + else: + return host, port + else: + return sockaddr + + +async def setup_unix_local_socket( + path: None | str | bytes | PathLike[Any], + mode: int | None, + socktype: int, +) -> socket.socket: + """ + Create a UNIX local socket object, deleting the socket at the given path if it + exists. + + Not available on Windows. + + :param path: path of the socket + :param mode: permissions to set on the socket + :param socktype: socket.SOCK_STREAM or socket.SOCK_DGRAM + + """ + path_str: str | None + if path is not None: + path_str = os.fsdecode(path) + + # Linux abstract namespace sockets aren't backed by a concrete file so skip stat call + if not path_str.startswith("\0"): + # Copied from pathlib... + try: + stat_result = os.stat(path) + except OSError as e: + if e.errno not in ( + errno.ENOENT, + errno.ENOTDIR, + errno.EBADF, + errno.ELOOP, + ): + raise + else: + if stat.S_ISSOCK(stat_result.st_mode): + os.unlink(path) + else: + path_str = None + + raw_socket = socket.socket(socket.AF_UNIX, socktype) + raw_socket.setblocking(False) + + if path_str is not None: + try: + await to_thread.run_sync(raw_socket.bind, path_str, abandon_on_cancel=True) + if mode is not None: + await to_thread.run_sync(chmod, path_str, mode, abandon_on_cancel=True) + except BaseException: + raw_socket.close() + raise + + return raw_socket + + +@dataclass +class TCPConnectable(ByteStreamConnectable): + """ + Connects to a TCP server at the given host and port. + + :param host: host name or IP address of the server + :param port: TCP port number of the server + """ + + host: str | IPv4Address | IPv6Address + port: int + + def __post_init__(self) -> None: + if self.port < 1 or self.port > 65535: + raise ValueError("TCP port number out of range") + + @override + async def connect(self) -> SocketStream: + try: + return await connect_tcp(self.host, self.port) + except OSError as exc: + raise ConnectionFailed( + f"error connecting to {self.host}:{self.port}: {exc}" + ) from exc + + +@dataclass +class UNIXConnectable(ByteStreamConnectable): + """ + Connects to a UNIX domain socket at the given path. + + :param path: the file system path of the socket + """ + + path: str | bytes | PathLike[str] | PathLike[bytes] + + @override + async def connect(self) -> UNIXSocketStream: + try: + return await connect_unix(self.path) + except OSError as exc: + raise ConnectionFailed(f"error connecting to {self.path!r}: {exc}") from exc + + +def as_connectable( + remote: ByteStreamConnectable + | tuple[str | IPv4Address | IPv6Address, int] + | str + | bytes + | PathLike[str], + /, + *, + tls: bool = False, + ssl_context: ssl.SSLContext | None = None, + tls_hostname: str | None = None, + tls_standard_compatible: bool = True, +) -> ByteStreamConnectable: + """ + Return a byte stream connectable from the given object. + + If a bytestream connectable is given, it is returned unchanged. + If a tuple of (host, port) is given, a TCP connectable is returned. + If a string or bytes path is given, a UNIX connectable is returned. + + If ``tls=True``, the connectable will be wrapped in a + :class:`~.streams.tls.TLSConnectable`. + + :param remote: a connectable, a tuple of (host, port) or a path to a UNIX socket + :param tls: if ``True``, wrap the plaintext connectable in a + :class:`~.streams.tls.TLSConnectable`, using the provided TLS settings) + :param ssl_context: if ``tls=True``, the SSLContext object to use (if not provided, + a secure default will be created) + :param tls_hostname: if ``tls=True``, host name of the server to use for checking + the server certificate (defaults to the host portion of the address for TCP + connectables) + :param tls_standard_compatible: if ``False`` and ``tls=True``, makes the TLS stream + skip the closing handshake when closing the connection, so it won't raise an + exception if the server does the same + + """ + connectable: TCPConnectable | UNIXConnectable | TLSConnectable + if isinstance(remote, ByteStreamConnectable): + return remote + elif isinstance(remote, tuple) and len(remote) == 2: + connectable = TCPConnectable(*remote) + elif isinstance(remote, (str, bytes, PathLike)): + connectable = UNIXConnectable(remote) + else: + raise TypeError(f"cannot convert {remote!r} to a connectable") + + if tls: + if not tls_hostname and isinstance(connectable, TCPConnectable): + tls_hostname = str(connectable.host) + + connectable = TLSConnectable( + connectable, + ssl_context=ssl_context, + hostname=tls_hostname, + standard_compatible=tls_standard_compatible, + ) + + return connectable diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_streams.py b/.venv/lib/python3.10/site-packages/anyio/_core/_streams.py new file mode 100644 index 0000000..2b9c7df --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_streams.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +import math +from typing import TypeVar +from warnings import warn + +from ..streams.memory import ( + MemoryObjectReceiveStream, + MemoryObjectSendStream, + _MemoryObjectStreamState, +) + +T_Item = TypeVar("T_Item") + + +class create_memory_object_stream( + tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]], +): + """ + Create a memory object stream. + + The stream's item type can be annotated like + :func:`create_memory_object_stream[T_Item]`. + + :param max_buffer_size: number of items held in the buffer until ``send()`` starts + blocking + :param item_type: old way of marking the streams with the right generic type for + static typing (does nothing on AnyIO 4) + + .. deprecated:: 4.0 + Use ``create_memory_object_stream[YourItemType](...)`` instead. + :return: a tuple of (send stream, receive stream) + + """ + + def __new__( # type: ignore[misc] + cls, max_buffer_size: float = 0, item_type: object = None + ) -> tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]: + if max_buffer_size != math.inf and not isinstance(max_buffer_size, int): + raise ValueError("max_buffer_size must be either an integer or math.inf") + if max_buffer_size < 0: + raise ValueError("max_buffer_size cannot be negative") + if item_type is not None: + warn( + "The item_type argument has been deprecated in AnyIO 4.0. " + "Use create_memory_object_stream[YourItemType](...) instead.", + DeprecationWarning, + stacklevel=2, + ) + + state = _MemoryObjectStreamState[T_Item](max_buffer_size) + return (MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_subprocesses.py b/.venv/lib/python3.10/site-packages/anyio/_core/_subprocesses.py new file mode 100644 index 0000000..9796f8b --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_subprocesses.py @@ -0,0 +1,196 @@ +from __future__ import annotations + +from collections.abc import AsyncIterable, Iterable, Mapping, Sequence +from io import BytesIO +from os import PathLike +from subprocess import PIPE, CalledProcessError, CompletedProcess +from typing import IO, Any, TypeAlias, cast + +from ..abc import Process +from ._eventloop import get_async_backend +from ._tasks import create_task_group + +StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes] + + +async def run_process( + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + input: bytes | None = None, + stdin: int | IO[Any] | None = None, + stdout: int | IO[Any] | None = PIPE, + stderr: int | IO[Any] | None = PIPE, + check: bool = True, + cwd: StrOrBytesPath | None = None, + env: Mapping[str, str] | None = None, + startupinfo: Any = None, + creationflags: int = 0, + start_new_session: bool = False, + pass_fds: Sequence[int] = (), + user: str | int | None = None, + group: str | int | None = None, + extra_groups: Iterable[str | int] | None = None, + umask: int = -1, +) -> CompletedProcess[bytes]: + """ + Run an external command in a subprocess and wait until it completes. + + .. seealso:: :func:`subprocess.run` + + :param command: either a string to pass to the shell, or an iterable of strings + containing the executable name or path and its arguments + :param input: bytes passed to the standard input of the subprocess + :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or `None`; ``input`` overrides this + :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or `None` + :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + :data:`subprocess.STDOUT`, a file-like object, or `None` + :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the + process terminates with a return code other than 0 + :param cwd: If not ``None``, change the working directory to this before running the + command + :param env: if not ``None``, this mapping replaces the inherited environment + variables from the parent process + :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used + to specify process startup parameters (Windows only) + :param creationflags: flags that can be used to control the creation of the + subprocess (see :class:`subprocess.Popen` for the specifics) + :param start_new_session: if ``true`` the setsid() system call will be made in the + child process prior to the execution of the subprocess. (POSIX only) + :param pass_fds: sequence of file descriptors to keep open between the parent and + child processes. (POSIX only) + :param user: effective user to run the process as (Python >= 3.9, POSIX only) + :param group: effective group to run the process as (Python >= 3.9, POSIX only) + :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9, + POSIX only) + :param umask: if not negative, this umask is applied in the child process before + running the given command (Python >= 3.9, POSIX only) + :return: an object representing the completed process + :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process + exits with a nonzero return code + + """ + + async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None: + buffer = BytesIO() + async for chunk in stream: + buffer.write(chunk) + + stream_contents[index] = buffer.getvalue() + + if stdin is not None and input is not None: + raise ValueError("only one of stdin and input is allowed") + + async with await open_process( + command, + stdin=PIPE if input else stdin, + stdout=stdout, + stderr=stderr, + cwd=cwd, + env=env, + startupinfo=startupinfo, + creationflags=creationflags, + start_new_session=start_new_session, + pass_fds=pass_fds, + user=user, + group=group, + extra_groups=extra_groups, + umask=umask, + ) as process: + stream_contents: list[bytes | None] = [None, None] + async with create_task_group() as tg: + if process.stdout: + tg.start_soon(drain_stream, process.stdout, 0) + + if process.stderr: + tg.start_soon(drain_stream, process.stderr, 1) + + if process.stdin and input: + await process.stdin.send(input) + await process.stdin.aclose() + + await process.wait() + + output, errors = stream_contents + if check and process.returncode != 0: + raise CalledProcessError(cast(int, process.returncode), command, output, errors) + + return CompletedProcess(command, cast(int, process.returncode), output, errors) + + +async def open_process( + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None = PIPE, + stdout: int | IO[Any] | None = PIPE, + stderr: int | IO[Any] | None = PIPE, + cwd: StrOrBytesPath | None = None, + env: Mapping[str, str] | None = None, + startupinfo: Any = None, + creationflags: int = 0, + start_new_session: bool = False, + pass_fds: Sequence[int] = (), + user: str | int | None = None, + group: str | int | None = None, + extra_groups: Iterable[str | int] | None = None, + umask: int = -1, +) -> Process: + """ + Start an external command in a subprocess. + + .. seealso:: :class:`subprocess.Popen` + + :param command: either a string to pass to the shell, or an iterable of strings + containing the executable name or path and its arguments + :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a + file-like object, or ``None`` + :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + a file-like object, or ``None`` + :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, + :data:`subprocess.STDOUT`, a file-like object, or ``None`` + :param cwd: If not ``None``, the working directory is changed before executing + :param env: If env is not ``None``, it must be a mapping that defines the + environment variables for the new process + :param creationflags: flags that can be used to control the creation of the + subprocess (see :class:`subprocess.Popen` for the specifics) + :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used + to specify process startup parameters (Windows only) + :param start_new_session: if ``true`` the setsid() system call will be made in the + child process prior to the execution of the subprocess. (POSIX only) + :param pass_fds: sequence of file descriptors to keep open between the parent and + child processes. (POSIX only) + :param user: effective user to run the process as (POSIX only) + :param group: effective group to run the process as (POSIX only) + :param extra_groups: supplementary groups to set in the subprocess (POSIX only) + :param umask: if not negative, this umask is applied in the child process before + running the given command (POSIX only) + :return: an asynchronous process object + + """ + kwargs: dict[str, Any] = {} + if user is not None: + kwargs["user"] = user + + if group is not None: + kwargs["group"] = group + + if extra_groups is not None: + kwargs["extra_groups"] = group + + if umask >= 0: + kwargs["umask"] = umask + + return await get_async_backend().open_process( + command, + stdin=stdin, + stdout=stdout, + stderr=stderr, + cwd=cwd, + env=env, + startupinfo=startupinfo, + creationflags=creationflags, + start_new_session=start_new_session, + pass_fds=pass_fds, + **kwargs, + ) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_synchronization.py b/.venv/lib/python3.10/site-packages/anyio/_core/_synchronization.py new file mode 100644 index 0000000..9c6f9a0 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_synchronization.py @@ -0,0 +1,757 @@ +from __future__ import annotations + +import math +from collections import deque +from collections.abc import Callable +from dataclasses import dataclass +from types import TracebackType +from typing import TypeVar + +from ..lowlevel import checkpoint_if_cancelled +from ._eventloop import get_async_backend +from ._exceptions import BusyResourceError, NoEventLoopError +from ._tasks import CancelScope +from ._testing import TaskInfo, get_current_task + +T = TypeVar("T") + + +@dataclass(frozen=True) +class EventStatistics: + """ + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait` + """ + + tasks_waiting: int + + +@dataclass(frozen=True) +class CapacityLimiterStatistics: + """ + :ivar int borrowed_tokens: number of tokens currently borrowed by tasks + :ivar float total_tokens: total number of available tokens + :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from + this limiter + :ivar int tasks_waiting: number of tasks waiting on + :meth:`~.CapacityLimiter.acquire` or + :meth:`~.CapacityLimiter.acquire_on_behalf_of` + """ + + borrowed_tokens: int + total_tokens: float + borrowers: tuple[object, ...] + tasks_waiting: int + + +@dataclass(frozen=True) +class LockStatistics: + """ + :ivar bool locked: flag indicating if this lock is locked or not + :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the + lock is not held by any task) + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire` + """ + + locked: bool + owner: TaskInfo | None + tasks_waiting: int + + +@dataclass(frozen=True) +class ConditionStatistics: + """ + :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait` + :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying + :class:`~.Lock` + """ + + tasks_waiting: int + lock_statistics: LockStatistics + + +@dataclass(frozen=True) +class SemaphoreStatistics: + """ + :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire` + + """ + + tasks_waiting: int + + +class Event: + def __new__(cls) -> Event: + try: + return get_async_backend().create_event() + except NoEventLoopError: + return EventAdapter() + + def set(self) -> None: + """Set the flag, notifying all listeners.""" + raise NotImplementedError + + def is_set(self) -> bool: + """Return ``True`` if the flag is set, ``False`` if not.""" + raise NotImplementedError + + async def wait(self) -> None: + """ + Wait until the flag has been set. + + If the flag has already been set when this method is called, it returns + immediately. + + """ + raise NotImplementedError + + def statistics(self) -> EventStatistics: + """Return statistics about the current state of this event.""" + raise NotImplementedError + + +class EventAdapter(Event): + _internal_event: Event | None = None + _is_set: bool = False + + def __new__(cls) -> EventAdapter: + return object.__new__(cls) + + @property + def _event(self) -> Event: + if self._internal_event is None: + self._internal_event = get_async_backend().create_event() + if self._is_set: + self._internal_event.set() + + return self._internal_event + + def set(self) -> None: + if self._internal_event is None: + self._is_set = True + else: + self._event.set() + + def is_set(self) -> bool: + if self._internal_event is None: + return self._is_set + + return self._internal_event.is_set() + + async def wait(self) -> None: + await self._event.wait() + + def statistics(self) -> EventStatistics: + if self._internal_event is None: + return EventStatistics(tasks_waiting=0) + + return self._internal_event.statistics() + + +class Lock: + def __new__(cls, *, fast_acquire: bool = False) -> Lock: + try: + return get_async_backend().create_lock(fast_acquire=fast_acquire) + except NoEventLoopError: + return LockAdapter(fast_acquire=fast_acquire) + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + async def acquire(self) -> None: + """Acquire the lock.""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire the lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + raise NotImplementedError + + def release(self) -> None: + """Release the lock.""" + raise NotImplementedError + + def locked(self) -> bool: + """Return True if the lock is currently held.""" + raise NotImplementedError + + def statistics(self) -> LockStatistics: + """ + Return statistics about the current state of this lock. + + .. versionadded:: 3.0 + """ + raise NotImplementedError + + +class LockAdapter(Lock): + _internal_lock: Lock | None = None + + def __new__(cls, *, fast_acquire: bool = False) -> LockAdapter: + return object.__new__(cls) + + def __init__(self, *, fast_acquire: bool = False): + self._fast_acquire = fast_acquire + + @property + def _lock(self) -> Lock: + if self._internal_lock is None: + self._internal_lock = get_async_backend().create_lock( + fast_acquire=self._fast_acquire + ) + + return self._internal_lock + + async def __aenter__(self) -> None: + await self._lock.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + if self._internal_lock is not None: + self._internal_lock.release() + + async def acquire(self) -> None: + """Acquire the lock.""" + await self._lock.acquire() + + def acquire_nowait(self) -> None: + """ + Acquire the lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + self._lock.acquire_nowait() + + def release(self) -> None: + """Release the lock.""" + self._lock.release() + + def locked(self) -> bool: + """Return True if the lock is currently held.""" + return self._lock.locked() + + def statistics(self) -> LockStatistics: + """ + Return statistics about the current state of this lock. + + .. versionadded:: 3.0 + + """ + if self._internal_lock is None: + return LockStatistics(False, None, 0) + + return self._internal_lock.statistics() + + +class Condition: + _owner_task: TaskInfo | None = None + + def __init__(self, lock: Lock | None = None): + self._lock = lock or Lock() + self._waiters: deque[Event] = deque() + + async def __aenter__(self) -> None: + await self.acquire() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + def _check_acquired(self) -> None: + if self._owner_task != get_current_task(): + raise RuntimeError("The current task is not holding the underlying lock") + + async def acquire(self) -> None: + """Acquire the underlying lock.""" + await self._lock.acquire() + self._owner_task = get_current_task() + + def acquire_nowait(self) -> None: + """ + Acquire the underlying lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + self._lock.acquire_nowait() + self._owner_task = get_current_task() + + def release(self) -> None: + """Release the underlying lock.""" + self._lock.release() + + def locked(self) -> bool: + """Return True if the lock is set.""" + return self._lock.locked() + + def notify(self, n: int = 1) -> None: + """Notify exactly n listeners.""" + self._check_acquired() + for _ in range(n): + try: + event = self._waiters.popleft() + except IndexError: + break + + event.set() + + def notify_all(self) -> None: + """Notify all the listeners.""" + self._check_acquired() + for event in self._waiters: + event.set() + + self._waiters.clear() + + async def wait(self) -> None: + """Wait for a notification.""" + await checkpoint_if_cancelled() + self._check_acquired() + event = Event() + self._waiters.append(event) + self.release() + try: + await event.wait() + except BaseException: + if not event.is_set(): + self._waiters.remove(event) + elif self._waiters: + # This task was notified by could not act on it, so pass + # it on to the next task + self._waiters.popleft().set() + + raise + finally: + with CancelScope(shield=True): + await self.acquire() + + async def wait_for(self, predicate: Callable[[], T]) -> T: + """ + Wait until a predicate becomes true. + + :param predicate: a callable that returns a truthy value when the condition is + met + :return: the result of the predicate + + .. versionadded:: 4.11.0 + + """ + while not (result := predicate()): + await self.wait() + + return result + + def statistics(self) -> ConditionStatistics: + """ + Return statistics about the current state of this condition. + + .. versionadded:: 3.0 + """ + return ConditionStatistics(len(self._waiters), self._lock.statistics()) + + +class Semaphore: + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + try: + return get_async_backend().create_semaphore( + initial_value, max_value=max_value, fast_acquire=fast_acquire + ) + except NoEventLoopError: + return SemaphoreAdapter(initial_value, max_value=max_value) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ): + if not isinstance(initial_value, int): + raise TypeError("initial_value must be an integer") + if initial_value < 0: + raise ValueError("initial_value must be >= 0") + if max_value is not None: + if not isinstance(max_value, int): + raise TypeError("max_value must be an integer or None") + if max_value < initial_value: + raise ValueError( + "max_value must be equal to or higher than initial_value" + ) + + self._fast_acquire = fast_acquire + + async def __aenter__(self) -> Semaphore: + await self.acquire() + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.release() + + async def acquire(self) -> None: + """Decrement the semaphore value, blocking if necessary.""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire the underlying lock, without blocking. + + :raises ~anyio.WouldBlock: if the operation would block + + """ + raise NotImplementedError + + def release(self) -> None: + """Increment the semaphore value.""" + raise NotImplementedError + + @property + def value(self) -> int: + """The current value of the semaphore.""" + raise NotImplementedError + + @property + def max_value(self) -> int | None: + """The maximum value of the semaphore.""" + raise NotImplementedError + + def statistics(self) -> SemaphoreStatistics: + """ + Return statistics about the current state of this semaphore. + + .. versionadded:: 3.0 + """ + raise NotImplementedError + + +class SemaphoreAdapter(Semaphore): + _internal_semaphore: Semaphore | None = None + + def __new__( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> SemaphoreAdapter: + return object.__new__(cls) + + def __init__( + self, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> None: + super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire) + self._initial_value = initial_value + self._max_value = max_value + + @property + def _semaphore(self) -> Semaphore: + if self._internal_semaphore is None: + self._internal_semaphore = get_async_backend().create_semaphore( + self._initial_value, max_value=self._max_value + ) + + return self._internal_semaphore + + async def acquire(self) -> None: + await self._semaphore.acquire() + + def acquire_nowait(self) -> None: + self._semaphore.acquire_nowait() + + def release(self) -> None: + self._semaphore.release() + + @property + def value(self) -> int: + if self._internal_semaphore is None: + return self._initial_value + + return self._semaphore.value + + @property + def max_value(self) -> int | None: + return self._max_value + + def statistics(self) -> SemaphoreStatistics: + if self._internal_semaphore is None: + return SemaphoreStatistics(tasks_waiting=0) + + return self._semaphore.statistics() + + +class CapacityLimiter: + def __new__(cls, total_tokens: float) -> CapacityLimiter: + try: + return get_async_backend().create_capacity_limiter(total_tokens) + except NoEventLoopError: + return CapacityLimiterAdapter(total_tokens) + + async def __aenter__(self) -> None: + raise NotImplementedError + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + raise NotImplementedError + + @property + def total_tokens(self) -> float: + """ + The total number of tokens available for borrowing. + + This is a read-write property. If the total number of tokens is increased, the + proportionate number of tasks waiting on this limiter will be granted their + tokens. + + .. versionchanged:: 3.0 + The property is now writable. + .. versionchanged:: 4.12 + The value can now be set to 0. + + """ + raise NotImplementedError + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + raise NotImplementedError + + @property + def borrowed_tokens(self) -> int: + """The number of tokens that have currently been borrowed.""" + raise NotImplementedError + + @property + def available_tokens(self) -> float: + """The number of tokens currently available to be borrowed""" + raise NotImplementedError + + def acquire_nowait(self) -> None: + """ + Acquire a token for the current task without waiting for one to become + available. + + :raises ~anyio.WouldBlock: if there are no tokens available for borrowing + + """ + raise NotImplementedError + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + """ + Acquire a token without waiting for one to become available. + + :param borrower: the entity borrowing a token + :raises ~anyio.WouldBlock: if there are no tokens available for borrowing + + """ + raise NotImplementedError + + async def acquire(self) -> None: + """ + Acquire a token for the current task, waiting if necessary for one to become + available. + + """ + raise NotImplementedError + + async def acquire_on_behalf_of(self, borrower: object) -> None: + """ + Acquire a token, waiting if necessary for one to become available. + + :param borrower: the entity borrowing a token + + """ + raise NotImplementedError + + def release(self) -> None: + """ + Release the token held by the current task. + + :raises RuntimeError: if the current task has not borrowed a token from this + limiter. + + """ + raise NotImplementedError + + def release_on_behalf_of(self, borrower: object) -> None: + """ + Release the token held by the given borrower. + + :raises RuntimeError: if the borrower has not borrowed a token from this + limiter. + + """ + raise NotImplementedError + + def statistics(self) -> CapacityLimiterStatistics: + """ + Return statistics about the current state of this limiter. + + .. versionadded:: 3.0 + + """ + raise NotImplementedError + + +class CapacityLimiterAdapter(CapacityLimiter): + _internal_limiter: CapacityLimiter | None = None + + def __new__(cls, total_tokens: float) -> CapacityLimiterAdapter: + return object.__new__(cls) + + def __init__(self, total_tokens: float) -> None: + self.total_tokens = total_tokens + + @property + def _limiter(self) -> CapacityLimiter: + if self._internal_limiter is None: + self._internal_limiter = get_async_backend().create_capacity_limiter( + self._total_tokens + ) + + return self._internal_limiter + + async def __aenter__(self) -> None: + await self._limiter.__aenter__() + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + return await self._limiter.__aexit__(exc_type, exc_val, exc_tb) + + @property + def total_tokens(self) -> float: + if self._internal_limiter is None: + return self._total_tokens + + return self._internal_limiter.total_tokens + + @total_tokens.setter + def total_tokens(self, value: float) -> None: + if not isinstance(value, int) and value is not math.inf: + raise TypeError("total_tokens must be an int or math.inf") + elif value < 1: + raise ValueError("total_tokens must be >= 1") + + if self._internal_limiter is None: + self._total_tokens = value + return + + self._limiter.total_tokens = value + + @property + def borrowed_tokens(self) -> int: + if self._internal_limiter is None: + return 0 + + return self._internal_limiter.borrowed_tokens + + @property + def available_tokens(self) -> float: + if self._internal_limiter is None: + return self._total_tokens + + return self._internal_limiter.available_tokens + + def acquire_nowait(self) -> None: + self._limiter.acquire_nowait() + + def acquire_on_behalf_of_nowait(self, borrower: object) -> None: + self._limiter.acquire_on_behalf_of_nowait(borrower) + + async def acquire(self) -> None: + await self._limiter.acquire() + + async def acquire_on_behalf_of(self, borrower: object) -> None: + await self._limiter.acquire_on_behalf_of(borrower) + + def release(self) -> None: + self._limiter.release() + + def release_on_behalf_of(self, borrower: object) -> None: + self._limiter.release_on_behalf_of(borrower) + + def statistics(self) -> CapacityLimiterStatistics: + if self._internal_limiter is None: + return CapacityLimiterStatistics( + borrowed_tokens=0, + total_tokens=self.total_tokens, + borrowers=(), + tasks_waiting=0, + ) + + return self._internal_limiter.statistics() + + +class ResourceGuard: + """ + A context manager for ensuring that a resource is only used by a single task at a + time. + + Entering this context manager while the previous has not exited it yet will trigger + :exc:`BusyResourceError`. + + :param action: the action to guard against (visible in the :exc:`BusyResourceError` + when triggered, e.g. "Another task is already {action} this resource") + + .. versionadded:: 4.1 + """ + + __slots__ = "action", "_guarded" + + def __init__(self, action: str = "using"): + self.action: str = action + self._guarded = False + + def __enter__(self) -> None: + if self._guarded: + raise BusyResourceError(self.action) + + self._guarded = True + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self._guarded = False diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_tasks.py b/.venv/lib/python3.10/site-packages/anyio/_core/_tasks.py new file mode 100644 index 0000000..0688bfe --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_tasks.py @@ -0,0 +1,173 @@ +from __future__ import annotations + +import math +from collections.abc import Generator +from contextlib import contextmanager +from types import TracebackType + +from ..abc._tasks import TaskGroup, TaskStatus +from ._eventloop import get_async_backend + + +class _IgnoredTaskStatus(TaskStatus[object]): + def started(self, value: object = None) -> None: + pass + + +TASK_STATUS_IGNORED = _IgnoredTaskStatus() + + +class CancelScope: + """ + Wraps a unit of work that can be made separately cancellable. + + :param deadline: The time (clock value) when this scope is cancelled automatically + :param shield: ``True`` to shield the cancel scope from external cancellation + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + """ + + def __new__( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + return get_async_backend().create_cancel_scope(shield=shield, deadline=deadline) + + def cancel(self, reason: str | None = None) -> None: + """ + Cancel this scope immediately. + + :param reason: a message describing the reason for the cancellation + + """ + raise NotImplementedError + + @property + def deadline(self) -> float: + """ + The time (clock value) when this scope is cancelled automatically. + + Will be ``float('inf')`` if no timeout has been set. + + """ + raise NotImplementedError + + @deadline.setter + def deadline(self, value: float) -> None: + raise NotImplementedError + + @property + def cancel_called(self) -> bool: + """``True`` if :meth:`cancel` has been called.""" + raise NotImplementedError + + @property + def cancelled_caught(self) -> bool: + """ + ``True`` if this scope suppressed a cancellation exception it itself raised. + + This is typically used to check if any work was interrupted, or to see if the + scope was cancelled due to its deadline being reached. The value will, however, + only be ``True`` if the cancellation was triggered by the scope itself (and not + an outer scope). + + """ + raise NotImplementedError + + @property + def shield(self) -> bool: + """ + ``True`` if this scope is shielded from external cancellation. + + While a scope is shielded, it will not receive cancellations from outside. + + """ + raise NotImplementedError + + @shield.setter + def shield(self, value: bool) -> None: + raise NotImplementedError + + def __enter__(self) -> CancelScope: + raise NotImplementedError + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + raise NotImplementedError + + +@contextmanager +def fail_after( + delay: float | None, shield: bool = False +) -> Generator[CancelScope, None, None]: + """ + Create a context manager which raises a :class:`TimeoutError` if does not finish in + time. + + :param delay: maximum allowed time (in seconds) before raising the exception, or + ``None`` to disable the timeout + :param shield: ``True`` to shield the cancel scope from external cancellation + :return: a context manager that yields a cancel scope + :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\] + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + current_time = get_async_backend().current_time + deadline = (current_time() + delay) if delay is not None else math.inf + with get_async_backend().create_cancel_scope( + deadline=deadline, shield=shield + ) as cancel_scope: + yield cancel_scope + + if cancel_scope.cancelled_caught and current_time() >= cancel_scope.deadline: + raise TimeoutError + + +def move_on_after(delay: float | None, shield: bool = False) -> CancelScope: + """ + Create a cancel scope with a deadline that expires after the given delay. + + :param delay: maximum allowed time (in seconds) before exiting the context block, or + ``None`` to disable the timeout + :param shield: ``True`` to shield the cancel scope from external cancellation + :return: a cancel scope + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + deadline = ( + (get_async_backend().current_time() + delay) if delay is not None else math.inf + ) + return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield) + + +def current_effective_deadline() -> float: + """ + Return the nearest deadline among all the cancel scopes effective for the current + task. + + :return: a clock value from the event loop's internal clock (or ``float('inf')`` if + there is no deadline in effect, or ``float('-inf')`` if the current scope has + been cancelled) + :rtype: float + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().current_effective_deadline() + + +def create_task_group() -> TaskGroup: + """ + Create a task group. + + :return: a task group + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().create_task_group() diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_tempfile.py b/.venv/lib/python3.10/site-packages/anyio/_core/_tempfile.py new file mode 100644 index 0000000..75a09f7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_tempfile.py @@ -0,0 +1,613 @@ +from __future__ import annotations + +import os +import sys +import tempfile +from collections.abc import Iterable +from io import BytesIO, TextIOWrapper +from types import TracebackType +from typing import ( + TYPE_CHECKING, + Any, + AnyStr, + Generic, + overload, +) + +from .. import to_thread +from .._core._fileio import AsyncFile +from ..lowlevel import checkpoint_if_cancelled + +if TYPE_CHECKING: + from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer + + +class TemporaryFile(Generic[AnyStr]): + """ + An asynchronous temporary file that is automatically created and cleaned up. + + This class provides an asynchronous context manager interface to a temporary file. + The file is created using Python's standard `tempfile.TemporaryFile` function in a + background thread, and is wrapped as an asynchronous file using `AsyncFile`. + + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file. Only applicable in + text mode. + :param newline: Controls how universal newlines mode works (only applicable in text + mode). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param errors: The error handling scheme used for encoding/decoding errors. + """ + + _async_file: AsyncFile[AnyStr] + + @overload + def __init__( + self: TemporaryFile[bytes], + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + @overload + def __init__( + self: TemporaryFile[str], + mode: OpenTextMode, + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + + def __init__( + self, + mode: OpenTextMode | OpenBinaryMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + *, + errors: str | None = None, + ) -> None: + self.mode = mode + self.buffering = buffering + self.encoding = encoding + self.newline = newline + self.suffix: str | None = suffix + self.prefix: str | None = prefix + self.dir: str | None = dir + self.errors = errors + + async def __aenter__(self) -> AsyncFile[AnyStr]: + fp = await to_thread.run_sync( + lambda: tempfile.TemporaryFile( + self.mode, + self.buffering, + self.encoding, + self.newline, + self.suffix, + self.prefix, + self.dir, + errors=self.errors, + ) + ) + self._async_file = AsyncFile(fp) + return self._async_file + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + await self._async_file.aclose() + + +class NamedTemporaryFile(Generic[AnyStr]): + """ + An asynchronous named temporary file that is automatically created and cleaned up. + + This class provides an asynchronous context manager for a temporary file with a + visible name in the file system. It uses Python's standard + :func:`~tempfile.NamedTemporaryFile` function and wraps the file object with + :class:`AsyncFile` for asynchronous operations. + + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file. Only applicable in + text mode. + :param newline: Controls how universal newlines mode works (only applicable in text + mode). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param delete: Whether to delete the file when it is closed. + :param errors: The error handling scheme used for encoding/decoding errors. + :param delete_on_close: (Python 3.12+) Whether to delete the file on close. + """ + + _async_file: AsyncFile[AnyStr] + + @overload + def __init__( + self: NamedTemporaryFile[bytes], + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + delete: bool = ..., + *, + errors: str | None = ..., + delete_on_close: bool = ..., + ): ... + @overload + def __init__( + self: NamedTemporaryFile[str], + mode: OpenTextMode, + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + delete: bool = ..., + *, + errors: str | None = ..., + delete_on_close: bool = ..., + ): ... + + def __init__( + self, + mode: OpenBinaryMode | OpenTextMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + delete: bool = True, + *, + errors: str | None = None, + delete_on_close: bool = True, + ) -> None: + self._params: dict[str, Any] = { + "mode": mode, + "buffering": buffering, + "encoding": encoding, + "newline": newline, + "suffix": suffix, + "prefix": prefix, + "dir": dir, + "delete": delete, + "errors": errors, + } + if sys.version_info >= (3, 12): + self._params["delete_on_close"] = delete_on_close + + async def __aenter__(self) -> AsyncFile[AnyStr]: + fp = await to_thread.run_sync( + lambda: tempfile.NamedTemporaryFile(**self._params) + ) + self._async_file = AsyncFile(fp) + return self._async_file + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + await self._async_file.aclose() + + +class SpooledTemporaryFile(AsyncFile[AnyStr]): + """ + An asynchronous spooled temporary file that starts in memory and is spooled to disk. + + This class provides an asynchronous interface to a spooled temporary file, much like + Python's standard :class:`~tempfile.SpooledTemporaryFile`. It supports asynchronous + write operations and provides a method to force a rollover to disk. + + :param max_size: Maximum size in bytes before the file is rolled over to disk. + :param mode: The mode in which the file is opened. Defaults to "w+b". + :param buffering: The buffering policy (-1 means the default buffering). + :param encoding: The encoding used to decode or encode the file (text mode only). + :param newline: Controls how universal newlines mode works (text mode only). + :param suffix: The suffix for the temporary file name. + :param prefix: The prefix for the temporary file name. + :param dir: The directory in which the temporary file is created. + :param errors: The error handling scheme used for encoding/decoding errors. + """ + + _rolled: bool = False + + @overload + def __init__( + self: SpooledTemporaryFile[bytes], + max_size: int = ..., + mode: OpenBinaryMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + @overload + def __init__( + self: SpooledTemporaryFile[str], + max_size: int = ..., + mode: OpenTextMode = ..., + buffering: int = ..., + encoding: str | None = ..., + newline: str | None = ..., + suffix: str | None = ..., + prefix: str | None = ..., + dir: str | None = ..., + *, + errors: str | None = ..., + ): ... + + def __init__( + self, + max_size: int = 0, + mode: OpenBinaryMode | OpenTextMode = "w+b", + buffering: int = -1, + encoding: str | None = None, + newline: str | None = None, + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + *, + errors: str | None = None, + ) -> None: + self._tempfile_params: dict[str, Any] = { + "mode": mode, + "buffering": buffering, + "encoding": encoding, + "newline": newline, + "suffix": suffix, + "prefix": prefix, + "dir": dir, + "errors": errors, + } + self._max_size = max_size + if "b" in mode: + super().__init__(BytesIO()) # type: ignore[arg-type] + else: + super().__init__( + TextIOWrapper( # type: ignore[arg-type] + BytesIO(), + encoding=encoding, + errors=errors, + newline=newline, + write_through=True, + ) + ) + + async def aclose(self) -> None: + if not self._rolled: + self._fp.close() + return + + await super().aclose() + + async def _check(self) -> None: + if self._rolled or self._fp.tell() <= self._max_size: + return + + await self.rollover() + + async def rollover(self) -> None: + if self._rolled: + return + + self._rolled = True + buffer = self._fp + buffer.seek(0) + self._fp = await to_thread.run_sync( + lambda: tempfile.TemporaryFile(**self._tempfile_params) + ) + await self.write(buffer.read()) + buffer.close() + + @property + def closed(self) -> bool: + return self._fp.closed + + async def read(self, size: int = -1) -> AnyStr: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.read(size) + + return await super().read(size) # type: ignore[return-value] + + async def read1(self: SpooledTemporaryFile[bytes], size: int = -1) -> bytes: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.read1(size) + + return await super().read1(size) + + async def readline(self) -> AnyStr: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.readline() + + return await super().readline() # type: ignore[return-value] + + async def readlines(self) -> list[AnyStr]: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.readlines() + + return await super().readlines() # type: ignore[return-value] + + async def readinto(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + self._fp.readinto(b) + + return await super().readinto(b) + + async def readinto1(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + self._fp.readinto(b) + + return await super().readinto1(b) + + async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.seek(offset, whence) + + return await super().seek(offset, whence) + + async def tell(self) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.tell() + + return await super().tell() + + async def truncate(self, size: int | None = None) -> int: + if not self._rolled: + await checkpoint_if_cancelled() + return self._fp.truncate(size) + + return await super().truncate(size) + + @overload + async def write(self: SpooledTemporaryFile[bytes], b: ReadableBuffer) -> int: ... + @overload + async def write(self: SpooledTemporaryFile[str], b: str) -> int: ... + + async def write(self, b: ReadableBuffer | str) -> int: + """ + Asynchronously write data to the spooled temporary file. + + If the file has not yet been rolled over, the data is written synchronously, + and a rollover is triggered if the size exceeds the maximum size. + + :param s: The data to write. + :return: The number of bytes written. + :raises RuntimeError: If the underlying file is not initialized. + + """ + if not self._rolled: + await checkpoint_if_cancelled() + result = self._fp.write(b) + await self._check() + return result + + return await super().write(b) # type: ignore[misc] + + @overload + async def writelines( + self: SpooledTemporaryFile[bytes], lines: Iterable[ReadableBuffer] + ) -> None: ... + @overload + async def writelines( + self: SpooledTemporaryFile[str], lines: Iterable[str] + ) -> None: ... + + async def writelines(self, lines: Iterable[str] | Iterable[ReadableBuffer]) -> None: + """ + Asynchronously write a list of lines to the spooled temporary file. + + If the file has not yet been rolled over, the lines are written synchronously, + and a rollover is triggered if the size exceeds the maximum size. + + :param lines: An iterable of lines to write. + :raises RuntimeError: If the underlying file is not initialized. + + """ + if not self._rolled: + await checkpoint_if_cancelled() + result = self._fp.writelines(lines) + await self._check() + return result + + return await super().writelines(lines) # type: ignore[misc] + + +class TemporaryDirectory(Generic[AnyStr]): + """ + An asynchronous temporary directory that is created and cleaned up automatically. + + This class provides an asynchronous context manager for creating a temporary + directory. It wraps Python's standard :class:`~tempfile.TemporaryDirectory` to + perform directory creation and cleanup operations in a background thread. + + :param suffix: Suffix to be added to the temporary directory name. + :param prefix: Prefix to be added to the temporary directory name. + :param dir: The parent directory where the temporary directory is created. + :param ignore_cleanup_errors: Whether to ignore errors during cleanup + :param delete: Whether to delete the directory upon closing (Python 3.12+). + """ + + def __init__( + self, + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, + *, + ignore_cleanup_errors: bool = False, + delete: bool = True, + ) -> None: + self.suffix: AnyStr | None = suffix + self.prefix: AnyStr | None = prefix + self.dir: AnyStr | None = dir + self.ignore_cleanup_errors = ignore_cleanup_errors + self.delete = delete + + self._tempdir: tempfile.TemporaryDirectory | None = None + + async def __aenter__(self) -> str: + params: dict[str, Any] = { + "suffix": self.suffix, + "prefix": self.prefix, + "dir": self.dir, + "ignore_cleanup_errors": self.ignore_cleanup_errors, + } + if sys.version_info >= (3, 12): + params["delete"] = self.delete + + self._tempdir = await to_thread.run_sync( + lambda: tempfile.TemporaryDirectory(**params) + ) + return await to_thread.run_sync(self._tempdir.__enter__) + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_value: BaseException | None, + traceback: TracebackType | None, + ) -> None: + if self._tempdir is not None: + await to_thread.run_sync( + self._tempdir.__exit__, exc_type, exc_value, traceback + ) + + async def cleanup(self) -> None: + if self._tempdir is not None: + await to_thread.run_sync(self._tempdir.cleanup) + + +@overload +async def mkstemp( + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, + text: bool = False, +) -> tuple[int, str]: ... + + +@overload +async def mkstemp( + suffix: bytes | None = None, + prefix: bytes | None = None, + dir: bytes | None = None, + text: bool = False, +) -> tuple[int, bytes]: ... + + +async def mkstemp( + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, + text: bool = False, +) -> tuple[int, str | bytes]: + """ + Asynchronously create a temporary file and return an OS-level handle and the file + name. + + This function wraps `tempfile.mkstemp` and executes it in a background thread. + + :param suffix: Suffix to be added to the file name. + :param prefix: Prefix to be added to the file name. + :param dir: Directory in which the temporary file is created. + :param text: Whether the file is opened in text mode. + :return: A tuple containing the file descriptor and the file name. + + """ + return await to_thread.run_sync(tempfile.mkstemp, suffix, prefix, dir, text) + + +@overload +async def mkdtemp( + suffix: str | None = None, + prefix: str | None = None, + dir: str | None = None, +) -> str: ... + + +@overload +async def mkdtemp( + suffix: bytes | None = None, + prefix: bytes | None = None, + dir: bytes | None = None, +) -> bytes: ... + + +async def mkdtemp( + suffix: AnyStr | None = None, + prefix: AnyStr | None = None, + dir: AnyStr | None = None, +) -> str | bytes: + """ + Asynchronously create a temporary directory and return its path. + + This function wraps `tempfile.mkdtemp` and executes it in a background thread. + + :param suffix: Suffix to be added to the directory name. + :param prefix: Prefix to be added to the directory name. + :param dir: Parent directory where the temporary directory is created. + :return: The path of the created temporary directory. + + """ + return await to_thread.run_sync(tempfile.mkdtemp, suffix, prefix, dir) + + +async def gettempdir() -> str: + """ + Asynchronously return the name of the directory used for temporary files. + + This function wraps `tempfile.gettempdir` and executes it in a background thread. + + :return: The path of the temporary directory as a string. + + """ + return await to_thread.run_sync(tempfile.gettempdir) + + +async def gettempdirb() -> bytes: + """ + Asynchronously return the name of the directory used for temporary files in bytes. + + This function wraps `tempfile.gettempdirb` and executes it in a background thread. + + :return: The path of the temporary directory as bytes. + + """ + return await to_thread.run_sync(tempfile.gettempdirb) diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_testing.py b/.venv/lib/python3.10/site-packages/anyio/_core/_testing.py new file mode 100644 index 0000000..369e65c --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_testing.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +from collections.abc import Awaitable, Generator +from typing import Any, cast + +from ._eventloop import get_async_backend + + +class TaskInfo: + """ + Represents an asynchronous task. + + :ivar int id: the unique identifier of the task + :ivar parent_id: the identifier of the parent task, if any + :vartype parent_id: Optional[int] + :ivar str name: the description of the task (if any) + :ivar ~collections.abc.Coroutine coro: the coroutine object of the task + """ + + __slots__ = "_name", "id", "parent_id", "name", "coro" + + def __init__( + self, + id: int, + parent_id: int | None, + name: str | None, + coro: Generator[Any, Any, Any] | Awaitable[Any], + ): + func = get_current_task + self._name = f"{func.__module__}.{func.__qualname__}" + self.id: int = id + self.parent_id: int | None = parent_id + self.name: str | None = name + self.coro: Generator[Any, Any, Any] | Awaitable[Any] = coro + + def __eq__(self, other: object) -> bool: + if isinstance(other, TaskInfo): + return self.id == other.id + + return NotImplemented + + def __hash__(self) -> int: + return hash(self.id) + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})" + + def has_pending_cancellation(self) -> bool: + """ + Return ``True`` if the task has a cancellation pending, ``False`` otherwise. + + """ + return False + + +def get_current_task() -> TaskInfo: + """ + Return the current task. + + :return: a representation of the current task + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().get_current_task() + + +def get_running_tasks() -> list[TaskInfo]: + """ + Return a list of running tasks in the current event loop. + + :return: a list of task info objects + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return cast("list[TaskInfo]", get_async_backend().get_running_tasks()) + + +async def wait_all_tasks_blocked() -> None: + """Wait until all other tasks are waiting for something.""" + await get_async_backend().wait_all_tasks_blocked() diff --git a/.venv/lib/python3.10/site-packages/anyio/_core/_typedattr.py b/.venv/lib/python3.10/site-packages/anyio/_core/_typedattr.py new file mode 100644 index 0000000..f358a44 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/_core/_typedattr.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +from collections.abc import Callable, Mapping +from typing import Any, TypeVar, final, overload + +from ._exceptions import TypedAttributeLookupError + +T_Attr = TypeVar("T_Attr") +T_Default = TypeVar("T_Default") +undefined = object() + + +def typed_attribute() -> Any: + """Return a unique object, used to mark typed attributes.""" + return object() + + +class TypedAttributeSet: + """ + Superclass for typed attribute collections. + + Checks that every public attribute of every subclass has a type annotation. + """ + + def __init_subclass__(cls) -> None: + annotations: dict[str, Any] = getattr(cls, "__annotations__", {}) + for attrname in dir(cls): + if not attrname.startswith("_") and attrname not in annotations: + raise TypeError( + f"Attribute {attrname!r} is missing its type annotation" + ) + + super().__init_subclass__() + + +class TypedAttributeProvider: + """Base class for classes that wish to provide typed extra attributes.""" + + @property + def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]: + """ + A mapping of the extra attributes to callables that return the corresponding + values. + + If the provider wraps another provider, the attributes from that wrapper should + also be included in the returned mapping (but the wrapper may override the + callables from the wrapped instance). + + """ + return {} + + @overload + def extra(self, attribute: T_Attr) -> T_Attr: ... + + @overload + def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default: ... + + @final + def extra(self, attribute: Any, default: object = undefined) -> object: + """ + extra(attribute, default=undefined) + + Return the value of the given typed extra attribute. + + :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to + look for + :param default: the value that should be returned if no value is found for the + attribute + :raises ~anyio.TypedAttributeLookupError: if the search failed and no default + value was given + + """ + try: + getter = self.extra_attributes[attribute] + except KeyError: + if default is undefined: + raise TypedAttributeLookupError("Attribute not found") from None + else: + return default + + return getter() diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__init__.py b/.venv/lib/python3.10/site-packages/anyio/abc/__init__.py new file mode 100644 index 0000000..d560ce3 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/__init__.py @@ -0,0 +1,58 @@ +from __future__ import annotations + +from ._eventloop import AsyncBackend as AsyncBackend +from ._resources import AsyncResource as AsyncResource +from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket +from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket +from ._sockets import IPAddressType as IPAddressType +from ._sockets import IPSockAddrType as IPSockAddrType +from ._sockets import SocketAttribute as SocketAttribute +from ._sockets import SocketListener as SocketListener +from ._sockets import SocketStream as SocketStream +from ._sockets import UDPPacketType as UDPPacketType +from ._sockets import UDPSocket as UDPSocket +from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType +from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket +from ._sockets import UNIXSocketStream as UNIXSocketStream +from ._streams import AnyByteReceiveStream as AnyByteReceiveStream +from ._streams import AnyByteSendStream as AnyByteSendStream +from ._streams import AnyByteStream as AnyByteStream +from ._streams import AnyByteStreamConnectable as AnyByteStreamConnectable +from ._streams import AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream +from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream +from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream +from ._streams import ByteReceiveStream as ByteReceiveStream +from ._streams import ByteSendStream as ByteSendStream +from ._streams import ByteStream as ByteStream +from ._streams import ByteStreamConnectable as ByteStreamConnectable +from ._streams import Listener as Listener +from ._streams import ObjectReceiveStream as ObjectReceiveStream +from ._streams import ObjectSendStream as ObjectSendStream +from ._streams import ObjectStream as ObjectStream +from ._streams import ObjectStreamConnectable as ObjectStreamConnectable +from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream +from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream +from ._streams import UnreliableObjectStream as UnreliableObjectStream +from ._subprocesses import Process as Process +from ._tasks import TaskGroup as TaskGroup +from ._tasks import TaskStatus as TaskStatus +from ._testing import TestRunner as TestRunner + +# Re-exported here, for backwards compatibility +# isort: off +from .._core._synchronization import ( + CapacityLimiter as CapacityLimiter, + Condition as Condition, + Event as Event, + Lock as Lock, + Semaphore as Semaphore, +) +from .._core._tasks import CancelScope as CancelScope +from ..from_thread import BlockingPortal as BlockingPortal + +# Re-export imports so they look like they live directly in this package +for __value in list(locals().values()): + if getattr(__value, "__module__", "").startswith("anyio.abc."): + __value.__module__ = __name__ + +del __value diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..ef4ac19 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_eventloop.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_eventloop.cpython-310.pyc new file mode 100644 index 0000000..35a17f9 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_eventloop.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_resources.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_resources.cpython-310.pyc new file mode 100644 index 0000000..736d32c Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_resources.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_sockets.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_sockets.cpython-310.pyc new file mode 100644 index 0000000..f0b72ad Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_sockets.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_streams.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_streams.cpython-310.pyc new file mode 100644 index 0000000..0ffccb0 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_streams.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-310.pyc new file mode 100644 index 0000000..df16e1f Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_tasks.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_tasks.cpython-310.pyc new file mode 100644 index 0000000..386edbb Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_tasks.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_testing.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_testing.cpython-310.pyc new file mode 100644 index 0000000..8565f51 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/abc/__pycache__/_testing.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_eventloop.py b/.venv/lib/python3.10/site-packages/anyio/abc/_eventloop.py new file mode 100644 index 0000000..ae06288 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_eventloop.py @@ -0,0 +1,409 @@ +from __future__ import annotations + +import math +import sys +from abc import ABCMeta, abstractmethod +from collections.abc import AsyncIterator, Awaitable, Callable, Sequence +from contextlib import AbstractContextManager +from os import PathLike +from signal import Signals +from socket import AddressFamily, SocketKind, socket +from typing import ( + IO, + TYPE_CHECKING, + Any, + TypeAlias, + TypeVar, + overload, +) + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if TYPE_CHECKING: + from _typeshed import FileDescriptorLike + + from .._core._synchronization import CapacityLimiter, Event, Lock, Semaphore + from .._core._tasks import CancelScope + from .._core._testing import TaskInfo + from ._sockets import ( + ConnectedUDPSocket, + ConnectedUNIXDatagramSocket, + IPSockAddrType, + SocketListener, + SocketStream, + UDPSocket, + UNIXDatagramSocket, + UNIXSocketStream, + ) + from ._subprocesses import Process + from ._tasks import TaskGroup + from ._testing import TestRunner + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") +StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes] + + +class AsyncBackend(metaclass=ABCMeta): + @classmethod + @abstractmethod + def run( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + options: dict[str, Any], + ) -> T_Retval: + """ + Run the given coroutine function in an asynchronous event loop. + + The current thread must not be already running an event loop. + + :param func: a coroutine function + :param args: positional arguments to ``func`` + :param kwargs: positional arguments to ``func`` + :param options: keyword arguments to call the backend ``run()`` implementation + with + :return: the return value of the coroutine function + """ + + @classmethod + @abstractmethod + def current_token(cls) -> object: + """ + Return an object that allows other threads to run code inside the event loop. + + :return: a token object, specific to the event loop running in the current + thread + """ + + @classmethod + @abstractmethod + def current_time(cls) -> float: + """ + Return the current value of the event loop's internal clock. + + :return: the clock value (seconds) + """ + + @classmethod + @abstractmethod + def cancelled_exception_class(cls) -> type[BaseException]: + """Return the exception class that is raised in a task if it's cancelled.""" + + @classmethod + @abstractmethod + async def checkpoint(cls) -> None: + """ + Check if the task has been cancelled, and allow rescheduling of other tasks. + + This is effectively the same as running :meth:`checkpoint_if_cancelled` and then + :meth:`cancel_shielded_checkpoint`. + """ + + @classmethod + async def checkpoint_if_cancelled(cls) -> None: + """ + Check if the current task group has been cancelled. + + This will check if the task has been cancelled, but will not allow other tasks + to be scheduled if not. + + """ + if cls.current_effective_deadline() == -math.inf: + await cls.checkpoint() + + @classmethod + async def cancel_shielded_checkpoint(cls) -> None: + """ + Allow the rescheduling of other tasks. + + This will give other tasks the opportunity to run, but without checking if the + current task group has been cancelled, unlike with :meth:`checkpoint`. + + """ + with cls.create_cancel_scope(shield=True): + await cls.sleep(0) + + @classmethod + @abstractmethod + async def sleep(cls, delay: float) -> None: + """ + Pause the current task for the specified duration. + + :param delay: the duration, in seconds + """ + + @classmethod + @abstractmethod + def create_cancel_scope( + cls, *, deadline: float = math.inf, shield: bool = False + ) -> CancelScope: + pass + + @classmethod + @abstractmethod + def current_effective_deadline(cls) -> float: + """ + Return the nearest deadline among all the cancel scopes effective for the + current task. + + :return: + - a clock value from the event loop's internal clock + - ``inf`` if there is no deadline in effect + - ``-inf`` if the current scope has been cancelled + :rtype: float + """ + + @classmethod + @abstractmethod + def create_task_group(cls) -> TaskGroup: + pass + + @classmethod + @abstractmethod + def create_event(cls) -> Event: + pass + + @classmethod + @abstractmethod + def create_lock(cls, *, fast_acquire: bool) -> Lock: + pass + + @classmethod + @abstractmethod + def create_semaphore( + cls, + initial_value: int, + *, + max_value: int | None = None, + fast_acquire: bool = False, + ) -> Semaphore: + pass + + @classmethod + @abstractmethod + def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter: + pass + + @classmethod + @abstractmethod + async def run_sync_in_worker_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + abandon_on_cancel: bool = False, + limiter: CapacityLimiter | None = None, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + def check_cancelled(cls) -> None: + pass + + @classmethod + @abstractmethod + def run_async_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + def run_sync_from_thread( + cls, + func: Callable[[Unpack[PosArgsT]], T_Retval], + args: tuple[Unpack[PosArgsT]], + token: object, + ) -> T_Retval: + pass + + @classmethod + @abstractmethod + async def open_process( + cls, + command: StrOrBytesPath | Sequence[StrOrBytesPath], + *, + stdin: int | IO[Any] | None, + stdout: int | IO[Any] | None, + stderr: int | IO[Any] | None, + **kwargs: Any, + ) -> Process: + pass + + @classmethod + @abstractmethod + def setup_process_pool_exit_at_shutdown(cls, workers: set[Process]) -> None: + pass + + @classmethod + @abstractmethod + async def connect_tcp( + cls, host: str, port: int, local_address: IPSockAddrType | None = None + ) -> SocketStream: + pass + + @classmethod + @abstractmethod + async def connect_unix(cls, path: str | bytes) -> UNIXSocketStream: + pass + + @classmethod + @abstractmethod + def create_tcp_listener(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + def create_unix_listener(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + async def create_udp_socket( + cls, + family: AddressFamily, + local_address: IPSockAddrType | None, + remote_address: IPSockAddrType | None, + reuse_port: bool, + ) -> UDPSocket | ConnectedUDPSocket: + pass + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: None + ) -> UNIXDatagramSocket: ... + + @classmethod + @overload + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: str | bytes + ) -> ConnectedUNIXDatagramSocket: ... + + @classmethod + @abstractmethod + async def create_unix_datagram_socket( + cls, raw_socket: socket, remote_path: str | bytes | None + ) -> UNIXDatagramSocket | ConnectedUNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + async def getaddrinfo( + cls, + host: bytes | str | None, + port: str | int | None, + *, + family: int | AddressFamily = 0, + type: int | SocketKind = 0, + proto: int = 0, + flags: int = 0, + ) -> Sequence[ + tuple[ + AddressFamily, + SocketKind, + int, + str, + tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], + ] + ]: + pass + + @classmethod + @abstractmethod + async def getnameinfo( + cls, sockaddr: IPSockAddrType, flags: int = 0 + ) -> tuple[str, str]: + pass + + @classmethod + @abstractmethod + async def wait_readable(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + async def wait_writable(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + def notify_closing(cls, obj: FileDescriptorLike) -> None: + pass + + @classmethod + @abstractmethod + async def wrap_listener_socket(cls, sock: socket) -> SocketListener: + pass + + @classmethod + @abstractmethod + async def wrap_stream_socket(cls, sock: socket) -> SocketStream: + pass + + @classmethod + @abstractmethod + async def wrap_unix_stream_socket(cls, sock: socket) -> UNIXSocketStream: + pass + + @classmethod + @abstractmethod + async def wrap_udp_socket(cls, sock: socket) -> UDPSocket: + pass + + @classmethod + @abstractmethod + async def wrap_connected_udp_socket(cls, sock: socket) -> ConnectedUDPSocket: + pass + + @classmethod + @abstractmethod + async def wrap_unix_datagram_socket(cls, sock: socket) -> UNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + async def wrap_connected_unix_datagram_socket( + cls, sock: socket + ) -> ConnectedUNIXDatagramSocket: + pass + + @classmethod + @abstractmethod + def current_default_thread_limiter(cls) -> CapacityLimiter: + pass + + @classmethod + @abstractmethod + def open_signal_receiver( + cls, *signals: Signals + ) -> AbstractContextManager[AsyncIterator[Signals]]: + pass + + @classmethod + @abstractmethod + def get_current_task(cls) -> TaskInfo: + pass + + @classmethod + @abstractmethod + def get_running_tasks(cls) -> Sequence[TaskInfo]: + pass + + @classmethod + @abstractmethod + async def wait_all_tasks_blocked(cls) -> None: + pass + + @classmethod + @abstractmethod + def create_test_runner(cls, options: dict[str, Any]) -> TestRunner: + pass diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_resources.py b/.venv/lib/python3.10/site-packages/anyio/abc/_resources.py new file mode 100644 index 0000000..10df115 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_resources.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from abc import ABCMeta, abstractmethod +from types import TracebackType +from typing import TypeVar + +T = TypeVar("T") + + +class AsyncResource(metaclass=ABCMeta): + """ + Abstract base class for all closeable asynchronous resources. + + Works as an asynchronous context manager which returns the instance itself on enter, + and calls :meth:`aclose` on exit. + """ + + __slots__ = () + + async def __aenter__(self: T) -> T: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + await self.aclose() + + @abstractmethod + async def aclose(self) -> None: + """Close the resource.""" diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_sockets.py b/.venv/lib/python3.10/site-packages/anyio/abc/_sockets.py new file mode 100644 index 0000000..feb26bd --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_sockets.py @@ -0,0 +1,399 @@ +from __future__ import annotations + +import errno +import socket +from abc import abstractmethod +from collections.abc import Callable, Collection, Mapping +from contextlib import AsyncExitStack +from io import IOBase +from ipaddress import IPv4Address, IPv6Address +from socket import AddressFamily +from typing import Any, TypeAlias, TypeVar + +from .._core._eventloop import get_async_backend +from .._core._typedattr import ( + TypedAttributeProvider, + TypedAttributeSet, + typed_attribute, +) +from ._streams import ByteStream, Listener, UnreliableObjectStream +from ._tasks import TaskGroup + +IPAddressType: TypeAlias = str | IPv4Address | IPv6Address +IPSockAddrType: TypeAlias = tuple[str, int] +SockAddrType: TypeAlias = IPSockAddrType | str +UDPPacketType: TypeAlias = tuple[bytes, IPSockAddrType] +UNIXDatagramPacketType: TypeAlias = tuple[bytes, str] +T_Retval = TypeVar("T_Retval") + + +def _validate_socket( + sock_or_fd: socket.socket | int, + sock_type: socket.SocketKind, + addr_family: socket.AddressFamily = socket.AF_UNSPEC, + *, + require_connected: bool = False, + require_bound: bool = False, +) -> socket.socket: + if isinstance(sock_or_fd, int): + try: + sock = socket.socket(fileno=sock_or_fd) + except OSError as exc: + if exc.errno == errno.ENOTSOCK: + raise ValueError( + "the file descriptor does not refer to a socket" + ) from exc + elif require_connected: + raise ValueError("the socket must be connected") from exc + elif require_bound: + raise ValueError("the socket must be bound to a local address") from exc + else: + raise + elif isinstance(sock_or_fd, socket.socket): + sock = sock_or_fd + else: + raise TypeError( + f"expected an int or socket, got {type(sock_or_fd).__qualname__} instead" + ) + + try: + if require_connected: + try: + sock.getpeername() + except OSError as exc: + raise ValueError("the socket must be connected") from exc + + if require_bound: + try: + if sock.family in (socket.AF_INET, socket.AF_INET6): + bound_addr = sock.getsockname()[1] + else: + bound_addr = sock.getsockname() + except OSError: + bound_addr = None + + if not bound_addr: + raise ValueError("the socket must be bound to a local address") + + if addr_family != socket.AF_UNSPEC and sock.family != addr_family: + raise ValueError( + f"address family mismatch: expected {addr_family.name}, got " + f"{sock.family.name}" + ) + + if sock.type != sock_type: + raise ValueError( + f"socket type mismatch: expected {sock_type.name}, got {sock.type.name}" + ) + except BaseException: + # Avoid ResourceWarning from the locally constructed socket object + if isinstance(sock_or_fd, int): + sock.detach() + + raise + + sock.setblocking(False) + return sock + + +class SocketAttribute(TypedAttributeSet): + """ + .. attribute:: family + :type: socket.AddressFamily + + the address family of the underlying socket + + .. attribute:: local_address + :type: tuple[str, int] | str + + the local address the underlying socket is connected to + + .. attribute:: local_port + :type: int + + for IP based sockets, the local port the underlying socket is bound to + + .. attribute:: raw_socket + :type: socket.socket + + the underlying stdlib socket object + + .. attribute:: remote_address + :type: tuple[str, int] | str + + the remote address the underlying socket is connected to + + .. attribute:: remote_port + :type: int + + for IP based sockets, the remote port the underlying socket is connected to + """ + + family: AddressFamily = typed_attribute() + local_address: SockAddrType = typed_attribute() + local_port: int = typed_attribute() + raw_socket: socket.socket = typed_attribute() + remote_address: SockAddrType = typed_attribute() + remote_port: int = typed_attribute() + + +class _SocketProvider(TypedAttributeProvider): + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + from .._core._sockets import convert_ipv6_sockaddr as convert + + attributes: dict[Any, Callable[[], Any]] = { + SocketAttribute.family: lambda: self._raw_socket.family, + SocketAttribute.local_address: lambda: convert( + self._raw_socket.getsockname() + ), + SocketAttribute.raw_socket: lambda: self._raw_socket, + } + try: + peername: tuple[str, int] | None = convert(self._raw_socket.getpeername()) + except OSError: + peername = None + + # Provide the remote address for connected sockets + if peername is not None: + attributes[SocketAttribute.remote_address] = lambda: peername + + # Provide local and remote ports for IP based sockets + if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6): + attributes[SocketAttribute.local_port] = lambda: ( + self._raw_socket.getsockname()[1] + ) + if peername is not None: + remote_port = peername[1] + attributes[SocketAttribute.remote_port] = lambda: remote_port + + return attributes + + @property + @abstractmethod + def _raw_socket(self) -> socket.socket: + pass + + +class SocketStream(ByteStream, _SocketProvider): + """ + Transports bytes over a socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> SocketStream: + """ + Wrap an existing socket object or file descriptor as a socket stream. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a socket stream + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_connected=True) + return await get_async_backend().wrap_stream_socket(sock) + + +class UNIXSocketStream(SocketStream): + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> UNIXSocketStream: + """ + Wrap an existing socket object or file descriptor as a UNIX socket stream. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a UNIX socket stream + + """ + sock = _validate_socket( + sock_or_fd, socket.SOCK_STREAM, socket.AF_UNIX, require_connected=True + ) + return await get_async_backend().wrap_unix_stream_socket(sock) + + @abstractmethod + async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None: + """ + Send file descriptors along with a message to the peer. + + :param message: a non-empty bytestring + :param fds: a collection of files (either numeric file descriptors or open file + or socket objects) + """ + + @abstractmethod + async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]: + """ + Receive file descriptors along with a message from the peer. + + :param msglen: length of the message to expect from the peer + :param maxfds: maximum number of file descriptors to expect from the peer + :return: a tuple of (message, file descriptors) + """ + + +class SocketListener(Listener[SocketStream], _SocketProvider): + """ + Listens to incoming socket connections. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> SocketListener: + """ + Wrap an existing socket object or file descriptor as a socket listener. + + The newly created listener takes ownership of the socket being passed in. + + :param sock_or_fd: a socket object or file descriptor + :return: a socket listener + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_bound=True) + return await get_async_backend().wrap_listener_socket(sock) + + @abstractmethod + async def accept(self) -> SocketStream: + """Accept an incoming connection.""" + + async def serve( + self, + handler: Callable[[SocketStream], Any], + task_group: TaskGroup | None = None, + ) -> None: + from .. import create_task_group + + async with AsyncExitStack() as stack: + if task_group is None: + task_group = await stack.enter_async_context(create_task_group()) + + while True: + stream = await self.accept() + task_group.start_soon(handler, stream) + + +class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider): + """ + Represents an unconnected UDP socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> UDPSocket: + """ + Wrap an existing socket object or file descriptor as a UDP socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must be bound to a local address. + + :param sock_or_fd: a socket object or file descriptor + :return: a UDP socket + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, require_bound=True) + return await get_async_backend().wrap_udp_socket(sock) + + async def sendto(self, data: bytes, host: str, port: int) -> None: + """ + Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port))). + + """ + return await self.send((data, (host, port))) + + +class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider): + """ + Represents an connected UDP socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket(cls, sock_or_fd: socket.socket | int) -> ConnectedUDPSocket: + """ + Wrap an existing socket object or file descriptor as a connected UDP socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a connected UDP socket + + """ + sock = _validate_socket( + sock_or_fd, + socket.SOCK_DGRAM, + require_connected=True, + ) + return await get_async_backend().wrap_connected_udp_socket(sock) + + +class UNIXDatagramSocket( + UnreliableObjectStream[UNIXDatagramPacketType], _SocketProvider +): + """ + Represents an unconnected Unix datagram socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> UNIXDatagramSocket: + """ + Wrap an existing socket object or file descriptor as a UNIX datagram + socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + + :param sock_or_fd: a socket object or file descriptor + :return: a UNIX datagram socket + + """ + sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX) + return await get_async_backend().wrap_unix_datagram_socket(sock) + + async def sendto(self, data: bytes, path: str) -> None: + """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, path)).""" + return await self.send((data, path)) + + +class ConnectedUNIXDatagramSocket(UnreliableObjectStream[bytes], _SocketProvider): + """ + Represents a connected Unix datagram socket. + + Supports all relevant extra attributes from :class:`~SocketAttribute`. + """ + + @classmethod + async def from_socket( + cls, + sock_or_fd: socket.socket | int, + ) -> ConnectedUNIXDatagramSocket: + """ + Wrap an existing socket object or file descriptor as a connected UNIX datagram + socket. + + The newly created socket wrapper takes ownership of the socket being passed in. + The existing socket must already be connected. + + :param sock_or_fd: a socket object or file descriptor + :return: a connected UNIX datagram socket + + """ + sock = _validate_socket( + sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX, require_connected=True + ) + return await get_async_backend().wrap_connected_unix_datagram_socket(sock) diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_streams.py b/.venv/lib/python3.10/site-packages/anyio/abc/_streams.py new file mode 100644 index 0000000..186e3f5 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_streams.py @@ -0,0 +1,233 @@ +from __future__ import annotations + +from abc import ABCMeta, abstractmethod +from collections.abc import Callable +from typing import Any, Generic, TypeAlias, TypeVar + +from .._core._exceptions import EndOfStream +from .._core._typedattr import TypedAttributeProvider +from ._resources import AsyncResource +from ._tasks import TaskGroup + +T_Item = TypeVar("T_Item") +T_co = TypeVar("T_co", covariant=True) +T_contra = TypeVar("T_contra", contravariant=True) + + +class UnreliableObjectReceiveStream( + Generic[T_co], AsyncResource, TypedAttributeProvider +): + """ + An interface for receiving objects. + + This interface makes no guarantees that the received messages arrive in the order in + which they were sent, or that no messages are missed. + + Asynchronously iterating over objects of this type will yield objects matching the + given type parameter. + """ + + def __aiter__(self) -> UnreliableObjectReceiveStream[T_co]: + return self + + async def __anext__(self) -> T_co: + try: + return await self.receive() + except EndOfStream: + raise StopAsyncIteration from None + + @abstractmethod + async def receive(self) -> T_co: + """ + Receive the next item. + + :raises ~anyio.ClosedResourceError: if the receive stream has been explicitly + closed + :raises ~anyio.EndOfStream: if this stream has been closed from the other end + :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable + due to external causes + """ + + +class UnreliableObjectSendStream( + Generic[T_contra], AsyncResource, TypedAttributeProvider +): + """ + An interface for sending objects. + + This interface makes no guarantees that the messages sent will reach the + recipient(s) in the same order in which they were sent, or at all. + """ + + @abstractmethod + async def send(self, item: T_contra) -> None: + """ + Send an item to the peer(s). + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if the send stream has been explicitly + closed + :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable + due to external causes + """ + + +class UnreliableObjectStream( + UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item] +): + """ + A bidirectional message stream which does not guarantee the order or reliability of + message delivery. + """ + + +class ObjectReceiveStream(UnreliableObjectReceiveStream[T_co]): + """ + A receive message stream which guarantees that messages are received in the same + order in which they were sent, and that no messages are missed. + """ + + +class ObjectSendStream(UnreliableObjectSendStream[T_contra]): + """ + A send message stream which guarantees that messages are delivered in the same order + in which they were sent, without missing any messages in the middle. + """ + + +class ObjectStream( + ObjectReceiveStream[T_Item], + ObjectSendStream[T_Item], + UnreliableObjectStream[T_Item], +): + """ + A bidirectional message stream which guarantees the order and reliability of message + delivery. + """ + + @abstractmethod + async def send_eof(self) -> None: + """ + Send an end-of-file indication to the peer. + + You should not try to send any further data to this stream after calling this + method. This method is idempotent (does nothing on successive calls). + """ + + +class ByteReceiveStream(AsyncResource, TypedAttributeProvider): + """ + An interface for receiving bytes from a single peer. + + Iterating this byte stream will yield a byte string of arbitrary length, but no more + than 65536 bytes. + """ + + def __aiter__(self) -> ByteReceiveStream: + return self + + async def __anext__(self) -> bytes: + try: + return await self.receive() + except EndOfStream: + raise StopAsyncIteration from None + + @abstractmethod + async def receive(self, max_bytes: int = 65536) -> bytes: + """ + Receive at most ``max_bytes`` bytes from the peer. + + .. note:: Implementers of this interface should not return an empty + :class:`bytes` object, and users should ignore them. + + :param max_bytes: maximum number of bytes to receive + :return: the received bytes + :raises ~anyio.EndOfStream: if this stream has been closed from the other end + """ + + +class ByteSendStream(AsyncResource, TypedAttributeProvider): + """An interface for sending bytes to a single peer.""" + + @abstractmethod + async def send(self, item: bytes) -> None: + """ + Send the given bytes to the peer. + + :param item: the bytes to send + """ + + +class ByteStream(ByteReceiveStream, ByteSendStream): + """A bidirectional byte stream.""" + + @abstractmethod + async def send_eof(self) -> None: + """ + Send an end-of-file indication to the peer. + + You should not try to send any further data to this stream after calling this + method. This method is idempotent (does nothing on successive calls). + """ + + +#: Type alias for all unreliable bytes-oriented receive streams. +AnyUnreliableByteReceiveStream: TypeAlias = ( + UnreliableObjectReceiveStream[bytes] | ByteReceiveStream +) +#: Type alias for all unreliable bytes-oriented send streams. +AnyUnreliableByteSendStream: TypeAlias = ( + UnreliableObjectSendStream[bytes] | ByteSendStream +) +#: Type alias for all unreliable bytes-oriented streams. +AnyUnreliableByteStream: TypeAlias = UnreliableObjectStream[bytes] | ByteStream +#: Type alias for all bytes-oriented receive streams. +AnyByteReceiveStream: TypeAlias = ObjectReceiveStream[bytes] | ByteReceiveStream +#: Type alias for all bytes-oriented send streams. +AnyByteSendStream: TypeAlias = ObjectSendStream[bytes] | ByteSendStream +#: Type alias for all bytes-oriented streams. +AnyByteStream: TypeAlias = ObjectStream[bytes] | ByteStream + + +class Listener(Generic[T_co], AsyncResource, TypedAttributeProvider): + """An interface for objects that let you accept incoming connections.""" + + @abstractmethod + async def serve( + self, handler: Callable[[T_co], Any], task_group: TaskGroup | None = None + ) -> None: + """ + Accept incoming connections as they come in and start tasks to handle them. + + :param handler: a callable that will be used to handle each accepted connection + :param task_group: the task group that will be used to start tasks for handling + each accepted connection (if omitted, an ad-hoc task group will be created) + """ + + +class ObjectStreamConnectable(Generic[T_co], metaclass=ABCMeta): + @abstractmethod + async def connect(self) -> ObjectStream[T_co]: + """ + Connect to the remote endpoint. + + :return: an object stream connected to the remote end + :raises ConnectionFailed: if the connection fails + """ + + +class ByteStreamConnectable(metaclass=ABCMeta): + @abstractmethod + async def connect(self) -> ByteStream: + """ + Connect to the remote endpoint. + + :return: a bytestream connected to the remote end + :raises ConnectionFailed: if the connection fails + """ + + +#: Type alias for all connectables returning bytestreams or bytes-oriented object streams +AnyByteStreamConnectable: TypeAlias = ( + ObjectStreamConnectable[bytes] | ByteStreamConnectable +) diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_subprocesses.py b/.venv/lib/python3.10/site-packages/anyio/abc/_subprocesses.py new file mode 100644 index 0000000..ce0564c --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_subprocesses.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +from abc import abstractmethod +from signal import Signals + +from ._resources import AsyncResource +from ._streams import ByteReceiveStream, ByteSendStream + + +class Process(AsyncResource): + """An asynchronous version of :class:`subprocess.Popen`.""" + + @abstractmethod + async def wait(self) -> int: + """ + Wait until the process exits. + + :return: the exit code of the process + """ + + @abstractmethod + def terminate(self) -> None: + """ + Terminates the process, gracefully if possible. + + On Windows, this calls ``TerminateProcess()``. + On POSIX systems, this sends ``SIGTERM`` to the process. + + .. seealso:: :meth:`subprocess.Popen.terminate` + """ + + @abstractmethod + def kill(self) -> None: + """ + Kills the process. + + On Windows, this calls ``TerminateProcess()``. + On POSIX systems, this sends ``SIGKILL`` to the process. + + .. seealso:: :meth:`subprocess.Popen.kill` + """ + + @abstractmethod + def send_signal(self, signal: Signals) -> None: + """ + Send a signal to the subprocess. + + .. seealso:: :meth:`subprocess.Popen.send_signal` + + :param signal: the signal number (e.g. :data:`signal.SIGHUP`) + """ + + @property + @abstractmethod + def pid(self) -> int: + """The process ID of the process.""" + + @property + @abstractmethod + def returncode(self) -> int | None: + """ + The return code of the process. If the process has not yet terminated, this will + be ``None``. + """ + + @property + @abstractmethod + def stdin(self) -> ByteSendStream | None: + """The stream for the standard input of the process.""" + + @property + @abstractmethod + def stdout(self) -> ByteReceiveStream | None: + """The stream for the standard output of the process.""" + + @property + @abstractmethod + def stderr(self) -> ByteReceiveStream | None: + """The stream for the standard error output of the process.""" diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_tasks.py b/.venv/lib/python3.10/site-packages/anyio/abc/_tasks.py new file mode 100644 index 0000000..516b3ec --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_tasks.py @@ -0,0 +1,117 @@ +from __future__ import annotations + +import sys +from abc import ABCMeta, abstractmethod +from collections.abc import Awaitable, Callable +from types import TracebackType +from typing import TYPE_CHECKING, Any, Protocol, overload + +if sys.version_info >= (3, 13): + from typing import TypeVar +else: + from typing_extensions import TypeVar + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if TYPE_CHECKING: + from .._core._tasks import CancelScope + +T_Retval = TypeVar("T_Retval") +T_contra = TypeVar("T_contra", contravariant=True, default=None) +PosArgsT = TypeVarTuple("PosArgsT") + + +class TaskStatus(Protocol[T_contra]): + @overload + def started(self: TaskStatus[None]) -> None: ... + + @overload + def started(self, value: T_contra) -> None: ... + + def started(self, value: T_contra | None = None) -> None: + """ + Signal that the task has started. + + :param value: object passed back to the starter of the task + """ + + +class TaskGroup(metaclass=ABCMeta): + """ + Groups several asynchronous tasks together. + + :ivar cancel_scope: the cancel scope inherited by all child tasks + :vartype cancel_scope: CancelScope + + .. note:: On asyncio, support for eager task factories is considered to be + **experimental**. In particular, they don't follow the usual semantics of new + tasks being scheduled on the next iteration of the event loop, and may thus + cause unexpected behavior in code that wasn't written with such semantics in + mind. + """ + + cancel_scope: CancelScope + + @abstractmethod + def start_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[Any]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> None: + """ + Start a new task in this task group. + + :param func: a coroutine function + :param args: positional arguments to call the function with + :param name: name of the task, for the purposes of introspection and debugging + + .. versionadded:: 3.0 + """ + + @abstractmethod + async def start( + self, + func: Callable[..., Awaitable[Any]], + *args: object, + name: object = None, + ) -> Any: + """ + Start a new task and wait until it signals for readiness. + + The target callable must accept a keyword argument ``task_status`` (of type + :class:`TaskStatus`). Awaiting on this method will return whatever was passed to + ``task_status.started()`` (``None`` by default). + + .. note:: The :class:`TaskStatus` class is generic, and the type argument should + indicate the type of the value that will be passed to + ``task_status.started()``. + + :param func: a coroutine function that accepts the ``task_status`` keyword + argument + :param args: positional arguments to call the function with + :param name: an optional name for the task, for introspection and debugging + :return: the value passed to ``task_status.started()`` + :raises RuntimeError: if the task finishes without calling + ``task_status.started()`` + + .. seealso:: :ref:`start_initialize` + + .. versionadded:: 3.0 + """ + + @abstractmethod + async def __aenter__(self) -> TaskGroup: + """Enter the task group context and allow starting new tasks.""" + + @abstractmethod + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + """Exit the task group context waiting for all tasks to finish.""" diff --git a/.venv/lib/python3.10/site-packages/anyio/abc/_testing.py b/.venv/lib/python3.10/site-packages/anyio/abc/_testing.py new file mode 100644 index 0000000..7c50ed7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/abc/_testing.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import types +from abc import ABCMeta, abstractmethod +from collections.abc import AsyncGenerator, Callable, Coroutine, Iterable +from typing import Any, TypeVar + +_T = TypeVar("_T") + + +class TestRunner(metaclass=ABCMeta): + """ + Encapsulates a running event loop. Every call made through this object will use the + same event loop. + """ + + def __enter__(self) -> TestRunner: + return self + + @abstractmethod + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: types.TracebackType | None, + ) -> bool | None: ... + + @abstractmethod + def run_asyncgen_fixture( + self, + fixture_func: Callable[..., AsyncGenerator[_T, Any]], + kwargs: dict[str, Any], + ) -> Iterable[_T]: + """ + Run an async generator fixture. + + :param fixture_func: the fixture function + :param kwargs: keyword arguments to call the fixture function with + :return: an iterator yielding the value yielded from the async generator + """ + + @abstractmethod + def run_fixture( + self, + fixture_func: Callable[..., Coroutine[Any, Any, _T]], + kwargs: dict[str, Any], + ) -> _T: + """ + Run an async fixture. + + :param fixture_func: the fixture function + :param kwargs: keyword arguments to call the fixture function with + :return: the return value of the fixture function + """ + + @abstractmethod + def run_test( + self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any] + ) -> None: + """ + Run an async test function. + + :param test_func: the test function + :param kwargs: keyword arguments to call the test function with + """ diff --git a/.venv/lib/python3.10/site-packages/anyio/from_thread.py b/.venv/lib/python3.10/site-packages/anyio/from_thread.py new file mode 100644 index 0000000..837de5e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/from_thread.py @@ -0,0 +1,578 @@ +from __future__ import annotations + +__all__ = ( + "BlockingPortal", + "BlockingPortalProvider", + "check_cancelled", + "run", + "run_sync", + "start_blocking_portal", +) + +import sys +from collections.abc import Awaitable, Callable, Generator +from concurrent.futures import Future +from contextlib import ( + AbstractAsyncContextManager, + AbstractContextManager, + contextmanager, +) +from dataclasses import dataclass, field +from functools import partial +from inspect import isawaitable +from threading import Lock, Thread, current_thread, get_ident +from types import TracebackType +from typing import ( + Any, + Generic, + TypeVar, + cast, + overload, +) + +from ._core._eventloop import ( + get_cancelled_exc_class, + threadlocals, +) +from ._core._eventloop import run as run_eventloop +from ._core._exceptions import NoEventLoopError +from ._core._synchronization import Event +from ._core._tasks import CancelScope, create_task_group +from .abc._tasks import TaskStatus +from .lowlevel import EventLoopToken, current_token + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +T_Retval = TypeVar("T_Retval") +T_co = TypeVar("T_co", covariant=True) +PosArgsT = TypeVarTuple("PosArgsT") + + +def _token_or_error(token: EventLoopToken | None) -> EventLoopToken: + if token is not None: + return token + + try: + return threadlocals.current_token + except AttributeError: + raise NoEventLoopError( + "Not running inside an AnyIO worker thread, and no event loop token was " + "provided" + ) from None + + +def run( + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + *args: Unpack[PosArgsT], + token: EventLoopToken | None = None, +) -> T_Retval: + """ + Call a coroutine function from a worker thread. + + :param func: a coroutine function + :param args: positional arguments for the callable + :param token: an event loop token to use to get back to the event loop thread + (required if calling this function from outside an AnyIO worker thread) + :return: the return value of the coroutine function + :raises MissingTokenError: if no token was provided and called from outside an + AnyIO worker thread + :raises RunFinishedError: if the event loop tied to ``token`` is no longer running + + .. versionchanged:: 4.11.0 + Added the ``token`` parameter. + + """ + explicit_token = token is not None + token = _token_or_error(token) + return token.backend_class.run_async_from_thread( + func, args, token=token.native_token if explicit_token else None + ) + + +def run_sync( + func: Callable[[Unpack[PosArgsT]], T_Retval], + *args: Unpack[PosArgsT], + token: EventLoopToken | None = None, +) -> T_Retval: + """ + Call a function in the event loop thread from a worker thread. + + :param func: a callable + :param args: positional arguments for the callable + :param token: an event loop token to use to get back to the event loop thread + (required if calling this function from outside an AnyIO worker thread) + :return: the return value of the callable + :raises MissingTokenError: if no token was provided and called from outside an + AnyIO worker thread + :raises RunFinishedError: if the event loop tied to ``token`` is no longer running + + .. versionchanged:: 4.11.0 + Added the ``token`` parameter. + + """ + explicit_token = token is not None + token = _token_or_error(token) + return token.backend_class.run_sync_from_thread( + func, args, token=token.native_token if explicit_token else None + ) + + +class _BlockingAsyncContextManager(Generic[T_co], AbstractContextManager): + _enter_future: Future[T_co] + _exit_future: Future[bool | None] + _exit_event: Event + _exit_exc_info: tuple[ + type[BaseException] | None, BaseException | None, TracebackType | None + ] = (None, None, None) + + def __init__( + self, async_cm: AbstractAsyncContextManager[T_co], portal: BlockingPortal + ): + self._async_cm = async_cm + self._portal = portal + + async def run_async_cm(self) -> bool | None: + try: + self._exit_event = Event() + value = await self._async_cm.__aenter__() + except BaseException as exc: + self._enter_future.set_exception(exc) + raise + else: + self._enter_future.set_result(value) + + try: + # Wait for the sync context manager to exit. + # This next statement can raise `get_cancelled_exc_class()` if + # something went wrong in a task group in this async context + # manager. + await self._exit_event.wait() + finally: + # In case of cancellation, it could be that we end up here before + # `_BlockingAsyncContextManager.__exit__` is called, and an + # `_exit_exc_info` has been set. + result = await self._async_cm.__aexit__(*self._exit_exc_info) + + return result + + def __enter__(self) -> T_co: + self._enter_future = Future() + self._exit_future = self._portal.start_task_soon(self.run_async_cm) + return self._enter_future.result() + + def __exit__( + self, + __exc_type: type[BaseException] | None, + __exc_value: BaseException | None, + __traceback: TracebackType | None, + ) -> bool | None: + self._exit_exc_info = __exc_type, __exc_value, __traceback + self._portal.call(self._exit_event.set) + return self._exit_future.result() + + +class _BlockingPortalTaskStatus(TaskStatus): + def __init__(self, future: Future): + self._future = future + + def started(self, value: object = None) -> None: + self._future.set_result(value) + + +class BlockingPortal: + """ + An object that lets external threads run code in an asynchronous event loop. + + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + """ + + def __init__(self) -> None: + self._token = current_token() + self._event_loop_thread_id: int | None = get_ident() + self._stop_event = Event() + self._task_group = create_task_group() + + async def __aenter__(self) -> BlockingPortal: + await self._task_group.__aenter__() + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> bool: + await self.stop() + return await self._task_group.__aexit__(exc_type, exc_val, exc_tb) + + def _check_running(self) -> None: + if self._event_loop_thread_id is None: + raise RuntimeError("This portal is not running") + if self._event_loop_thread_id == get_ident(): + raise RuntimeError( + "This method cannot be called from the event loop thread" + ) + + async def sleep_until_stopped(self) -> None: + """Sleep until :meth:`stop` is called.""" + await self._stop_event.wait() + + async def stop(self, cancel_remaining: bool = False) -> None: + """ + Signal the portal to shut down. + + This marks the portal as no longer accepting new calls and exits from + :meth:`sleep_until_stopped`. + + :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False`` + to let them finish before returning + + """ + self._event_loop_thread_id = None + self._stop_event.set() + if cancel_remaining: + self._task_group.cancel_scope.cancel("the blocking portal is shutting down") + + async def _call_func( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + future: Future[T_Retval], + ) -> None: + def callback(f: Future[T_Retval]) -> None: + if f.cancelled(): + if self._event_loop_thread_id == get_ident(): + scope.cancel("the future was cancelled") + elif self._event_loop_thread_id is not None: + self.call(scope.cancel, "the future was cancelled") + + try: + retval_or_awaitable = func(*args, **kwargs) + if isawaitable(retval_or_awaitable): + with CancelScope() as scope: + future.add_done_callback(callback) + retval = await retval_or_awaitable + else: + retval = retval_or_awaitable + except get_cancelled_exc_class(): + future.cancel() + future.set_running_or_notify_cancel() + except BaseException as exc: + if not future.cancelled(): + future.set_exception(exc) + + # Let base exceptions fall through + if not isinstance(exc, Exception): + raise + else: + if not future.cancelled(): + future.set_result(retval) + finally: + scope = None # type: ignore[assignment] + + def _spawn_task_from_thread( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval], + args: tuple[Unpack[PosArgsT]], + kwargs: dict[str, Any], + name: object, + future: Future[T_Retval], + ) -> None: + """ + Spawn a new task using the given callable. + + :param func: a callable + :param args: positional arguments to be passed to the callable + :param kwargs: keyword arguments to be passed to the callable + :param name: name of the task (will be coerced to a string if not ``None``) + :param future: a future that will resolve to the return value of the callable, + or the exception raised during its execution + + """ + run_sync( + partial(self._task_group.start_soon, name=name), + self._call_func, + func, + args, + kwargs, + future, + token=self._token, + ) + + @overload + def call( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + *args: Unpack[PosArgsT], + ) -> T_Retval: ... + + @overload + def call( + self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT] + ) -> T_Retval: ... + + def call( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval], + *args: Unpack[PosArgsT], + ) -> T_Retval: + """ + Call the given function in the event loop thread. + + If the callable returns a coroutine object, it is awaited on. + + :param func: any callable + :raises RuntimeError: if the portal is not running or if this method is called + from within the event loop thread + + """ + return cast(T_Retval, self.start_task_soon(func, *args).result()) + + @overload + def start_task_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], + *args: Unpack[PosArgsT], + name: object = None, + ) -> Future[T_Retval]: ... + + @overload + def start_task_soon( + self, + func: Callable[[Unpack[PosArgsT]], T_Retval], + *args: Unpack[PosArgsT], + name: object = None, + ) -> Future[T_Retval]: ... + + def start_task_soon( + self, + func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval], + *args: Unpack[PosArgsT], + name: object = None, + ) -> Future[T_Retval]: + """ + Start a task in the portal's task group. + + The task will be run inside a cancel scope which can be cancelled by cancelling + the returned future. + + :param func: the target function + :param args: positional arguments passed to ``func`` + :param name: name of the task (will be coerced to a string if not ``None``) + :return: a future that resolves with the return value of the callable if the + task completes successfully, or with the exception raised in the task + :raises RuntimeError: if the portal is not running or if this method is called + from within the event loop thread + :rtype: concurrent.futures.Future[T_Retval] + + .. versionadded:: 3.0 + + """ + self._check_running() + f: Future[T_Retval] = Future() + self._spawn_task_from_thread(func, args, {}, name, f) + return f + + def start_task( + self, + func: Callable[..., Awaitable[T_Retval]], + *args: object, + name: object = None, + ) -> tuple[Future[T_Retval], Any]: + """ + Start a task in the portal's task group and wait until it signals for readiness. + + This method works the same way as :meth:`.abc.TaskGroup.start`. + + :param func: the target function + :param args: positional arguments passed to ``func`` + :param name: name of the task (will be coerced to a string if not ``None``) + :return: a tuple of (future, task_status_value) where the ``task_status_value`` + is the value passed to ``task_status.started()`` from within the target + function + :rtype: tuple[concurrent.futures.Future[T_Retval], Any] + + .. versionadded:: 3.0 + + """ + + def task_done(future: Future[T_Retval]) -> None: + if not task_status_future.done(): + if future.cancelled(): + task_status_future.cancel() + elif future.exception(): + task_status_future.set_exception(future.exception()) + else: + exc = RuntimeError( + "Task exited without calling task_status.started()" + ) + task_status_future.set_exception(exc) + + self._check_running() + task_status_future: Future = Future() + task_status = _BlockingPortalTaskStatus(task_status_future) + f: Future = Future() + f.add_done_callback(task_done) + self._spawn_task_from_thread(func, args, {"task_status": task_status}, name, f) + return f, task_status_future.result() + + def wrap_async_context_manager( + self, cm: AbstractAsyncContextManager[T_co] + ) -> AbstractContextManager[T_co]: + """ + Wrap an async context manager as a synchronous context manager via this portal. + + Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping + in the middle until the synchronous context manager exits. + + :param cm: an asynchronous context manager + :return: a synchronous context manager + + .. versionadded:: 2.1 + + """ + return _BlockingAsyncContextManager(cm, self) + + +@dataclass +class BlockingPortalProvider: + """ + A manager for a blocking portal. Used as a context manager. The first thread to + enter this context manager causes a blocking portal to be started with the specific + parameters, and the last thread to exit causes the portal to be shut down. Thus, + there will be exactly one blocking portal running in this context as long as at + least one thread has entered this context manager. + + The parameters are the same as for :func:`~anyio.run`. + + :param backend: name of the backend + :param backend_options: backend options + + .. versionadded:: 4.4 + """ + + backend: str = "asyncio" + backend_options: dict[str, Any] | None = None + _lock: Lock = field(init=False, default_factory=Lock) + _leases: int = field(init=False, default=0) + _portal: BlockingPortal = field(init=False) + _portal_cm: AbstractContextManager[BlockingPortal] | None = field( + init=False, default=None + ) + + def __enter__(self) -> BlockingPortal: + with self._lock: + if self._portal_cm is None: + self._portal_cm = start_blocking_portal( + self.backend, self.backend_options + ) + self._portal = self._portal_cm.__enter__() + + self._leases += 1 + return self._portal + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + portal_cm: AbstractContextManager[BlockingPortal] | None = None + with self._lock: + assert self._portal_cm + assert self._leases > 0 + self._leases -= 1 + if not self._leases: + portal_cm = self._portal_cm + self._portal_cm = None + del self._portal + + if portal_cm: + portal_cm.__exit__(None, None, None) + + +@contextmanager +def start_blocking_portal( + backend: str = "asyncio", + backend_options: dict[str, Any] | None = None, + *, + name: str | None = None, +) -> Generator[BlockingPortal, Any, None]: + """ + Start a new event loop in a new thread and run a blocking portal in its main task. + + The parameters are the same as for :func:`~anyio.run`. + + :param backend: name of the backend + :param backend_options: backend options + :param name: name of the thread + :return: a context manager that yields a blocking portal + + .. versionchanged:: 3.0 + Usage as a context manager is now required. + + """ + + async def run_portal() -> None: + async with BlockingPortal() as portal_: + if name is None: + current_thread().name = f"{backend}-portal-{id(portal_):x}" + + future.set_result(portal_) + await portal_.sleep_until_stopped() + + def run_blocking_portal() -> None: + if future.set_running_or_notify_cancel(): + try: + run_eventloop( + run_portal, backend=backend, backend_options=backend_options + ) + except BaseException as exc: + if not future.done(): + future.set_exception(exc) + + future: Future[BlockingPortal] = Future() + thread = Thread(target=run_blocking_portal, daemon=True, name=name) + thread.start() + try: + cancel_remaining_tasks = False + portal = future.result() + try: + yield portal + except BaseException: + cancel_remaining_tasks = True + raise + finally: + try: + portal.call(portal.stop, cancel_remaining_tasks) + except RuntimeError: + pass + finally: + thread.join() + + +def check_cancelled() -> None: + """ + Check if the cancel scope of the host task's running the current worker thread has + been cancelled. + + If the host task's current cancel scope has indeed been cancelled, the + backend-specific cancellation exception will be raised. + + :raises RuntimeError: if the current thread was not spawned by + :func:`.to_thread.run_sync` + + """ + try: + token: EventLoopToken = threadlocals.current_token + except AttributeError: + raise NoEventLoopError( + "This function can only be called inside an AnyIO worker thread" + ) from None + + token.backend_class.check_cancelled() diff --git a/.venv/lib/python3.10/site-packages/anyio/functools.py b/.venv/lib/python3.10/site-packages/anyio/functools.py new file mode 100644 index 0000000..f1d6c7c --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/functools.py @@ -0,0 +1,409 @@ +from __future__ import annotations + +__all__ = ( + "AsyncCacheInfo", + "AsyncCacheParameters", + "AsyncLRUCacheWrapper", + "cache", + "lru_cache", + "reduce", +) + +import functools +import sys +from collections import OrderedDict +from collections.abc import ( + AsyncIterable, + Awaitable, + Callable, + Coroutine, + Hashable, + Iterable, +) +from functools import update_wrapper +from inspect import iscoroutinefunction +from typing import ( + Any, + Generic, + NamedTuple, + TypedDict, + TypeVar, + cast, + final, + overload, +) +from weakref import WeakKeyDictionary + +from ._core._eventloop import current_time +from ._core._synchronization import Lock +from .lowlevel import RunVar, checkpoint + +if sys.version_info >= (3, 11): + from typing import ParamSpec +else: + from typing_extensions import ParamSpec + +T = TypeVar("T") +S = TypeVar("S") +P = ParamSpec("P") +lru_cache_items: RunVar[ + WeakKeyDictionary[ + AsyncLRUCacheWrapper[Any, Any], + OrderedDict[ + Hashable, + tuple[_InitialMissingType, Lock, float | None] + | tuple[Any, None, float | None], + ], + ] +] = RunVar("lru_cache_items") + + +class _InitialMissingType: + pass + + +initial_missing: _InitialMissingType = _InitialMissingType() + + +class AsyncCacheInfo(NamedTuple): + hits: int + misses: int + maxsize: int | None + currsize: int + ttl: int | None + + +class AsyncCacheParameters(TypedDict): + maxsize: int | None + typed: bool + always_checkpoint: bool + ttl: int | None + + +class _LRUMethodWrapper(Generic[T]): + def __init__(self, wrapper: AsyncLRUCacheWrapper[..., T], instance: object): + self.__wrapper = wrapper + self.__instance = instance + + def cache_info(self) -> AsyncCacheInfo: + return self.__wrapper.cache_info() + + def cache_parameters(self) -> AsyncCacheParameters: + return self.__wrapper.cache_parameters() + + def cache_clear(self) -> None: + self.__wrapper.cache_clear() + + async def __call__(self, *args: Any, **kwargs: Any) -> T: + if self.__instance is None: + return await self.__wrapper(*args, **kwargs) + + return await self.__wrapper(self.__instance, *args, **kwargs) + + +@final +class AsyncLRUCacheWrapper(Generic[P, T]): + def __init__( + self, + func: Callable[P, Awaitable[T]], + maxsize: int | None, + typed: bool, + always_checkpoint: bool, + ttl: int | None, + ): + self.__wrapped__ = func + self._hits: int = 0 + self._misses: int = 0 + self._maxsize = max(maxsize, 0) if maxsize is not None else None + self._currsize: int = 0 + self._typed = typed + self._always_checkpoint = always_checkpoint + self._ttl = ttl + update_wrapper(self, func) + + def cache_info(self) -> AsyncCacheInfo: + return AsyncCacheInfo( + self._hits, self._misses, self._maxsize, self._currsize, self._ttl + ) + + def cache_parameters(self) -> AsyncCacheParameters: + return { + "maxsize": self._maxsize, + "typed": self._typed, + "always_checkpoint": self._always_checkpoint, + "ttl": self._ttl, + } + + def cache_clear(self) -> None: + if cache := lru_cache_items.get(None): + cache.pop(self, None) + self._hits = self._misses = self._currsize = 0 + + async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: + # Easy case first: if maxsize == 0, no caching is done + if self._maxsize == 0: + value = await self.__wrapped__(*args, **kwargs) + self._misses += 1 + return value + + # The key is constructed as a flat tuple to avoid memory overhead + key: tuple[Any, ...] = args + if kwargs: + # initial_missing is used as a separator + key += (initial_missing,) + sum(kwargs.items(), ()) + + if self._typed: + key += tuple(type(arg) for arg in args) + if kwargs: + key += (initial_missing,) + tuple(type(val) for val in kwargs.values()) + + try: + cache = lru_cache_items.get() + except LookupError: + cache = WeakKeyDictionary() + lru_cache_items.set(cache) + + try: + cache_entry = cache[self] + except KeyError: + cache_entry = cache[self] = OrderedDict() + + cached_value: T | _InitialMissingType + try: + cached_value, lock, expires_at = cache_entry[key] + except KeyError: + # We're the first task to call this function + cached_value, lock, expires_at = ( + initial_missing, + Lock(fast_acquire=not self._always_checkpoint), + None, + ) + cache_entry[key] = cached_value, lock, expires_at + + if lock is None: + if expires_at is not None and current_time() >= expires_at: + self._currsize -= 1 + cached_value, lock, expires_at = ( + initial_missing, + Lock(fast_acquire=not self._always_checkpoint), + None, + ) + cache_entry[key] = cached_value, lock, expires_at + else: + # The value was already cached + self._hits += 1 + cache_entry.move_to_end(key) + if self._always_checkpoint: + await checkpoint() + + return cast(T, cached_value) + + async with lock: + # Check if another task filled the cache while we acquired the lock + if (cached_value := cache_entry[key][0]) is initial_missing: + self._misses += 1 + if self._maxsize is not None and self._currsize >= self._maxsize: + cache_entry.popitem(last=False) + else: + self._currsize += 1 + + value = await self.__wrapped__(*args, **kwargs) + expires_at = ( + current_time() + self._ttl if self._ttl is not None else None + ) + cache_entry[key] = value, None, expires_at + else: + # Another task filled the cache while we were waiting for the lock + self._hits += 1 + cache_entry.move_to_end(key) + value = cast(T, cached_value) + + return value + + def __get__( + self, instance: object, owner: type | None = None + ) -> _LRUMethodWrapper[T]: + wrapper = _LRUMethodWrapper(self, instance) + update_wrapper(wrapper, self.__wrapped__) + return wrapper + + +class _LRUCacheWrapper(Generic[T]): + def __init__( + self, maxsize: int | None, typed: bool, always_checkpoint: bool, ttl: int | None + ): + self._maxsize = maxsize + self._typed = typed + self._always_checkpoint = always_checkpoint + self._ttl = ttl + + @overload + def __call__( # type: ignore[overload-overlap] + self, func: Callable[P, Coroutine[Any, Any, T]], / + ) -> AsyncLRUCacheWrapper[P, T]: ... + + @overload + def __call__( + self, func: Callable[..., T], / + ) -> functools._lru_cache_wrapper[T]: ... + + def __call__( + self, f: Callable[P, Coroutine[Any, Any, T]] | Callable[..., T], / + ) -> AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]: + if iscoroutinefunction(f): + return AsyncLRUCacheWrapper( + f, self._maxsize, self._typed, self._always_checkpoint, self._ttl + ) + + return functools.lru_cache(maxsize=self._maxsize, typed=self._typed)(f) # type: ignore[arg-type] + + +@overload +def cache( # type: ignore[overload-overlap] + func: Callable[P, Coroutine[Any, Any, T]], / +) -> AsyncLRUCacheWrapper[P, T]: ... + + +@overload +def cache(func: Callable[..., T], /) -> functools._lru_cache_wrapper[T]: ... + + +def cache( + func: Callable[..., T] | Callable[P, Coroutine[Any, Any, T]], / +) -> AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]: + """ + A convenient shortcut for :func:`lru_cache` with ``maxsize=None``. + + This is the asynchronous equivalent to :func:`functools.cache`. + + """ + return lru_cache(maxsize=None)(func) + + +@overload +def lru_cache( + *, + maxsize: int | None = ..., + typed: bool = ..., + always_checkpoint: bool = ..., + ttl: int | None = ..., +) -> _LRUCacheWrapper[Any]: ... + + +@overload +def lru_cache( # type: ignore[overload-overlap] + func: Callable[P, Coroutine[Any, Any, T]], / +) -> AsyncLRUCacheWrapper[P, T]: ... + + +@overload +def lru_cache(func: Callable[..., T], /) -> functools._lru_cache_wrapper[T]: ... + + +def lru_cache( + func: Callable[P, Coroutine[Any, Any, T]] | Callable[..., T] | None = None, + /, + *, + maxsize: int | None = 128, + typed: bool = False, + always_checkpoint: bool = False, + ttl: int | None = None, +) -> ( + AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T] | _LRUCacheWrapper[Any] +): + """ + An asynchronous version of :func:`functools.lru_cache`. + + If a synchronous function is passed, the standard library + :func:`functools.lru_cache` is applied instead. + + :param always_checkpoint: if ``True``, every call to the cached function will be + guaranteed to yield control to the event loop at least once + :param ttl: time in seconds after which to invalidate cache entries + + .. note:: Caches and locks are managed on a per-event loop basis. + + """ + if func is None: + return _LRUCacheWrapper[Any](maxsize, typed, always_checkpoint, ttl) + + if not callable(func): + raise TypeError("the first argument must be callable") + + return _LRUCacheWrapper[T](maxsize, typed, always_checkpoint, ttl)(func) + + +@overload +async def reduce( + function: Callable[[T, S], Awaitable[T]], + iterable: Iterable[S] | AsyncIterable[S], + /, + initial: T, +) -> T: ... + + +@overload +async def reduce( + function: Callable[[T, T], Awaitable[T]], + iterable: Iterable[T] | AsyncIterable[T], + /, +) -> T: ... + + +async def reduce( # type: ignore[misc] + function: Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]], + iterable: Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S], + /, + initial: T | _InitialMissingType = initial_missing, +) -> T: + """ + Asynchronous version of :func:`functools.reduce`. + + :param function: a coroutine function that takes two arguments: the accumulated + value and the next element from the iterable + :param iterable: an iterable or async iterable + :param initial: the initial value (if missing, the first element of the iterable is + used as the initial value) + + """ + element: Any + function_called = False + if isinstance(iterable, AsyncIterable): + async_it = iterable.__aiter__() + if initial is initial_missing: + try: + value = cast(T, await async_it.__anext__()) + except StopAsyncIteration: + raise TypeError( + "reduce() of empty sequence with no initial value" + ) from None + else: + value = cast(T, initial) + + async for element in async_it: + value = await function(value, element) + function_called = True + elif isinstance(iterable, Iterable): + it = iter(iterable) + if initial is initial_missing: + try: + value = cast(T, next(it)) + except StopIteration: + raise TypeError( + "reduce() of empty sequence with no initial value" + ) from None + else: + value = cast(T, initial) + + for element in it: + value = await function(value, element) + function_called = True + else: + raise TypeError("reduce() argument 2 must be an iterable or async iterable") + + # Make sure there is at least one checkpoint, even if an empty iterable and an + # initial value were given + if not function_called: + await checkpoint() + + return value diff --git a/.venv/lib/python3.10/site-packages/anyio/lowlevel.py b/.venv/lib/python3.10/site-packages/anyio/lowlevel.py new file mode 100644 index 0000000..ffbb75a --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/lowlevel.py @@ -0,0 +1,196 @@ +from __future__ import annotations + +__all__ = ( + "EventLoopToken", + "RunvarToken", + "RunVar", + "checkpoint", + "checkpoint_if_cancelled", + "cancel_shielded_checkpoint", + "current_token", +) + +import enum +from dataclasses import dataclass +from types import TracebackType +from typing import Any, Generic, Literal, TypeVar, final, overload +from weakref import WeakKeyDictionary + +from ._core._eventloop import get_async_backend +from .abc import AsyncBackend + +T = TypeVar("T") +D = TypeVar("D") + + +async def checkpoint() -> None: + """ + Check for cancellation and allow the scheduler to switch to another task. + + Equivalent to (but more efficient than):: + + await checkpoint_if_cancelled() + await cancel_shielded_checkpoint() + + .. versionadded:: 3.0 + + """ + await get_async_backend().checkpoint() + + +async def checkpoint_if_cancelled() -> None: + """ + Enter a checkpoint if the enclosing cancel scope has been cancelled. + + This does not allow the scheduler to switch to a different task. + + .. versionadded:: 3.0 + + """ + await get_async_backend().checkpoint_if_cancelled() + + +async def cancel_shielded_checkpoint() -> None: + """ + Allow the scheduler to switch to another task but without checking for cancellation. + + Equivalent to (but potentially more efficient than):: + + with CancelScope(shield=True): + await checkpoint() + + .. versionadded:: 3.0 + + """ + await get_async_backend().cancel_shielded_checkpoint() + + +@final +@dataclass(frozen=True, repr=False) +class EventLoopToken: + """ + An opaque object that holds a reference to an event loop. + + .. versionadded:: 4.11.0 + """ + + backend_class: type[AsyncBackend] + native_token: object + + +def current_token() -> EventLoopToken: + """ + Return a token object that can be used to call code in the current event loop from + another thread. + + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + .. versionadded:: 4.11.0 + + """ + backend_class = get_async_backend() + raw_token = backend_class.current_token() + return EventLoopToken(backend_class, raw_token) + + +_run_vars: WeakKeyDictionary[object, dict[RunVar[Any], Any]] = WeakKeyDictionary() + + +class _NoValueSet(enum.Enum): + NO_VALUE_SET = enum.auto() + + +class RunvarToken(Generic[T]): + __slots__ = "_var", "_value", "_redeemed" + + def __init__(self, var: RunVar[T], value: T | Literal[_NoValueSet.NO_VALUE_SET]): + self._var = var + self._value: T | Literal[_NoValueSet.NO_VALUE_SET] = value + self._redeemed = False + + def __enter__(self) -> RunvarToken[T]: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self._var.reset(self) + + +class RunVar(Generic[T]): + """ + Like a :class:`~contextvars.ContextVar`, except scoped to the running event loop. + + Can be used as a context manager, Just like :class:`~contextvars.ContextVar`, that + will reset the variable to its previous value when the context block is exited. + """ + + __slots__ = "_name", "_default" + + NO_VALUE_SET: Literal[_NoValueSet.NO_VALUE_SET] = _NoValueSet.NO_VALUE_SET + + def __init__( + self, name: str, default: T | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET + ): + self._name = name + self._default = default + + @property + def _current_vars(self) -> dict[RunVar[T], T]: + native_token = current_token().native_token + try: + return _run_vars[native_token] + except KeyError: + run_vars = _run_vars[native_token] = {} + return run_vars + + @overload + def get(self, default: D) -> T | D: ... + + @overload + def get(self) -> T: ... + + def get( + self, default: D | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET + ) -> T | D: + try: + return self._current_vars[self] + except KeyError: + if default is not RunVar.NO_VALUE_SET: + return default + elif self._default is not RunVar.NO_VALUE_SET: + return self._default + + raise LookupError( + f'Run variable "{self._name}" has no value and no default set' + ) + + def set(self, value: T) -> RunvarToken[T]: + current_vars = self._current_vars + token = RunvarToken(self, current_vars.get(self, RunVar.NO_VALUE_SET)) + current_vars[self] = value + return token + + def reset(self, token: RunvarToken[T]) -> None: + if token._var is not self: + raise ValueError("This token does not belong to this RunVar") + + if token._redeemed: + raise ValueError("This token has already been used") + + if token._value is _NoValueSet.NO_VALUE_SET: + try: + del self._current_vars[self] + except KeyError: + pass + else: + self._current_vars[self] = token._value + + token._redeemed = True + + def __repr__(self) -> str: + return f"" diff --git a/.venv/lib/python3.10/site-packages/anyio/py.typed b/.venv/lib/python3.10/site-packages/anyio/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/anyio/pytest_plugin.py b/.venv/lib/python3.10/site-packages/anyio/pytest_plugin.py new file mode 100644 index 0000000..a5183f0 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/pytest_plugin.py @@ -0,0 +1,363 @@ +from __future__ import annotations + +import dataclasses +import socket +import sys +from collections.abc import Callable, Generator, Iterator +from contextlib import ExitStack, contextmanager +from inspect import isasyncgenfunction, iscoroutinefunction, ismethod +from typing import Any, cast + +import pytest +from _pytest.fixtures import FuncFixtureInfo, SubRequest +from _pytest.outcomes import Exit +from _pytest.python import CallSpec2 +from _pytest.scope import Scope + +from . import get_available_backends +from ._core._eventloop import ( + current_async_library, + get_async_backend, + reset_current_async_library, + set_current_async_library, +) +from ._core._exceptions import iterate_exceptions +from .abc import TestRunner + +if sys.version_info < (3, 11): + from exceptiongroup import ExceptionGroup + +_current_runner: TestRunner | None = None +_runner_stack: ExitStack | None = None +_runner_leases = 0 + + +def extract_backend_and_options(backend: object) -> tuple[str, dict[str, Any]]: + if isinstance(backend, str): + return backend, {} + elif isinstance(backend, tuple) and len(backend) == 2: + if isinstance(backend[0], str) and isinstance(backend[1], dict): + return cast(tuple[str, dict[str, Any]], backend) + + raise TypeError("anyio_backend must be either a string or tuple of (string, dict)") + + +@contextmanager +def get_runner( + backend_name: str, backend_options: dict[str, Any] +) -> Iterator[TestRunner]: + global _current_runner, _runner_leases, _runner_stack + if _current_runner is None: + asynclib = get_async_backend(backend_name) + _runner_stack = ExitStack() + if current_async_library() is None: + # Since we're in control of the event loop, we can cache the name of the + # async library + token = set_current_async_library(backend_name) + _runner_stack.callback(reset_current_async_library, token) + + backend_options = backend_options or {} + _current_runner = _runner_stack.enter_context( + asynclib.create_test_runner(backend_options) + ) + + _runner_leases += 1 + try: + yield _current_runner + finally: + _runner_leases -= 1 + if not _runner_leases: + assert _runner_stack is not None + _runner_stack.close() + _runner_stack = _current_runner = None + + +def pytest_addoption(parser: pytest.Parser) -> None: + parser.addini( + "anyio_mode", + default="strict", + help='AnyIO plugin mode (either "strict" or "auto")', + ) + + +def pytest_configure(config: pytest.Config) -> None: + config.addinivalue_line( + "markers", + "anyio: mark the (coroutine function) test to be run asynchronously via anyio.", + ) + if ( + config.getini("anyio_mode") == "auto" + and config.pluginmanager.has_plugin("asyncio") + and config.getini("asyncio_mode") == "auto" + ): + config.issue_config_time_warning( + pytest.PytestConfigWarning( + "AnyIO auto mode has been enabled together with pytest-asyncio auto " + "mode. This may cause unexpected behavior." + ), + 1, + ) + + +@pytest.hookimpl(hookwrapper=True) +def pytest_fixture_setup(fixturedef: Any, request: Any) -> Generator[Any]: + def wrapper(anyio_backend: Any, request: SubRequest, **kwargs: Any) -> Any: + # Rebind any fixture methods to the request instance + if ( + request.instance + and ismethod(func) + and type(func.__self__) is type(request.instance) + ): + local_func = func.__func__.__get__(request.instance) + else: + local_func = func + + backend_name, backend_options = extract_backend_and_options(anyio_backend) + if has_backend_arg: + kwargs["anyio_backend"] = anyio_backend + + if has_request_arg: + kwargs["request"] = request + + with get_runner(backend_name, backend_options) as runner: + if isasyncgenfunction(local_func): + yield from runner.run_asyncgen_fixture(local_func, kwargs) + else: + yield runner.run_fixture(local_func, kwargs) + + # Only apply this to coroutine functions and async generator functions in requests + # that involve the anyio_backend fixture + func = fixturedef.func + if isasyncgenfunction(func) or iscoroutinefunction(func): + if "anyio_backend" in request.fixturenames: + fixturedef.func = wrapper + original_argname = fixturedef.argnames + + if not (has_backend_arg := "anyio_backend" in fixturedef.argnames): + fixturedef.argnames += ("anyio_backend",) + + if not (has_request_arg := "request" in fixturedef.argnames): + fixturedef.argnames += ("request",) + + try: + return (yield) + finally: + fixturedef.func = func + fixturedef.argnames = original_argname + + return (yield) + + +@pytest.hookimpl(tryfirst=True) +def pytest_pycollect_makeitem( + collector: pytest.Module | pytest.Class, name: str, obj: object +) -> None: + if collector.istestfunction(obj, name): + inner_func = obj.hypothesis.inner_test if hasattr(obj, "hypothesis") else obj + if iscoroutinefunction(inner_func): + anyio_auto_mode = collector.config.getini("anyio_mode") == "auto" + marker = collector.get_closest_marker("anyio") + own_markers = getattr(obj, "pytestmark", ()) + if ( + anyio_auto_mode + or marker + or any(marker.name == "anyio" for marker in own_markers) + ): + pytest.mark.usefixtures("anyio_backend")(obj) + + +def pytest_collection_finish(session: pytest.Session) -> None: + for i, item in reversed(list(enumerate(session.items))): + if ( + isinstance(item, pytest.Function) + and iscoroutinefunction(item.function) + and item.get_closest_marker("anyio") is not None + and "anyio_backend" not in item.fixturenames + ): + new_items = [] + try: + cs_fields = {f.name for f in dataclasses.fields(CallSpec2)} + except TypeError: + cs_fields = set() + + for param_index, backend in enumerate(get_available_backends()): + if "_arg2scope" in cs_fields: # pytest >= 8 + callspec = CallSpec2( + params={"anyio_backend": backend}, + indices={"anyio_backend": param_index}, + _arg2scope={"anyio_backend": Scope.Module}, + _idlist=[backend], + marks=[], + ) + else: # pytest 7.x + callspec = CallSpec2( # type: ignore[call-arg] + funcargs={}, + params={"anyio_backend": backend}, + indices={"anyio_backend": param_index}, + arg2scope={"anyio_backend": Scope.Module}, + idlist=[backend], + marks=[], + ) + + fi = item._fixtureinfo + new_names_closure = list(fi.names_closure) + if "anyio_backend" not in new_names_closure: + new_names_closure.append("anyio_backend") + + new_fixtureinfo = FuncFixtureInfo( + argnames=fi.argnames, + initialnames=fi.initialnames, + names_closure=new_names_closure, + name2fixturedefs=fi.name2fixturedefs, + ) + new_item = pytest.Function.from_parent( + item.parent, + name=f"{item.originalname}[{backend}]", + callspec=callspec, + callobj=item.obj, + fixtureinfo=new_fixtureinfo, + keywords=item.keywords, + originalname=item.originalname, + ) + new_items.append(new_item) + + session.items[i : i + 1] = new_items + + +@pytest.hookimpl(tryfirst=True) +def pytest_pyfunc_call(pyfuncitem: Any) -> bool | None: + def run_with_hypothesis(**kwargs: Any) -> None: + with get_runner(backend_name, backend_options) as runner: + runner.run_test(original_func, kwargs) + + backend = pyfuncitem.funcargs.get("anyio_backend") + if backend: + backend_name, backend_options = extract_backend_and_options(backend) + + if hasattr(pyfuncitem.obj, "hypothesis"): + # Wrap the inner test function unless it's already wrapped + original_func = pyfuncitem.obj.hypothesis.inner_test + if original_func.__qualname__ != run_with_hypothesis.__qualname__: + if iscoroutinefunction(original_func): + pyfuncitem.obj.hypothesis.inner_test = run_with_hypothesis + + return None + + if iscoroutinefunction(pyfuncitem.obj): + funcargs = pyfuncitem.funcargs + testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames} + with get_runner(backend_name, backend_options) as runner: + try: + runner.run_test(pyfuncitem.obj, testargs) + except ExceptionGroup as excgrp: + for exc in iterate_exceptions(excgrp): + if isinstance(exc, (Exit, KeyboardInterrupt, SystemExit)): + raise exc from excgrp + + raise + + return True + + return None + + +@pytest.fixture(scope="module", params=get_available_backends()) +def anyio_backend(request: Any) -> Any: + return request.param + + +@pytest.fixture +def anyio_backend_name(anyio_backend: Any) -> str: + if isinstance(anyio_backend, str): + return anyio_backend + else: + return anyio_backend[0] + + +@pytest.fixture +def anyio_backend_options(anyio_backend: Any) -> dict[str, Any]: + if isinstance(anyio_backend, str): + return {} + else: + return anyio_backend[1] + + +class FreePortFactory: + """ + Manages port generation based on specified socket kind, ensuring no duplicate + ports are generated. + + This class provides functionality for generating available free ports on the + system. It is initialized with a specific socket kind and can generate ports + for given address families while avoiding reuse of previously generated ports. + + Users should not instantiate this class directly, but use the + ``free_tcp_port_factory`` and ``free_udp_port_factory`` fixtures instead. For simple + uses cases, ``free_tcp_port`` and ``free_udp_port`` can be used instead. + """ + + def __init__(self, kind: socket.SocketKind) -> None: + self._kind = kind + self._generated = set[int]() + + @property + def kind(self) -> socket.SocketKind: + """ + The type of socket connection (e.g., :data:`~socket.SOCK_STREAM` or + :data:`~socket.SOCK_DGRAM`) used to bind for checking port availability + + """ + return self._kind + + def __call__(self, family: socket.AddressFamily | None = None) -> int: + """ + Return an unbound port for the given address family. + + :param family: if omitted, both IPv4 and IPv6 addresses will be tried + :return: a port number + + """ + if family is not None: + families = [family] + else: + families = [socket.AF_INET] + if socket.has_ipv6: + families.append(socket.AF_INET6) + + while True: + port = 0 + with ExitStack() as stack: + for family in families: + sock = stack.enter_context(socket.socket(family, self._kind)) + addr = "::1" if family == socket.AF_INET6 else "127.0.0.1" + try: + sock.bind((addr, port)) + except OSError: + break + + if not port: + port = sock.getsockname()[1] + else: + if port not in self._generated: + self._generated.add(port) + return port + + +@pytest.fixture(scope="session") +def free_tcp_port_factory() -> FreePortFactory: + return FreePortFactory(socket.SOCK_STREAM) + + +@pytest.fixture(scope="session") +def free_udp_port_factory() -> FreePortFactory: + return FreePortFactory(socket.SOCK_DGRAM) + + +@pytest.fixture +def free_tcp_port(free_tcp_port_factory: Callable[[], int]) -> int: + return free_tcp_port_factory() + + +@pytest.fixture +def free_udp_port(free_udp_port_factory: Callable[[], int]) -> int: + return free_udp_port_factory() diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__init__.py b/.venv/lib/python3.10/site-packages/anyio/streams/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..0774356 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/buffered.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/buffered.cpython-310.pyc new file mode 100644 index 0000000..0d330d5 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/buffered.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/file.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/file.cpython-310.pyc new file mode 100644 index 0000000..f6bbfd8 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/file.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/memory.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/memory.cpython-310.pyc new file mode 100644 index 0000000..a24a292 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/memory.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/stapled.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/stapled.cpython-310.pyc new file mode 100644 index 0000000..7550cc8 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/stapled.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/text.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/text.cpython-310.pyc new file mode 100644 index 0000000..94870cd Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/text.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/tls.cpython-310.pyc b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/tls.cpython-310.pyc new file mode 100644 index 0000000..1483329 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/anyio/streams/__pycache__/tls.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/buffered.py b/.venv/lib/python3.10/site-packages/anyio/streams/buffered.py new file mode 100644 index 0000000..57c7cd7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/buffered.py @@ -0,0 +1,188 @@ +from __future__ import annotations + +__all__ = ( + "BufferedByteReceiveStream", + "BufferedByteStream", + "BufferedConnectable", +) + +import sys +from collections.abc import Callable, Iterable, Mapping +from dataclasses import dataclass, field +from typing import Any, SupportsIndex + +from .. import ClosedResourceError, DelimiterNotFound, EndOfStream, IncompleteRead +from ..abc import ( + AnyByteReceiveStream, + AnyByteStream, + AnyByteStreamConnectable, + ByteReceiveStream, + ByteStream, + ByteStreamConnectable, +) + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + + +@dataclass(eq=False) +class BufferedByteReceiveStream(ByteReceiveStream): + """ + Wraps any bytes-based receive stream and uses a buffer to provide sophisticated + receiving capabilities in the form of a byte stream. + """ + + receive_stream: AnyByteReceiveStream + _buffer: bytearray = field(init=False, default_factory=bytearray) + _closed: bool = field(init=False, default=False) + + async def aclose(self) -> None: + await self.receive_stream.aclose() + self._closed = True + + @property + def buffer(self) -> bytes: + """The bytes currently in the buffer.""" + return bytes(self._buffer) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.receive_stream.extra_attributes + + def feed_data(self, data: Iterable[SupportsIndex], /) -> None: + """ + Append data directly into the buffer. + + Any data in the buffer will be consumed by receive operations before receiving + anything from the wrapped stream. + + :param data: the data to append to the buffer (can be bytes or anything else + that supports ``__index__()``) + + """ + self._buffer.extend(data) + + async def receive(self, max_bytes: int = 65536) -> bytes: + if self._closed: + raise ClosedResourceError + + if self._buffer: + chunk = bytes(self._buffer[:max_bytes]) + del self._buffer[:max_bytes] + return chunk + elif isinstance(self.receive_stream, ByteReceiveStream): + return await self.receive_stream.receive(max_bytes) + else: + # With a bytes-oriented object stream, we need to handle any surplus bytes + # we get from the receive() call + chunk = await self.receive_stream.receive() + if len(chunk) > max_bytes: + # Save the surplus bytes in the buffer + self._buffer.extend(chunk[max_bytes:]) + return chunk[:max_bytes] + else: + return chunk + + async def receive_exactly(self, nbytes: int) -> bytes: + """ + Read exactly the given amount of bytes from the stream. + + :param nbytes: the number of bytes to read + :return: the bytes read + :raises ~anyio.IncompleteRead: if the stream was closed before the requested + amount of bytes could be read from the stream + + """ + while True: + remaining = nbytes - len(self._buffer) + if remaining <= 0: + retval = self._buffer[:nbytes] + del self._buffer[:nbytes] + return bytes(retval) + + try: + if isinstance(self.receive_stream, ByteReceiveStream): + chunk = await self.receive_stream.receive(remaining) + else: + chunk = await self.receive_stream.receive() + except EndOfStream as exc: + raise IncompleteRead from exc + + self._buffer.extend(chunk) + + async def receive_until(self, delimiter: bytes, max_bytes: int) -> bytes: + """ + Read from the stream until the delimiter is found or max_bytes have been read. + + :param delimiter: the marker to look for in the stream + :param max_bytes: maximum number of bytes that will be read before raising + :exc:`~anyio.DelimiterNotFound` + :return: the bytes read (not including the delimiter) + :raises ~anyio.IncompleteRead: if the stream was closed before the delimiter + was found + :raises ~anyio.DelimiterNotFound: if the delimiter is not found within the + bytes read up to the maximum allowed + + """ + delimiter_size = len(delimiter) + offset = 0 + while True: + # Check if the delimiter can be found in the current buffer + index = self._buffer.find(delimiter, offset) + if index >= 0: + found = self._buffer[:index] + del self._buffer[: index + len(delimiter) :] + return bytes(found) + + # Check if the buffer is already at or over the limit + if len(self._buffer) >= max_bytes: + raise DelimiterNotFound(max_bytes) + + # Read more data into the buffer from the socket + try: + data = await self.receive_stream.receive() + except EndOfStream as exc: + raise IncompleteRead from exc + + # Move the offset forward and add the new data to the buffer + offset = max(len(self._buffer) - delimiter_size + 1, 0) + self._buffer.extend(data) + + +class BufferedByteStream(BufferedByteReceiveStream, ByteStream): + """ + A full-duplex variant of :class:`BufferedByteReceiveStream`. All writes are passed + through to the wrapped stream as-is. + """ + + def __init__(self, stream: AnyByteStream): + """ + :param stream: the stream to be wrapped + + """ + super().__init__(stream) + self._stream = stream + + @override + async def send_eof(self) -> None: + await self._stream.send_eof() + + @override + async def send(self, item: bytes) -> None: + await self._stream.send(item) + + +class BufferedConnectable(ByteStreamConnectable): + def __init__(self, connectable: AnyByteStreamConnectable): + """ + :param connectable: the connectable to wrap + + """ + self.connectable = connectable + + @override + async def connect(self) -> BufferedByteStream: + stream = await self.connectable.connect() + return BufferedByteStream(stream) diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/file.py b/.venv/lib/python3.10/site-packages/anyio/streams/file.py new file mode 100644 index 0000000..79c3d50 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/file.py @@ -0,0 +1,154 @@ +from __future__ import annotations + +__all__ = ( + "FileReadStream", + "FileStreamAttribute", + "FileWriteStream", +) + +from collections.abc import Callable, Mapping +from io import SEEK_SET, UnsupportedOperation +from os import PathLike +from pathlib import Path +from typing import IO, Any + +from .. import ( + BrokenResourceError, + ClosedResourceError, + EndOfStream, + TypedAttributeSet, + to_thread, + typed_attribute, +) +from ..abc import ByteReceiveStream, ByteSendStream + + +class FileStreamAttribute(TypedAttributeSet): + #: the open file descriptor + file: IO[bytes] = typed_attribute() + #: the path of the file on the file system, if available (file must be a real file) + path: Path = typed_attribute() + #: the file number, if available (file must be a real file or a TTY) + fileno: int = typed_attribute() + + +class _BaseFileStream: + def __init__(self, file: IO[bytes]): + self._file = file + + async def aclose(self) -> None: + await to_thread.run_sync(self._file.close) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + attributes: dict[Any, Callable[[], Any]] = { + FileStreamAttribute.file: lambda: self._file, + } + + if hasattr(self._file, "name"): + attributes[FileStreamAttribute.path] = lambda: Path(self._file.name) + + try: + self._file.fileno() + except UnsupportedOperation: + pass + else: + attributes[FileStreamAttribute.fileno] = lambda: self._file.fileno() + + return attributes + + +class FileReadStream(_BaseFileStream, ByteReceiveStream): + """ + A byte stream that reads from a file in the file system. + + :param file: a file that has been opened for reading in binary mode + + .. versionadded:: 3.0 + """ + + @classmethod + async def from_path(cls, path: str | PathLike[str]) -> FileReadStream: + """ + Create a file read stream by opening the given file. + + :param path: path of the file to read from + + """ + file = await to_thread.run_sync(Path(path).open, "rb") + return cls(file) + + async def receive(self, max_bytes: int = 65536) -> bytes: + try: + data = await to_thread.run_sync(self._file.read, max_bytes) + except ValueError: + raise ClosedResourceError from None + except OSError as exc: + raise BrokenResourceError from exc + + if data: + return data + else: + raise EndOfStream + + async def seek(self, position: int, whence: int = SEEK_SET) -> int: + """ + Seek the file to the given position. + + .. seealso:: :meth:`io.IOBase.seek` + + .. note:: Not all file descriptors are seekable. + + :param position: position to seek the file to + :param whence: controls how ``position`` is interpreted + :return: the new absolute position + :raises OSError: if the file is not seekable + + """ + return await to_thread.run_sync(self._file.seek, position, whence) + + async def tell(self) -> int: + """ + Return the current stream position. + + .. note:: Not all file descriptors are seekable. + + :return: the current absolute position + :raises OSError: if the file is not seekable + + """ + return await to_thread.run_sync(self._file.tell) + + +class FileWriteStream(_BaseFileStream, ByteSendStream): + """ + A byte stream that writes to a file in the file system. + + :param file: a file that has been opened for writing in binary mode + + .. versionadded:: 3.0 + """ + + @classmethod + async def from_path( + cls, path: str | PathLike[str], append: bool = False + ) -> FileWriteStream: + """ + Create a file write stream by opening the given file for writing. + + :param path: path of the file to write to + :param append: if ``True``, open the file for appending; if ``False``, any + existing file at the given path will be truncated + + """ + mode = "ab" if append else "wb" + file = await to_thread.run_sync(Path(path).open, mode) + return cls(file) + + async def send(self, item: bytes) -> None: + try: + await to_thread.run_sync(self._file.write, item) + except ValueError: + raise ClosedResourceError from None + except OSError as exc: + raise BrokenResourceError from exc diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/memory.py b/.venv/lib/python3.10/site-packages/anyio/streams/memory.py new file mode 100644 index 0000000..a3fa0c3 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/memory.py @@ -0,0 +1,325 @@ +from __future__ import annotations + +__all__ = ( + "MemoryObjectReceiveStream", + "MemoryObjectSendStream", + "MemoryObjectStreamStatistics", +) + +import warnings +from collections import OrderedDict, deque +from dataclasses import dataclass, field +from types import TracebackType +from typing import Generic, NamedTuple, TypeVar + +from .. import ( + BrokenResourceError, + ClosedResourceError, + EndOfStream, + WouldBlock, +) +from .._core._testing import TaskInfo, get_current_task +from ..abc import Event, ObjectReceiveStream, ObjectSendStream +from ..lowlevel import checkpoint + +T_Item = TypeVar("T_Item") +T_co = TypeVar("T_co", covariant=True) +T_contra = TypeVar("T_contra", contravariant=True) + + +class MemoryObjectStreamStatistics(NamedTuple): + current_buffer_used: int #: number of items stored in the buffer + #: maximum number of items that can be stored on this stream (or :data:`math.inf`) + max_buffer_size: float + open_send_streams: int #: number of unclosed clones of the send stream + open_receive_streams: int #: number of unclosed clones of the receive stream + #: number of tasks blocked on :meth:`MemoryObjectSendStream.send` + tasks_waiting_send: int + #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive` + tasks_waiting_receive: int + + +@dataclass(eq=False) +class _MemoryObjectItemReceiver(Generic[T_Item]): + task_info: TaskInfo = field(init=False, default_factory=get_current_task) + item: T_Item = field(init=False) + + def __repr__(self) -> str: + # When item is not defined, we get following error with default __repr__: + # AttributeError: 'MemoryObjectItemReceiver' object has no attribute 'item' + item = getattr(self, "item", None) + return f"{self.__class__.__name__}(task_info={self.task_info}, item={item!r})" + + +@dataclass(eq=False) +class _MemoryObjectStreamState(Generic[T_Item]): + max_buffer_size: float = field() + buffer: deque[T_Item] = field(init=False, default_factory=deque) + open_send_channels: int = field(init=False, default=0) + open_receive_channels: int = field(init=False, default=0) + waiting_receivers: OrderedDict[Event, _MemoryObjectItemReceiver[T_Item]] = field( + init=False, default_factory=OrderedDict + ) + waiting_senders: OrderedDict[Event, T_Item] = field( + init=False, default_factory=OrderedDict + ) + + def statistics(self) -> MemoryObjectStreamStatistics: + return MemoryObjectStreamStatistics( + len(self.buffer), + self.max_buffer_size, + self.open_send_channels, + self.open_receive_channels, + len(self.waiting_senders), + len(self.waiting_receivers), + ) + + +@dataclass(eq=False) +class MemoryObjectReceiveStream(Generic[T_co], ObjectReceiveStream[T_co]): + _state: _MemoryObjectStreamState[T_co] + _closed: bool = field(init=False, default=False) + + def __post_init__(self) -> None: + self._state.open_receive_channels += 1 + + def receive_nowait(self) -> T_co: + """ + Receive the next item if it can be done without waiting. + + :return: the received item + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.EndOfStream: if the buffer is empty and this stream has been + closed from the sending end + :raises ~anyio.WouldBlock: if there are no items in the buffer and no tasks + waiting to send + + """ + if self._closed: + raise ClosedResourceError + + if self._state.waiting_senders: + # Get the item from the next sender + send_event, item = self._state.waiting_senders.popitem(last=False) + self._state.buffer.append(item) + send_event.set() + + if self._state.buffer: + return self._state.buffer.popleft() + elif not self._state.open_send_channels: + raise EndOfStream + + raise WouldBlock + + async def receive(self) -> T_co: + await checkpoint() + try: + return self.receive_nowait() + except WouldBlock: + # Add ourselves in the queue + receive_event = Event() + receiver = _MemoryObjectItemReceiver[T_co]() + self._state.waiting_receivers[receive_event] = receiver + + try: + await receive_event.wait() + finally: + self._state.waiting_receivers.pop(receive_event, None) + + try: + return receiver.item + except AttributeError: + raise EndOfStream from None + + def clone(self) -> MemoryObjectReceiveStream[T_co]: + """ + Create a clone of this receive stream. + + Each clone can be closed separately. Only when all clones have been closed will + the receiving end of the memory stream be considered closed by the sending ends. + + :return: the cloned stream + + """ + if self._closed: + raise ClosedResourceError + + return MemoryObjectReceiveStream(_state=self._state) + + def close(self) -> None: + """ + Close the stream. + + This works the exact same way as :meth:`aclose`, but is provided as a special + case for the benefit of synchronous callbacks. + + """ + if not self._closed: + self._closed = True + self._state.open_receive_channels -= 1 + if self._state.open_receive_channels == 0: + send_events = list(self._state.waiting_senders.keys()) + for event in send_events: + event.set() + + async def aclose(self) -> None: + self.close() + + def statistics(self) -> MemoryObjectStreamStatistics: + """ + Return statistics about the current state of this stream. + + .. versionadded:: 3.0 + """ + return self._state.statistics() + + def __enter__(self) -> MemoryObjectReceiveStream[T_co]: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def __del__(self) -> None: + if not self._closed: + warnings.warn( + f"Unclosed <{self.__class__.__name__} at {id(self):x}>", + ResourceWarning, + stacklevel=1, + source=self, + ) + + +@dataclass(eq=False) +class MemoryObjectSendStream(Generic[T_contra], ObjectSendStream[T_contra]): + _state: _MemoryObjectStreamState[T_contra] + _closed: bool = field(init=False, default=False) + + def __post_init__(self) -> None: + self._state.open_send_channels += 1 + + def send_nowait(self, item: T_contra) -> None: + """ + Send an item immediately if it can be done without waiting. + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.BrokenResourceError: if the stream has been closed from the + receiving end + :raises ~anyio.WouldBlock: if the buffer is full and there are no tasks waiting + to receive + + """ + if self._closed: + raise ClosedResourceError + if not self._state.open_receive_channels: + raise BrokenResourceError + + while self._state.waiting_receivers: + receive_event, receiver = self._state.waiting_receivers.popitem(last=False) + if not receiver.task_info.has_pending_cancellation(): + receiver.item = item + receive_event.set() + return + + if len(self._state.buffer) < self._state.max_buffer_size: + self._state.buffer.append(item) + else: + raise WouldBlock + + async def send(self, item: T_contra) -> None: + """ + Send an item to the stream. + + If the buffer is full, this method blocks until there is again room in the + buffer or the item can be sent directly to a receiver. + + :param item: the item to send + :raises ~anyio.ClosedResourceError: if this send stream has been closed + :raises ~anyio.BrokenResourceError: if the stream has been closed from the + receiving end + + """ + await checkpoint() + try: + self.send_nowait(item) + except WouldBlock: + # Wait until there's someone on the receiving end + send_event = Event() + self._state.waiting_senders[send_event] = item + try: + await send_event.wait() + except BaseException: + self._state.waiting_senders.pop(send_event, None) + raise + + if send_event in self._state.waiting_senders: + del self._state.waiting_senders[send_event] + raise BrokenResourceError from None + + def clone(self) -> MemoryObjectSendStream[T_contra]: + """ + Create a clone of this send stream. + + Each clone can be closed separately. Only when all clones have been closed will + the sending end of the memory stream be considered closed by the receiving ends. + + :return: the cloned stream + + """ + if self._closed: + raise ClosedResourceError + + return MemoryObjectSendStream(_state=self._state) + + def close(self) -> None: + """ + Close the stream. + + This works the exact same way as :meth:`aclose`, but is provided as a special + case for the benefit of synchronous callbacks. + + """ + if not self._closed: + self._closed = True + self._state.open_send_channels -= 1 + if self._state.open_send_channels == 0: + receive_events = list(self._state.waiting_receivers.keys()) + self._state.waiting_receivers.clear() + for event in receive_events: + event.set() + + async def aclose(self) -> None: + self.close() + + def statistics(self) -> MemoryObjectStreamStatistics: + """ + Return statistics about the current state of this stream. + + .. versionadded:: 3.0 + """ + return self._state.statistics() + + def __enter__(self) -> MemoryObjectSendStream[T_contra]: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + self.close() + + def __del__(self) -> None: + if not self._closed: + warnings.warn( + f"Unclosed <{self.__class__.__name__} at {id(self):x}>", + ResourceWarning, + stacklevel=1, + source=self, + ) diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/stapled.py b/.venv/lib/python3.10/site-packages/anyio/streams/stapled.py new file mode 100644 index 0000000..9248b68 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/stapled.py @@ -0,0 +1,147 @@ +from __future__ import annotations + +__all__ = ( + "MultiListener", + "StapledByteStream", + "StapledObjectStream", +) + +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass +from typing import Any, Generic, TypeVar + +from ..abc import ( + ByteReceiveStream, + ByteSendStream, + ByteStream, + Listener, + ObjectReceiveStream, + ObjectSendStream, + ObjectStream, + TaskGroup, +) + +T_Item = TypeVar("T_Item") +T_Stream = TypeVar("T_Stream") + + +@dataclass(eq=False) +class StapledByteStream(ByteStream): + """ + Combines two byte streams into a single, bidirectional byte stream. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param ByteSendStream send_stream: the sending byte stream + :param ByteReceiveStream receive_stream: the receiving byte stream + """ + + send_stream: ByteSendStream + receive_stream: ByteReceiveStream + + async def receive(self, max_bytes: int = 65536) -> bytes: + return await self.receive_stream.receive(max_bytes) + + async def send(self, item: bytes) -> None: + await self.send_stream.send(item) + + async def send_eof(self) -> None: + await self.send_stream.aclose() + + async def aclose(self) -> None: + await self.send_stream.aclose() + await self.receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.send_stream.extra_attributes, + **self.receive_stream.extra_attributes, + } + + +@dataclass(eq=False) +class StapledObjectStream(Generic[T_Item], ObjectStream[T_Item]): + """ + Combines two object streams into a single, bidirectional object stream. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param ObjectSendStream send_stream: the sending object stream + :param ObjectReceiveStream receive_stream: the receiving object stream + """ + + send_stream: ObjectSendStream[T_Item] + receive_stream: ObjectReceiveStream[T_Item] + + async def receive(self) -> T_Item: + return await self.receive_stream.receive() + + async def send(self, item: T_Item) -> None: + await self.send_stream.send(item) + + async def send_eof(self) -> None: + await self.send_stream.aclose() + + async def aclose(self) -> None: + await self.send_stream.aclose() + await self.receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.send_stream.extra_attributes, + **self.receive_stream.extra_attributes, + } + + +@dataclass(eq=False) +class MultiListener(Generic[T_Stream], Listener[T_Stream]): + """ + Combines multiple listeners into one, serving connections from all of them at once. + + Any MultiListeners in the given collection of listeners will have their listeners + moved into this one. + + Extra attributes are provided from each listener, with each successive listener + overriding any conflicting attributes from the previous one. + + :param listeners: listeners to serve + :type listeners: Sequence[Listener[T_Stream]] + """ + + listeners: Sequence[Listener[T_Stream]] + + def __post_init__(self) -> None: + listeners: list[Listener[T_Stream]] = [] + for listener in self.listeners: + if isinstance(listener, MultiListener): + listeners.extend(listener.listeners) + del listener.listeners[:] # type: ignore[attr-defined] + else: + listeners.append(listener) + + self.listeners = listeners + + async def serve( + self, handler: Callable[[T_Stream], Any], task_group: TaskGroup | None = None + ) -> None: + from .. import create_task_group + + async with create_task_group() as tg: + for listener in self.listeners: + tg.start_soon(listener.serve, handler, task_group) + + async def aclose(self) -> None: + for listener in self.listeners: + await listener.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + attributes: dict = {} + for listener in self.listeners: + attributes.update(listener.extra_attributes) + + return attributes diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/text.py b/.venv/lib/python3.10/site-packages/anyio/streams/text.py new file mode 100644 index 0000000..296cd25 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/text.py @@ -0,0 +1,176 @@ +from __future__ import annotations + +__all__ = ( + "TextConnectable", + "TextReceiveStream", + "TextSendStream", + "TextStream", +) + +import codecs +import sys +from collections.abc import Callable, Mapping +from dataclasses import InitVar, dataclass, field +from typing import Any + +from ..abc import ( + AnyByteReceiveStream, + AnyByteSendStream, + AnyByteStream, + AnyByteStreamConnectable, + ObjectReceiveStream, + ObjectSendStream, + ObjectStream, + ObjectStreamConnectable, +) + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + + +@dataclass(eq=False) +class TextReceiveStream(ObjectReceiveStream[str]): + """ + Stream wrapper that decodes bytes to strings using the given encoding. + + Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any + completely received unicode characters as soon as they come in. + + :param transport_stream: any bytes-based receive stream + :param encoding: character encoding to use for decoding bytes to strings (defaults + to ``utf-8``) + :param errors: handling scheme for decoding errors (defaults to ``strict``; see the + `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteReceiveStream + encoding: InitVar[str] = "utf-8" + errors: InitVar[str] = "strict" + _decoder: codecs.IncrementalDecoder = field(init=False) + + def __post_init__(self, encoding: str, errors: str) -> None: + decoder_class = codecs.getincrementaldecoder(encoding) + self._decoder = decoder_class(errors=errors) + + async def receive(self) -> str: + while True: + chunk = await self.transport_stream.receive() + decoded = self._decoder.decode(chunk) + if decoded: + return decoded + + async def aclose(self) -> None: + await self.transport_stream.aclose() + self._decoder.reset() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.transport_stream.extra_attributes + + +@dataclass(eq=False) +class TextSendStream(ObjectSendStream[str]): + """ + Sends strings to the wrapped stream as bytes using the given encoding. + + :param AnyByteSendStream transport_stream: any bytes-based send stream + :param str encoding: character encoding to use for encoding strings to bytes + (defaults to ``utf-8``) + :param str errors: handling scheme for encoding errors (defaults to ``strict``; see + the `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteSendStream + encoding: InitVar[str] = "utf-8" + errors: str = "strict" + _encoder: Callable[..., tuple[bytes, int]] = field(init=False) + + def __post_init__(self, encoding: str) -> None: + self._encoder = codecs.getencoder(encoding) + + async def send(self, item: str) -> None: + encoded = self._encoder(item, self.errors)[0] + await self.transport_stream.send(encoded) + + async def aclose(self) -> None: + await self.transport_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return self.transport_stream.extra_attributes + + +@dataclass(eq=False) +class TextStream(ObjectStream[str]): + """ + A bidirectional stream that decodes bytes to strings on receive and encodes strings + to bytes on send. + + Extra attributes will be provided from both streams, with the receive stream + providing the values in case of a conflict. + + :param AnyByteStream transport_stream: any bytes-based stream + :param str encoding: character encoding to use for encoding/decoding strings to/from + bytes (defaults to ``utf-8``) + :param str errors: handling scheme for encoding errors (defaults to ``strict``; see + the `codecs module documentation`_ for a comprehensive list of options) + + .. _codecs module documentation: + https://docs.python.org/3/library/codecs.html#codec-objects + """ + + transport_stream: AnyByteStream + encoding: InitVar[str] = "utf-8" + errors: InitVar[str] = "strict" + _receive_stream: TextReceiveStream = field(init=False) + _send_stream: TextSendStream = field(init=False) + + def __post_init__(self, encoding: str, errors: str) -> None: + self._receive_stream = TextReceiveStream( + self.transport_stream, encoding=encoding, errors=errors + ) + self._send_stream = TextSendStream( + self.transport_stream, encoding=encoding, errors=errors + ) + + async def receive(self) -> str: + return await self._receive_stream.receive() + + async def send(self, item: str) -> None: + await self._send_stream.send(item) + + async def send_eof(self) -> None: + await self.transport_stream.send_eof() + + async def aclose(self) -> None: + await self._send_stream.aclose() + await self._receive_stream.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self._send_stream.extra_attributes, + **self._receive_stream.extra_attributes, + } + + +class TextConnectable(ObjectStreamConnectable[str]): + def __init__(self, connectable: AnyByteStreamConnectable): + """ + :param connectable: the bytestream endpoint to wrap + + """ + self.connectable = connectable + + @override + async def connect(self) -> TextStream: + stream = await self.connectable.connect() + return TextStream(stream) diff --git a/.venv/lib/python3.10/site-packages/anyio/streams/tls.py b/.venv/lib/python3.10/site-packages/anyio/streams/tls.py new file mode 100644 index 0000000..e2a7ca5 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/streams/tls.py @@ -0,0 +1,421 @@ +from __future__ import annotations + +__all__ = ( + "TLSAttribute", + "TLSConnectable", + "TLSListener", + "TLSStream", +) + +import logging +import re +import ssl +import sys +from collections.abc import Callable, Mapping +from dataclasses import dataclass +from functools import wraps +from ssl import SSLContext +from typing import Any, TypeAlias, TypeVar + +from .. import ( + BrokenResourceError, + EndOfStream, + aclose_forcefully, + get_cancelled_exc_class, + to_thread, +) +from .._core._typedattr import TypedAttributeSet, typed_attribute +from ..abc import ( + AnyByteStream, + AnyByteStreamConnectable, + ByteStream, + ByteStreamConnectable, + Listener, + TaskGroup, +) + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if sys.version_info >= (3, 12): + from typing import override +else: + from typing_extensions import override + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") +_PCTRTT: TypeAlias = tuple[tuple[str, str], ...] +_PCTRTTT: TypeAlias = tuple[_PCTRTT, ...] + + +class TLSAttribute(TypedAttributeSet): + """Contains Transport Layer Security related attributes.""" + + #: the selected ALPN protocol + alpn_protocol: str | None = typed_attribute() + #: the channel binding for type ``tls-unique`` + channel_binding_tls_unique: bytes = typed_attribute() + #: the selected cipher + cipher: tuple[str, str, int] = typed_attribute() + #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert` + # for more information) + peer_certificate: None | (dict[str, str | _PCTRTTT | _PCTRTT]) = typed_attribute() + #: the peer certificate in binary form + peer_certificate_binary: bytes | None = typed_attribute() + #: ``True`` if this is the server side of the connection + server_side: bool = typed_attribute() + #: ciphers shared by the client during the TLS handshake (``None`` if this is the + #: client side) + shared_ciphers: list[tuple[str, str, int]] | None = typed_attribute() + #: the :class:`~ssl.SSLObject` used for encryption + ssl_object: ssl.SSLObject = typed_attribute() + #: ``True`` if this stream does (and expects) a closing TLS handshake when the + #: stream is being closed + standard_compatible: bool = typed_attribute() + #: the TLS protocol version (e.g. ``TLSv1.2``) + tls_version: str = typed_attribute() + + +@dataclass(eq=False) +class TLSStream(ByteStream): + """ + A stream wrapper that encrypts all sent data and decrypts received data. + + This class has no public initializer; use :meth:`wrap` instead. + All extra attributes from :class:`~TLSAttribute` are supported. + + :var AnyByteStream transport_stream: the wrapped stream + + """ + + transport_stream: AnyByteStream + standard_compatible: bool + _ssl_object: ssl.SSLObject + _read_bio: ssl.MemoryBIO + _write_bio: ssl.MemoryBIO + + @classmethod + async def wrap( + cls, + transport_stream: AnyByteStream, + *, + server_side: bool | None = None, + hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + standard_compatible: bool = True, + ) -> TLSStream: + """ + Wrap an existing stream with Transport Layer Security. + + This performs a TLS handshake with the peer. + + :param transport_stream: a bytes-transporting stream to wrap + :param server_side: ``True`` if this is the server side of the connection, + ``False`` if this is the client side (if omitted, will be set to ``False`` + if ``hostname`` has been provided, ``False`` otherwise). Used only to create + a default context when an explicit context has not been provided. + :param hostname: host name of the peer (if host name checking is desired) + :param ssl_context: the SSLContext object to use (if not provided, a secure + default will be created) + :param standard_compatible: if ``False``, skip the closing handshake when + closing the connection, and don't raise an exception if the peer does the + same + :raises ~ssl.SSLError: if the TLS handshake fails + + """ + if server_side is None: + server_side = not hostname + + if not ssl_context: + purpose = ( + ssl.Purpose.CLIENT_AUTH if server_side else ssl.Purpose.SERVER_AUTH + ) + ssl_context = ssl.create_default_context(purpose) + + # Re-enable detection of unexpected EOFs if it was disabled by Python + if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"): + ssl_context.options &= ~ssl.OP_IGNORE_UNEXPECTED_EOF + + bio_in = ssl.MemoryBIO() + bio_out = ssl.MemoryBIO() + + # External SSLContext implementations may do blocking I/O in wrap_bio(), + # but the standard library implementation won't + if type(ssl_context) is ssl.SSLContext: + ssl_object = ssl_context.wrap_bio( + bio_in, bio_out, server_side=server_side, server_hostname=hostname + ) + else: + ssl_object = await to_thread.run_sync( + ssl_context.wrap_bio, + bio_in, + bio_out, + server_side, + hostname, + None, + ) + + wrapper = cls( + transport_stream=transport_stream, + standard_compatible=standard_compatible, + _ssl_object=ssl_object, + _read_bio=bio_in, + _write_bio=bio_out, + ) + await wrapper._call_sslobject_method(ssl_object.do_handshake) + return wrapper + + async def _call_sslobject_method( + self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT] + ) -> T_Retval: + while True: + try: + result = func(*args) + except ssl.SSLWantReadError: + try: + # Flush any pending writes first + if self._write_bio.pending: + await self.transport_stream.send(self._write_bio.read()) + + data = await self.transport_stream.receive() + except EndOfStream: + self._read_bio.write_eof() + except OSError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + raise BrokenResourceError from exc + else: + self._read_bio.write(data) + except ssl.SSLWantWriteError: + await self.transport_stream.send(self._write_bio.read()) + except ssl.SSLSyscallError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + raise BrokenResourceError from exc + except ssl.SSLError as exc: + self._read_bio.write_eof() + self._write_bio.write_eof() + if isinstance(exc, ssl.SSLEOFError) or ( + exc.strerror and "UNEXPECTED_EOF_WHILE_READING" in exc.strerror + ): + if self.standard_compatible: + raise BrokenResourceError from exc + else: + raise EndOfStream from None + + raise + else: + # Flush any pending writes first + if self._write_bio.pending: + await self.transport_stream.send(self._write_bio.read()) + + return result + + async def unwrap(self) -> tuple[AnyByteStream, bytes]: + """ + Does the TLS closing handshake. + + :return: a tuple of (wrapped byte stream, bytes left in the read buffer) + + """ + await self._call_sslobject_method(self._ssl_object.unwrap) + self._read_bio.write_eof() + self._write_bio.write_eof() + return self.transport_stream, self._read_bio.read() + + async def aclose(self) -> None: + if self.standard_compatible: + try: + await self.unwrap() + except BaseException: + await aclose_forcefully(self.transport_stream) + raise + + await self.transport_stream.aclose() + + async def receive(self, max_bytes: int = 65536) -> bytes: + data = await self._call_sslobject_method(self._ssl_object.read, max_bytes) + if not data: + raise EndOfStream + + return data + + async def send(self, item: bytes) -> None: + await self._call_sslobject_method(self._ssl_object.write, item) + + async def send_eof(self) -> None: + tls_version = self.extra(TLSAttribute.tls_version) + match = re.match(r"TLSv(\d+)(?:\.(\d+))?", tls_version) + if match: + major, minor = int(match.group(1)), int(match.group(2) or 0) + if (major, minor) < (1, 3): + raise NotImplementedError( + f"send_eof() requires at least TLSv1.3; current " + f"session uses {tls_version}" + ) + + raise NotImplementedError( + "send_eof() has not yet been implemented for TLS streams" + ) + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + **self.transport_stream.extra_attributes, + TLSAttribute.alpn_protocol: self._ssl_object.selected_alpn_protocol, + TLSAttribute.channel_binding_tls_unique: ( + self._ssl_object.get_channel_binding + ), + TLSAttribute.cipher: self._ssl_object.cipher, + TLSAttribute.peer_certificate: lambda: self._ssl_object.getpeercert(False), + TLSAttribute.peer_certificate_binary: lambda: self._ssl_object.getpeercert( + True + ), + TLSAttribute.server_side: lambda: self._ssl_object.server_side, + TLSAttribute.shared_ciphers: lambda: ( + self._ssl_object.shared_ciphers() + if self._ssl_object.server_side + else None + ), + TLSAttribute.standard_compatible: lambda: self.standard_compatible, + TLSAttribute.ssl_object: lambda: self._ssl_object, + TLSAttribute.tls_version: self._ssl_object.version, + } + + +@dataclass(eq=False) +class TLSListener(Listener[TLSStream]): + """ + A convenience listener that wraps another listener and auto-negotiates a TLS session + on every accepted connection. + + If the TLS handshake times out or raises an exception, + :meth:`handle_handshake_error` is called to do whatever post-mortem processing is + deemed necessary. + + Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute. + + :param Listener listener: the listener to wrap + :param ssl_context: the SSL context object + :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap` + :param handshake_timeout: time limit for the TLS handshake + (passed to :func:`~anyio.fail_after`) + """ + + listener: Listener[Any] + ssl_context: ssl.SSLContext + standard_compatible: bool = True + handshake_timeout: float = 30 + + @staticmethod + async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> None: + """ + Handle an exception raised during the TLS handshake. + + This method does 3 things: + + #. Forcefully closes the original stream + #. Logs the exception (unless it was a cancellation exception) using the + ``anyio.streams.tls`` logger + #. Reraises the exception if it was a base exception or a cancellation exception + + :param exc: the exception + :param stream: the original stream + + """ + await aclose_forcefully(stream) + + # Log all except cancellation exceptions + if not isinstance(exc, get_cancelled_exc_class()): + # CPython (as of 3.11.5) returns incorrect `sys.exc_info()` here when using + # any asyncio implementation, so we explicitly pass the exception to log + # (https://github.com/python/cpython/issues/108668). Trio does not have this + # issue because it works around the CPython bug. + logging.getLogger(__name__).exception( + "Error during TLS handshake", exc_info=exc + ) + + # Only reraise base exceptions and cancellation exceptions + if not isinstance(exc, Exception) or isinstance(exc, get_cancelled_exc_class()): + raise + + async def serve( + self, + handler: Callable[[TLSStream], Any], + task_group: TaskGroup | None = None, + ) -> None: + @wraps(handler) + async def handler_wrapper(stream: AnyByteStream) -> None: + from .. import fail_after + + try: + with fail_after(self.handshake_timeout): + wrapped_stream = await TLSStream.wrap( + stream, + ssl_context=self.ssl_context, + standard_compatible=self.standard_compatible, + ) + except BaseException as exc: + await self.handle_handshake_error(exc, stream) + else: + await handler(wrapped_stream) + + await self.listener.serve(handler_wrapper, task_group) + + async def aclose(self) -> None: + await self.listener.aclose() + + @property + def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]: + return { + TLSAttribute.standard_compatible: lambda: self.standard_compatible, + } + + +class TLSConnectable(ByteStreamConnectable): + """ + Wraps another connectable and does TLS negotiation after a successful connection. + + :param connectable: the connectable to wrap + :param hostname: host name of the server (if host name checking is desired) + :param ssl_context: the SSLContext object to use (if not provided, a secure default + will be created) + :param standard_compatible: if ``False``, skip the closing handshake when closing + the connection, and don't raise an exception if the server does the same + """ + + def __init__( + self, + connectable: AnyByteStreamConnectable, + *, + hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + standard_compatible: bool = True, + ) -> None: + self.connectable = connectable + self.ssl_context: SSLContext = ssl_context or ssl.create_default_context( + ssl.Purpose.SERVER_AUTH + ) + if not isinstance(self.ssl_context, ssl.SSLContext): + raise TypeError( + "ssl_context must be an instance of ssl.SSLContext, not " + f"{type(self.ssl_context).__name__}" + ) + self.hostname = hostname + self.standard_compatible = standard_compatible + + @override + async def connect(self) -> TLSStream: + stream = await self.connectable.connect() + try: + return await TLSStream.wrap( + stream, + hostname=self.hostname, + ssl_context=self.ssl_context, + standard_compatible=self.standard_compatible, + ) + except BaseException: + await aclose_forcefully(stream) + raise diff --git a/.venv/lib/python3.10/site-packages/anyio/to_interpreter.py b/.venv/lib/python3.10/site-packages/anyio/to_interpreter.py new file mode 100644 index 0000000..694dbe7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/to_interpreter.py @@ -0,0 +1,246 @@ +from __future__ import annotations + +__all__ = ( + "run_sync", + "current_default_interpreter_limiter", +) + +import atexit +import os +import sys +from collections import deque +from collections.abc import Callable +from typing import Any, Final, TypeVar + +from . import current_time, to_thread +from ._core._exceptions import BrokenWorkerInterpreter +from ._core._synchronization import CapacityLimiter +from .lowlevel import RunVar + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +if sys.version_info >= (3, 14): + from concurrent.interpreters import ExecutionFailed, create + + def _interp_call( + func: Callable[..., Any], args: tuple[Any, ...] + ) -> tuple[Any, bool]: + try: + retval = func(*args) + except BaseException as exc: + return exc, True + else: + return retval, False + + class _Worker: + last_used: float = 0 + + def __init__(self) -> None: + self._interpreter = create() + + def destroy(self) -> None: + self._interpreter.close() + + def call( + self, + func: Callable[..., T_Retval], + args: tuple[Any, ...], + ) -> T_Retval: + try: + res, is_exception = self._interpreter.call(_interp_call, func, args) + except ExecutionFailed as exc: + raise BrokenWorkerInterpreter(exc.excinfo) from exc + + if is_exception: + raise res + + return res +elif sys.version_info >= (3, 13): + import _interpqueues + import _interpreters + + UNBOUND: Final = 2 # I have no clue how this works, but it was used in the stdlib + FMT_UNPICKLED: Final = 0 + FMT_PICKLED: Final = 1 + QUEUE_PICKLE_ARGS: Final = (FMT_PICKLED, UNBOUND) + QUEUE_UNPICKLE_ARGS: Final = (FMT_UNPICKLED, UNBOUND) + + _run_func = compile( + """ +import _interpqueues +from _interpreters import NotShareableError +from pickle import loads, dumps, HIGHEST_PROTOCOL + +QUEUE_PICKLE_ARGS = (1, 2) +QUEUE_UNPICKLE_ARGS = (0, 2) + +item = _interpqueues.get(queue_id)[0] +try: + func, args = loads(item) + retval = func(*args) +except BaseException as exc: + is_exception = True + retval = exc +else: + is_exception = False + +try: + _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_UNPICKLE_ARGS) +except NotShareableError: + retval = dumps(retval, HIGHEST_PROTOCOL) + _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_PICKLE_ARGS) + """, + "", + "exec", + ) + + class _Worker: + last_used: float = 0 + + def __init__(self) -> None: + self._interpreter_id = _interpreters.create() + self._queue_id = _interpqueues.create(1, *QUEUE_UNPICKLE_ARGS) + _interpreters.set___main___attrs( + self._interpreter_id, {"queue_id": self._queue_id} + ) + + def destroy(self) -> None: + _interpqueues.destroy(self._queue_id) + _interpreters.destroy(self._interpreter_id) + + def call( + self, + func: Callable[..., T_Retval], + args: tuple[Any, ...], + ) -> T_Retval: + import pickle + + item = pickle.dumps((func, args), pickle.HIGHEST_PROTOCOL) + _interpqueues.put(self._queue_id, item, *QUEUE_PICKLE_ARGS) + exc_info = _interpreters.exec(self._interpreter_id, _run_func) + if exc_info: + raise BrokenWorkerInterpreter(exc_info) + + res = _interpqueues.get(self._queue_id) + (res, is_exception), fmt = res[:2] + if fmt == FMT_PICKLED: + res = pickle.loads(res) + + if is_exception: + raise res + + return res +else: + + class _Worker: + last_used: float = 0 + + def __init__(self) -> None: + raise RuntimeError("subinterpreters require at least Python 3.13") + + def call( + self, + func: Callable[..., T_Retval], + args: tuple[Any, ...], + ) -> T_Retval: + raise NotImplementedError + + def destroy(self) -> None: + pass + + +DEFAULT_CPU_COUNT: Final = 8 # this is just an arbitrarily selected value +MAX_WORKER_IDLE_TIME = ( + 30 # seconds a subinterpreter can be idle before becoming eligible for pruning +) + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") + +_idle_workers = RunVar[deque[_Worker]]("_available_workers") +_default_interpreter_limiter = RunVar[CapacityLimiter]("_default_interpreter_limiter") + + +def _stop_workers(workers: deque[_Worker]) -> None: + for worker in workers: + worker.destroy() + + workers.clear() + + +async def run_sync( + func: Callable[[Unpack[PosArgsT]], T_Retval], + *args: Unpack[PosArgsT], + limiter: CapacityLimiter | None = None, +) -> T_Retval: + """ + Call the given function with the given arguments in a subinterpreter. + + .. warning:: On Python 3.13, the :mod:`concurrent.interpreters` module was not yet + available, so the code path for that Python version relies on an undocumented, + private API. As such, it is recommended to not rely on this function for anything + mission-critical on Python 3.13. + + :param func: a callable + :param args: the positional arguments for the callable + :param limiter: capacity limiter to use to limit the total number of subinterpreters + running (if omitted, the default limiter is used) + :return: the result of the call + :raises BrokenWorkerInterpreter: if there's an internal error in a subinterpreter + + """ + if limiter is None: + limiter = current_default_interpreter_limiter() + + try: + idle_workers = _idle_workers.get() + except LookupError: + idle_workers = deque() + _idle_workers.set(idle_workers) + atexit.register(_stop_workers, idle_workers) + + async with limiter: + try: + worker = idle_workers.pop() + except IndexError: + worker = _Worker() + + try: + return await to_thread.run_sync( + worker.call, + func, + args, + limiter=limiter, + ) + finally: + # Prune workers that have been idle for too long + now = current_time() + while idle_workers: + if now - idle_workers[0].last_used <= MAX_WORKER_IDLE_TIME: + break + + await to_thread.run_sync(idle_workers.popleft().destroy, limiter=limiter) + + worker.last_used = current_time() + idle_workers.append(worker) + + +def current_default_interpreter_limiter() -> CapacityLimiter: + """ + Return the capacity limiter used by default to limit the number of concurrently + running subinterpreters. + + Defaults to the number of CPU cores. + + :return: a capacity limiter object + + """ + try: + return _default_interpreter_limiter.get() + except LookupError: + limiter = CapacityLimiter(os.cpu_count() or DEFAULT_CPU_COUNT) + _default_interpreter_limiter.set(limiter) + return limiter diff --git a/.venv/lib/python3.10/site-packages/anyio/to_process.py b/.venv/lib/python3.10/site-packages/anyio/to_process.py new file mode 100644 index 0000000..b289234 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/to_process.py @@ -0,0 +1,266 @@ +from __future__ import annotations + +__all__ = ( + "current_default_process_limiter", + "process_worker", + "run_sync", +) + +import os +import pickle +import subprocess +import sys +from collections import deque +from collections.abc import Callable +from importlib.util import module_from_spec, spec_from_file_location +from typing import TypeVar, cast + +from ._core._eventloop import current_time, get_async_backend, get_cancelled_exc_class +from ._core._exceptions import BrokenWorkerProcess +from ._core._subprocesses import open_process +from ._core._synchronization import CapacityLimiter +from ._core._tasks import CancelScope, fail_after +from .abc import ByteReceiveStream, ByteSendStream, Process +from .lowlevel import RunVar, checkpoint_if_cancelled +from .streams.buffered import BufferedByteReceiveStream + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +WORKER_MAX_IDLE_TIME = 300 # 5 minutes + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") + +_process_pool_workers: RunVar[set[Process]] = RunVar("_process_pool_workers") +_process_pool_idle_workers: RunVar[deque[tuple[Process, float]]] = RunVar( + "_process_pool_idle_workers" +) +_default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter") + + +async def run_sync( # type: ignore[return] + func: Callable[[Unpack[PosArgsT]], T_Retval], + *args: Unpack[PosArgsT], + cancellable: bool = False, + limiter: CapacityLimiter | None = None, +) -> T_Retval: + """ + Call the given function with the given arguments in a worker process. + + If the ``cancellable`` option is enabled and the task waiting for its completion is + cancelled, the worker process running it will be abruptly terminated using SIGKILL + (or ``terminateProcess()`` on Windows). + + :param func: a callable + :param args: positional arguments for the callable + :param cancellable: ``True`` to allow cancellation of the operation while it's + running + :param limiter: capacity limiter to use to limit the total amount of processes + running (if omitted, the default limiter is used) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + :return: an awaitable that yields the return value of the function. + + """ + + async def send_raw_command(pickled_cmd: bytes) -> object: + try: + await stdin.send(pickled_cmd) + response = await buffered.receive_until(b"\n", 50) + status, length = response.split(b" ") + if status not in (b"RETURN", b"EXCEPTION"): + raise RuntimeError( + f"Worker process returned unexpected response: {response!r}" + ) + + pickled_response = await buffered.receive_exactly(int(length)) + except BaseException as exc: + workers.discard(process) + try: + process.kill() + with CancelScope(shield=True): + await process.aclose() + except ProcessLookupError: + pass + + if isinstance(exc, get_cancelled_exc_class()): + raise + else: + raise BrokenWorkerProcess from exc + + retval = pickle.loads(pickled_response) + if status == b"EXCEPTION": + assert isinstance(retval, BaseException) + raise retval + else: + return retval + + # First pickle the request before trying to reserve a worker process + await checkpoint_if_cancelled() + request = pickle.dumps(("run", func, args), protocol=pickle.HIGHEST_PROTOCOL) + + # If this is the first run in this event loop thread, set up the necessary variables + try: + workers = _process_pool_workers.get() + idle_workers = _process_pool_idle_workers.get() + except LookupError: + workers = set() + idle_workers = deque() + _process_pool_workers.set(workers) + _process_pool_idle_workers.set(idle_workers) + get_async_backend().setup_process_pool_exit_at_shutdown(workers) + + async with limiter or current_default_process_limiter(): + # Pop processes from the pool (starting from the most recently used) until we + # find one that hasn't exited yet + process: Process + while idle_workers: + process, idle_since = idle_workers.pop() + if process.returncode is None: + stdin = cast(ByteSendStream, process.stdin) + buffered = BufferedByteReceiveStream( + cast(ByteReceiveStream, process.stdout) + ) + + # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME + # seconds or longer + now = current_time() + killed_processes: list[Process] = [] + while idle_workers: + if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME: + break + + process_to_kill, idle_since = idle_workers.popleft() + process_to_kill.kill() + workers.remove(process_to_kill) + killed_processes.append(process_to_kill) + + with CancelScope(shield=True): + for killed_process in killed_processes: + await killed_process.aclose() + + break + + workers.remove(process) + else: + command = [sys.executable, "-u", "-m", __name__] + process = await open_process( + command, stdin=subprocess.PIPE, stdout=subprocess.PIPE + ) + try: + stdin = cast(ByteSendStream, process.stdin) + buffered = BufferedByteReceiveStream( + cast(ByteReceiveStream, process.stdout) + ) + with fail_after(20): + message = await buffered.receive(6) + + if message != b"READY\n": + raise BrokenWorkerProcess( + f"Worker process returned unexpected response: {message!r}" + ) + + main_module_path = getattr(sys.modules["__main__"], "__file__", None) + pickled = pickle.dumps( + ("init", sys.path, main_module_path), + protocol=pickle.HIGHEST_PROTOCOL, + ) + await send_raw_command(pickled) + except (BrokenWorkerProcess, get_cancelled_exc_class()): + raise + except BaseException as exc: + process.kill() + raise BrokenWorkerProcess( + "Error during worker process initialization" + ) from exc + + workers.add(process) + + with CancelScope(shield=not cancellable): + try: + return cast(T_Retval, await send_raw_command(request)) + finally: + if process in workers: + idle_workers.append((process, current_time())) + + +def current_default_process_limiter() -> CapacityLimiter: + """ + Return the capacity limiter that is used by default to limit the number of worker + processes. + + :return: a capacity limiter object + + """ + try: + return _default_process_limiter.get() + except LookupError: + limiter = CapacityLimiter(os.cpu_count() or 2) + _default_process_limiter.set(limiter) + return limiter + + +def process_worker() -> None: + # Redirect standard streams to os.devnull so that user code won't interfere with the + # parent-worker communication + stdin = sys.stdin + stdout = sys.stdout + sys.stdin = open(os.devnull) + sys.stdout = open(os.devnull, "w") + + stdout.buffer.write(b"READY\n") + while True: + retval = exception = None + try: + command, *args = pickle.load(stdin.buffer) + except EOFError: + return + except BaseException as exc: + exception = exc + else: + if command == "run": + func, args = args + try: + retval = func(*args) + except BaseException as exc: + exception = exc + elif command == "init": + main_module_path: str | None + sys.path, main_module_path = args + del sys.modules["__main__"] + if main_module_path and os.path.isfile(main_module_path): + # Load the parent's main module but as __mp_main__ instead of + # __main__ (like multiprocessing does) to avoid infinite recursion + try: + spec = spec_from_file_location("__mp_main__", main_module_path) + if spec and spec.loader: + main = module_from_spec(spec) + spec.loader.exec_module(main) + sys.modules["__main__"] = main + except BaseException as exc: + exception = exc + try: + if exception is not None: + status = b"EXCEPTION" + pickled = pickle.dumps(exception, pickle.HIGHEST_PROTOCOL) + else: + status = b"RETURN" + pickled = pickle.dumps(retval, pickle.HIGHEST_PROTOCOL) + except BaseException as exc: + exception = exc + status = b"EXCEPTION" + pickled = pickle.dumps(exc, pickle.HIGHEST_PROTOCOL) + + stdout.buffer.write(b"%s %d\n" % (status, len(pickled))) + stdout.buffer.write(pickled) + + # Respect SIGTERM + if isinstance(exception, SystemExit): + raise exception + + +if __name__ == "__main__": + process_worker() diff --git a/.venv/lib/python3.10/site-packages/anyio/to_thread.py b/.venv/lib/python3.10/site-packages/anyio/to_thread.py new file mode 100644 index 0000000..83c79d1 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/anyio/to_thread.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +__all__ = ( + "run_sync", + "current_default_thread_limiter", +) + +import sys +from collections.abc import Callable +from typing import TypeVar +from warnings import warn + +from ._core._eventloop import get_async_backend +from .abc import CapacityLimiter + +if sys.version_info >= (3, 11): + from typing import TypeVarTuple, Unpack +else: + from typing_extensions import TypeVarTuple, Unpack + +T_Retval = TypeVar("T_Retval") +PosArgsT = TypeVarTuple("PosArgsT") + + +async def run_sync( + func: Callable[[Unpack[PosArgsT]], T_Retval], + *args: Unpack[PosArgsT], + abandon_on_cancel: bool = False, + cancellable: bool | None = None, + limiter: CapacityLimiter | None = None, +) -> T_Retval: + """ + Call the given function with the given arguments in a worker thread. + + If the ``abandon_on_cancel`` option is enabled and the task waiting for its + completion is cancelled, the thread will still run its course but its + return value (or any raised exception) will be ignored. + + :param func: a callable + :param args: positional arguments for the callable + :param abandon_on_cancel: ``True`` to abandon the thread (leaving it to run + unchecked on own) if the host task is cancelled, ``False`` to ignore + cancellations in the host task until the operation has completed in the worker + thread + :param cancellable: deprecated alias of ``abandon_on_cancel``; will override + ``abandon_on_cancel`` if both parameters are passed + :param limiter: capacity limiter to use to limit the total amount of threads running + (if omitted, the default limiter is used) + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + :return: an awaitable that yields the return value of the function. + + """ + if cancellable is not None: + abandon_on_cancel = cancellable + warn( + "The `cancellable=` keyword argument to `anyio.to_thread.run_sync` is " + "deprecated since AnyIO 4.1.0; use `abandon_on_cancel=` instead", + DeprecationWarning, + stacklevel=2, + ) + + return await get_async_backend().run_sync_in_worker_thread( + func, args, abandon_on_cancel=abandon_on_cancel, limiter=limiter + ) + + +def current_default_thread_limiter() -> CapacityLimiter: + """ + Return the capacity limiter that is used by default to limit the number of + concurrent threads. + + :return: a capacity limiter object + :raises NoEventLoopError: if no supported asynchronous event loop is running in the + current thread + + """ + return get_async_backend().current_default_thread_limiter() diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/METADATA b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/METADATA new file mode 100644 index 0000000..7fd97b7 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/METADATA @@ -0,0 +1,123 @@ +Metadata-Version: 2.4 +Name: beautifulsoup4 +Version: 4.14.3 +Summary: Screen-scraping library +Project-URL: Download, https://www.crummy.com/software/BeautifulSoup/bs4/download/ +Project-URL: Homepage, https://www.crummy.com/software/BeautifulSoup/bs4/ +Author-email: Leonard Richardson +License: MIT License +License-File: AUTHORS +License-File: LICENSE +Keywords: HTML,XML,parse,soup +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing :: Markup :: HTML +Classifier: Topic :: Text Processing :: Markup :: SGML +Classifier: Topic :: Text Processing :: Markup :: XML +Requires-Python: >=3.7.0 +Requires-Dist: soupsieve>=1.6.1 +Requires-Dist: typing-extensions>=4.0.0 +Provides-Extra: cchardet +Requires-Dist: cchardet; extra == 'cchardet' +Provides-Extra: chardet +Requires-Dist: chardet; extra == 'chardet' +Provides-Extra: charset-normalizer +Requires-Dist: charset-normalizer; extra == 'charset-normalizer' +Provides-Extra: html5lib +Requires-Dist: html5lib; extra == 'html5lib' +Provides-Extra: lxml +Requires-Dist: lxml; extra == 'lxml' +Description-Content-Type: text/markdown + +Beautiful Soup is a library that makes it easy to scrape information +from web pages. It sits atop an HTML or XML parser, providing Pythonic +idioms for iterating, searching, and modifying the parse tree. + +# Quick start + +``` +>>> from bs4 import BeautifulSoup +>>> soup = BeautifulSoup("

SomebadHTML") +>>> print(soup.prettify()) + + +

+ Some + + bad + + HTML + + +

+ + +>>> soup.find(string="bad") +'bad' +>>> soup.i +HTML +# +>>> soup = BeautifulSoup("SomebadXML", "xml") +# +>>> print(soup.prettify()) + + + Some + + bad + + XML + + +``` + +To go beyond the basics, [comprehensive documentation is available](https://www.crummy.com/software/BeautifulSoup/bs4/doc/). + +# Links + +* [Homepage](https://www.crummy.com/software/BeautifulSoup/bs4/) +* [Documentation](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) +* [Discussion group](https://groups.google.com/group/beautifulsoup/) +* [Development](https://code.launchpad.net/beautifulsoup/) +* [Bug tracker](https://bugs.launchpad.net/beautifulsoup/) +* [Complete changelog](https://git.launchpad.net/beautifulsoup/tree/CHANGELOG) + +# Note on Python 2 sunsetting + +Beautiful Soup's support for Python 2 was discontinued on December 31, +2020: one year after the sunset date for Python 2 itself. From this +point onward, new Beautiful Soup development will exclusively target +Python 3. The final release of Beautiful Soup 4 to support Python 2 +was 4.9.3. + +# Supporting the project + +If you use Beautiful Soup as part of your professional work, please consider a +[Tidelift subscription](https://tidelift.com/subscription/pkg/pypi-beautifulsoup4?utm_source=pypi-beautifulsoup4&utm_medium=referral&utm_campaign=readme). +This will support many of the free software projects your organization +depends on, not just Beautiful Soup. + +If you use Beautiful Soup for personal projects, the best way to say +thank you is to read +[Tool Safety](https://www.crummy.com/software/BeautifulSoup/zine/), a zine I +wrote about what Beautiful Soup has taught me about software +development. + +# Building the documentation + +The bs4/doc/ directory contains full documentation in Sphinx +format. Run `make html` in that directory to create HTML +documentation. + +# Running the unit tests + +Beautiful Soup supports unit test discovery using Pytest: + +``` +$ pytest +``` + diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/RECORD b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/RECORD new file mode 100644 index 0000000..febdfb4 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/RECORD @@ -0,0 +1,37 @@ +beautifulsoup4-4.14.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +beautifulsoup4-4.14.3.dist-info/METADATA,sha256=Ac93vA8Xp9FtgOcKXFM8ESfVdztimUfJ3WUpVlhKtsY,3812 +beautifulsoup4-4.14.3.dist-info/RECORD,, +beautifulsoup4-4.14.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87 +beautifulsoup4-4.14.3.dist-info/licenses/AUTHORS,sha256=uYkjiRjh_aweRnF8tAW2PpJJeickE68NmJwd9siry28,2201 +beautifulsoup4-4.14.3.dist-info/licenses/LICENSE,sha256=VbTY1LHlvIbRDvrJG3TIe8t3UmsPW57a-LnNKtxzl7I,1441 +bs4/__init__.py,sha256=E7wiVp7oQK0JhdAYxpehZa8drv3W_sJv5oeTFiBfR5o,44386 +bs4/__pycache__/__init__.cpython-310.pyc,, +bs4/__pycache__/_deprecation.cpython-310.pyc,, +bs4/__pycache__/_typing.cpython-310.pyc,, +bs4/__pycache__/_warnings.cpython-310.pyc,, +bs4/__pycache__/css.cpython-310.pyc,, +bs4/__pycache__/dammit.cpython-310.pyc,, +bs4/__pycache__/diagnose.cpython-310.pyc,, +bs4/__pycache__/element.cpython-310.pyc,, +bs4/__pycache__/exceptions.cpython-310.pyc,, +bs4/__pycache__/filter.cpython-310.pyc,, +bs4/__pycache__/formatter.cpython-310.pyc,, +bs4/_deprecation.py,sha256=niHJCk37APg8KEuFOa57ZXaxLdBmc_2V6uuaJqu7r30,2408 +bs4/_typing.py,sha256=zNcx7R1yCTK8WwtumP28hc7CJ3pMyZXj_VAeYaNXMZA,7549 +bs4/_warnings.py,sha256=ZuOETgcnEbZgw2N0nnNXn6wvtrn2ut7AF0d98bvkMFc,4711 +bs4/builder/__init__.py,sha256=Rl4qjOXvdyyyjayOFqbkgoUoo81IgoyKD-RwWeVK59g,31194 +bs4/builder/__pycache__/__init__.cpython-310.pyc,, +bs4/builder/__pycache__/_html5lib.cpython-310.pyc,, +bs4/builder/__pycache__/_htmlparser.cpython-310.pyc,, +bs4/builder/__pycache__/_lxml.cpython-310.pyc,, +bs4/builder/_html5lib.py,sha256=hL6xUk4_I2i5CMguFoYFlrI26cY4Dut7fOEQrUctHIM,23607 +bs4/builder/_htmlparser.py,sha256=CnULPQV2rm4vLojJABpQ7Xm9diddnEZx2Wcz_VTC1Mg,17445 +bs4/builder/_lxml.py,sha256=ks1e8boA_nOA2oomAhxeudccR6ThbEE-EllFqHRoPLA,18969 +bs4/css.py,sha256=_m_l_4SGWHnY620VJ21j_qQH1RX3p91sYVemgKxaLsM,12713 +bs4/dammit.py,sha256=ZJWa9K32X6N2imFHleqUq0ekf592weU1lvULN_WYWYk,57024 +bs4/diagnose.py,sha256=at98iuxyOrqec4V8iwkTIbNUqBCsq9Lr3fDAQx2129Y,7846 +bs4/element.py,sha256=oXmj7LG_2NpsDK90mq73q0PMK0FjFBIGSeTTJLVwwTc,120237 +bs4/exceptions.py,sha256=Q9FOadNe8QRvzDMaKSXe2Wtl8JK_oAZW7mbFZBVP_GE,951 +bs4/filter.py,sha256=rw8ZNhTDLEJVCEiSifou5tZR_3zBLeuvAyouY82qU_E,29201 +bs4/formatter.py,sha256=uBT0k6W8O5kJ9PCuJYjra97yoUqC-dlM9D_v-oRM0r8,10478 +bs4/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/WHEEL new file mode 100644 index 0000000..12228d4 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.27.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/AUTHORS b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/AUTHORS new file mode 100644 index 0000000..18926c2 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/AUTHORS @@ -0,0 +1,49 @@ +Behold, mortal, the origins of Beautiful Soup... +================================================ + +Leonard Richardson is the primary maintainer. + +Aaron DeVore, Isaac Muse and Chris Papademetrious have made +significant contributions to the code base. + +Mark Pilgrim provided the encoding detection code that forms the base +of UnicodeDammit. + +Thomas Kluyver and Ezio Melotti finished the work of getting Beautiful +Soup 4 working under Python 3. + +Simon Willison wrote soupselect, which was used to make Beautiful Soup +support CSS selectors. Isaac Muse wrote SoupSieve, which made it +possible to _remove_ the CSS selector code from Beautiful Soup. + +Sam Ruby helped with a lot of edge cases. + +Jonathan Ellis was awarded the prestigious Beau Potage D'Or for his +work in solving the nestable tags conundrum. + +An incomplete list of people have contributed patches to Beautiful +Soup: + + Istvan Albert, Andrew Lin, Anthony Baxter, Oliver Beattie, Andrew +Boyko, Tony Chang, Francisco Canas, "Delong", Zephyr Fang, Fuzzy, +Roman Gaufman, Yoni Gilad, Richie Hindle, Toshihiro Kamiya, Peteris +Krumins, Kent Johnson, Marek Kapolka, Andreas Kostyrka, Roel Kramer, +Ben Last, Robert Leftwich, Stefaan Lippens, "liquider", Staffan +Malmgren, Ksenia Marasanova, JP Moins, Adam Monsen, John Nagle, "Jon", +Ed Oskiewicz, Martijn Peters, Greg Phillips, Giles Radford, Stefano +Revera, Arthur Rudolph, Marko Samastur, James Salter, Jouni Seppänen, +Alexander Schmolck, Tim Shirley, Geoffrey Sneddon, Ville Skyttä, +"Vikas", Jens Svalgaard, Andy Theyers, Eric Weiser, Glyn Webster, John +Wiseman, Paul Wright, Danny Yoo + +An incomplete list of people who made suggestions or found bugs or +found ways to break Beautiful Soup: + + Hanno Böck, Matteo Bertini, Chris Curvey, Simon Cusack, Bruce Eckel, + Matt Ernst, Michael Foord, Tom Harris, Bill de hOra, Donald Howes, + Matt Patterson, Scott Roberts, Steve Strassmann, Mike Williams, + warchild at redho dot com, Sami Kuisma, Carlos Rocha, Bob Hutchison, + Joren Mc, Michal Migurski, John Kleven, Tim Heaney, Tripp Lilley, Ed + Summers, Dennis Sutch, Chris Smith, Aaron Swartz, Stuart + Turner, Greg Edwards, Kevin J Kalupson, Nikos Kouremenos, Artur de + Sousa Rocha, Yichun Wei, Per Vognsen diff --git a/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/LICENSE b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/LICENSE new file mode 100644 index 0000000..08e3a9c --- /dev/null +++ b/.venv/lib/python3.10/site-packages/beautifulsoup4-4.14.3.dist-info/licenses/LICENSE @@ -0,0 +1,31 @@ +Beautiful Soup is made available under the MIT license: + + Copyright (c) Leonard Richardson + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + +Beautiful Soup incorporates code from the html5lib library, which is +also made available under the MIT license. Copyright (c) James Graham +and other contributors + +Beautiful Soup has an optional dependency on the soupsieve library, +which is also made available under the MIT license. Copyright (c) +Isaac Muse diff --git a/.venv/lib/python3.10/site-packages/bs4/__init__.py b/.venv/lib/python3.10/site-packages/bs4/__init__.py new file mode 100644 index 0000000..19b7c0e --- /dev/null +++ b/.venv/lib/python3.10/site-packages/bs4/__init__.py @@ -0,0 +1,1174 @@ +"""Beautiful Soup Elixir and Tonic - "The Screen-Scraper's Friend". + +http://www.crummy.com/software/BeautifulSoup/ + +Beautiful Soup uses a pluggable XML or HTML parser to parse a +(possibly invalid) document into a tree representation. Beautiful Soup +provides methods and Pythonic idioms that make it easy to navigate, +search, and modify the parse tree. + +Beautiful Soup works with Python 3.7 and up. It works better if lxml +and/or html5lib is installed, but they are not required. + +For more than you ever wanted to know about Beautiful Soup, see the +documentation: http://www.crummy.com/software/BeautifulSoup/bs4/doc/ +""" + +__author__ = "Leonard Richardson (leonardr@segfault.org)" +__version__ = "4.14.3" +__copyright__ = "Copyright (c) 2004-2025 Leonard Richardson" +# Use of this source code is governed by the MIT license. +__license__ = "MIT" + +__all__ = [ + "AttributeResemblesVariableWarning", + "BeautifulSoup", + "Comment", + "Declaration", + "ProcessingInstruction", + "ResultSet", + "CSS", + "Script", + "Stylesheet", + "Tag", + "TemplateString", + "ElementFilter", + "UnicodeDammit", + "CData", + "Doctype", + + # Exceptions + "FeatureNotFound", + "ParserRejectedMarkup", + "StopParsing", + + # Warnings + "AttributeResemblesVariableWarning", + "GuessedAtParserWarning", + "MarkupResemblesLocatorWarning", + "UnusualUsageWarning", + "XMLParsedAsHTMLWarning", +] + +from collections import Counter +import io +import sys +import warnings + +# The very first thing we do is give a useful error if someone is +# running this code under Python 2. +if sys.version_info.major < 3: + raise ImportError( + "You are trying to use a Python 3-specific version of Beautiful Soup under Python 2. This will not work. The final version of Beautiful Soup to support Python 2 was 4.9.3." + ) + +from .builder import ( + builder_registry, + TreeBuilder, +) +from .builder._htmlparser import HTMLParserTreeBuilder +from .dammit import UnicodeDammit +from .css import CSS +from ._deprecation import ( + _deprecated, +) +from .element import ( + CData, + Comment, + DEFAULT_OUTPUT_ENCODING, + Declaration, + Doctype, + NavigableString, + PageElement, + ProcessingInstruction, + PYTHON_SPECIFIC_ENCODINGS, + ResultSet, + Script, + Stylesheet, + Tag, + TemplateString, +) +from .formatter import Formatter +from .filter import ( + ElementFilter, + SoupStrainer, +) +from typing import ( + Any, + cast, + Counter as CounterType, + Dict, + Iterator, + List, + Sequence, + Sized, + Optional, + Type, + Union, +) + +from bs4._typing import ( + _Encoding, + _Encodings, + _IncomingMarkup, + _InsertableElement, + _RawAttributeValue, + _RawAttributeValues, + _RawMarkup, +) + +# Import all warnings and exceptions into the main package. +from bs4.exceptions import ( + FeatureNotFound, + ParserRejectedMarkup, + StopParsing, +) +from bs4._warnings import ( + AttributeResemblesVariableWarning, + GuessedAtParserWarning, + MarkupResemblesLocatorWarning, + UnusualUsageWarning, + XMLParsedAsHTMLWarning, +) + + +class BeautifulSoup(Tag): + """A data structure representing a parsed HTML or XML document. + + Most of the methods you'll call on a BeautifulSoup object are inherited from + PageElement or Tag. + + Internally, this class defines the basic interface called by the + tree builders when converting an HTML/XML document into a data + structure. The interface abstracts away the differences between + parsers. To write a new tree builder, you'll need to understand + these methods as a whole. + + These methods will be called by the BeautifulSoup constructor: + * reset() + * feed(markup) + + The tree builder may call these methods from its feed() implementation: + * handle_starttag(name, attrs) # See note about return value + * handle_endtag(name) + * handle_data(data) # Appends to the current data node + * endData(containerClass) # Ends the current data node + + No matter how complicated the underlying parser is, you should be + able to build a tree using 'start tag' events, 'end tag' events, + 'data' events, and "done with data" events. + + If you encounter an empty-element tag (aka a self-closing tag, + like HTML's
tag), call handle_starttag and then + handle_endtag. + """ + + #: Since `BeautifulSoup` subclasses `Tag`, it's possible to treat it as + #: a `Tag` with a `Tag.name`. Hoever, this name makes it clear the + #: `BeautifulSoup` object isn't a real markup tag. + ROOT_TAG_NAME: str = "[document]" + + #: If the end-user gives no indication which tree builder they + #: want, look for one with these features. + DEFAULT_BUILDER_FEATURES: Sequence[str] = ["html", "fast"] + + #: A string containing all ASCII whitespace characters, used in + #: during parsing to detect data chunks that seem 'empty'. + ASCII_SPACES: str = "\x20\x0a\x09\x0c\x0d" + + # FUTURE PYTHON: + element_classes: Dict[Type[PageElement], Type[PageElement]] #: :meta private: + builder: TreeBuilder #: :meta private: + is_xml: bool + known_xml: Optional[bool] + parse_only: Optional[SoupStrainer] #: :meta private: + + # These members are only used while parsing markup. + markup: Optional[_RawMarkup] #: :meta private: + current_data: List[str] #: :meta private: + currentTag: Optional[Tag] #: :meta private: + tagStack: List[Tag] #: :meta private: + open_tag_counter: CounterType[str] #: :meta private: + preserve_whitespace_tag_stack: List[Tag] #: :meta private: + string_container_stack: List[Tag] #: :meta private: + _most_recent_element: Optional[PageElement] #: :meta private: + + #: Beautiful Soup's best guess as to the character encoding of the + #: original document. + original_encoding: Optional[_Encoding] + + #: The character encoding, if any, that was explicitly defined + #: in the original document. This may or may not match + #: `BeautifulSoup.original_encoding`. + declared_html_encoding: Optional[_Encoding] + + #: This is True if the markup that was parsed contains + #: U+FFFD REPLACEMENT_CHARACTER characters which were not present + #: in the original markup. These mark character sequences that + #: could not be represented in Unicode. + contains_replacement_characters: bool + + def __init__( + self, + markup: _IncomingMarkup = "", + features: Optional[Union[str, Sequence[str]]] = None, + builder: Optional[Union[TreeBuilder, Type[TreeBuilder]]] = None, + parse_only: Optional[SoupStrainer] = None, + from_encoding: Optional[_Encoding] = None, + exclude_encodings: Optional[_Encodings] = None, + element_classes: Optional[Dict[Type[PageElement], Type[PageElement]]] = None, + **kwargs: Any, + ): + """Constructor. + + :param markup: A string or a file-like object representing + markup to be parsed. + + :param features: Desirable features of the parser to be + used. This may be the name of a specific parser ("lxml", + "lxml-xml", "html.parser", or "html5lib") or it may be the + type of markup to be used ("html", "html5", "xml"). It's + recommended that you name a specific parser, so that + Beautiful Soup gives you the same results across platforms + and virtual environments. + + :param builder: A TreeBuilder subclass to instantiate (or + instance to use) instead of looking one up based on + `features`. You only need to use this if you've implemented a + custom TreeBuilder. + + :param parse_only: A SoupStrainer. Only parts of the document + matching the SoupStrainer will be considered. This is useful + when parsing part of a document that would otherwise be too + large to fit into memory. + + :param from_encoding: A string indicating the encoding of the + document to be parsed. Pass this in if Beautiful Soup is + guessing wrongly about the document's encoding. + + :param exclude_encodings: A list of strings indicating + encodings known to be wrong. Pass this in if you don't know + the document's encoding but you know Beautiful Soup's guess is + wrong. + + :param element_classes: A dictionary mapping BeautifulSoup + classes like Tag and NavigableString, to other classes you'd + like to be instantiated instead as the parse tree is + built. This is useful for subclassing Tag or NavigableString + to modify default behavior. + + :param kwargs: For backwards compatibility purposes, the + constructor accepts certain keyword arguments used in + Beautiful Soup 3. None of these arguments do anything in + Beautiful Soup 4; they will result in a warning and then be + ignored. + + Apart from this, any keyword arguments passed into the + BeautifulSoup constructor are propagated to the TreeBuilder + constructor. This makes it possible to configure a + TreeBuilder by passing in arguments, not just by saying which + one to use. + """ + if "convertEntities" in kwargs: + del kwargs["convertEntities"] + warnings.warn( + "BS4 does not respect the convertEntities argument to the " + "BeautifulSoup constructor. Entities are always converted " + "to Unicode characters." + ) + + if "markupMassage" in kwargs: + del kwargs["markupMassage"] + warnings.warn( + "BS4 does not respect the markupMassage argument to the " + "BeautifulSoup constructor. The tree builder is responsible " + "for any necessary markup massage." + ) + + if "smartQuotesTo" in kwargs: + del kwargs["smartQuotesTo"] + warnings.warn( + "BS4 does not respect the smartQuotesTo argument to the " + "BeautifulSoup constructor. Smart quotes are always converted " + "to Unicode characters." + ) + + if "selfClosingTags" in kwargs: + del kwargs["selfClosingTags"] + warnings.warn( + "Beautiful Soup 4 does not respect the selfClosingTags argument to the " + "BeautifulSoup constructor. The tree builder is responsible " + "for understanding self-closing tags." + ) + + if "isHTML" in kwargs: + del kwargs["isHTML"] + warnings.warn( + "Beautiful Soup 4 does not respect the isHTML argument to the " + "BeautifulSoup constructor. Suggest you use " + "features='lxml' for HTML and features='lxml-xml' for " + "XML." + ) + + def deprecated_argument(old_name: str, new_name: str) -> Optional[Any]: + if old_name in kwargs: + warnings.warn( + 'The "%s" argument to the BeautifulSoup constructor ' + 'was renamed to "%s" in Beautiful Soup 4.0.0' + % (old_name, new_name), + DeprecationWarning, + stacklevel=3, + ) + return kwargs.pop(old_name) + return None + + parse_only = parse_only or deprecated_argument("parseOnlyThese", "parse_only") + if parse_only is not None: + # Issue a warning if we can tell in advance that + # parse_only will exclude the entire tree. + if parse_only.excludes_everything: + warnings.warn( + f"The given value for parse_only will exclude everything: {parse_only}", + UserWarning, + stacklevel=3, + ) + + from_encoding = from_encoding or deprecated_argument( + "fromEncoding", "from_encoding" + ) + + if from_encoding and isinstance(markup, str): + warnings.warn( + "You provided Unicode markup but also provided a value for from_encoding. Your from_encoding will be ignored." + ) + from_encoding = None + + self.element_classes = element_classes or dict() + + # We need this information to track whether or not the builder + # was specified well enough that we can omit the 'you need to + # specify a parser' warning. + original_builder = builder + original_features = features + + builder_class: Optional[Type[TreeBuilder]] = None + if isinstance(builder, type): + # A builder class was passed in; it needs to be instantiated. + builder_class = builder + builder = None + elif builder is None: + if isinstance(features, str): + features = [features] + if features is None or len(features) == 0: + features = self.DEFAULT_BUILDER_FEATURES + possible_builder_class = builder_registry.lookup(*features) + if possible_builder_class is None: + raise FeatureNotFound( + "Couldn't find a tree builder with the features you " + "requested: %s. Do you need to install a parser library?" + % ",".join(features) + ) + builder_class = possible_builder_class + + # At this point either we have a TreeBuilder instance in + # builder, or we have a builder_class that we can instantiate + # with the remaining **kwargs. + if builder is None: + assert builder_class is not None + builder = builder_class(**kwargs) + if ( + not original_builder + and not ( + original_features == builder.NAME + or ( + isinstance(original_features, str) + and original_features in builder.ALTERNATE_NAMES + ) + ) + and markup + ): + # The user did not tell us which TreeBuilder to use, + # and we had to guess. Issue a warning. + if builder.is_xml: + markup_type = "XML" + else: + markup_type = "HTML" + + # This code adapted from warnings.py so that we get the same line + # of code as our warnings.warn() call gets, even if the answer is wrong + # (as it may be in a multithreading situation). + caller = None + try: + caller = sys._getframe(1) + except ValueError: + pass + if caller: + globals = caller.f_globals + line_number = caller.f_lineno + else: + globals = sys.__dict__ + line_number = 1 + filename = globals.get("__file__") + if filename: + fnl = filename.lower() + if fnl.endswith((".pyc", ".pyo")): + filename = filename[:-1] + if filename: + # If there is no filename at all, the user is most likely in a REPL, + # and the warning is not necessary. + values = dict( + filename=filename, + line_number=line_number, + parser=builder.NAME, + markup_type=markup_type, + ) + warnings.warn( + GuessedAtParserWarning.MESSAGE % values, + GuessedAtParserWarning, + stacklevel=2, + ) + else: + if kwargs: + warnings.warn( + "Keyword arguments to the BeautifulSoup constructor will be ignored. These would normally be passed into the TreeBuilder constructor, but a TreeBuilder instance was passed in as `builder`." + ) + + self.builder = builder + self.is_xml = builder.is_xml + self.known_xml = self.is_xml + self._namespaces = dict() + self.parse_only = parse_only + + if hasattr(markup, "read"): # It's a file-type object. + markup = cast(io.IOBase, markup).read() + elif not isinstance(markup, (bytes, str)) and not hasattr(markup, "__len__"): + raise TypeError( + f"Incoming markup is of an invalid type: {markup!r}. Markup must be a string, a bytestring, or an open filehandle." + ) + elif isinstance(markup, Sized) and len(markup) <= 256 and ( + (isinstance(markup, bytes) and b"<" not in markup and b"\n" not in markup) + or (isinstance(markup, str) and "<" not in markup and "\n" not in markup) + ): + # Issue warnings for a couple beginner problems + # involving passing non-markup to Beautiful Soup. + # Beautiful Soup will still parse the input as markup, + # since that is sometimes the intended behavior. + if not self._markup_is_url(markup): + self._markup_resembles_filename(markup) + + # At this point we know markup is a string or bytestring. If + # it was a file-type object, we've read from it. + markup = cast(_RawMarkup, markup) + + rejections = [] + success = False + for ( + self.markup, + self.original_encoding, + self.declared_html_encoding, + self.contains_replacement_characters, + ) in self.builder.prepare_markup( + markup, from_encoding, exclude_encodings=exclude_encodings + ): + self.reset() + self.builder.initialize_soup(self) + try: + self._feed() + success = True + break + except ParserRejectedMarkup as e: + rejections.append(e) + pass + + if not success: + other_exceptions = [str(e) for e in rejections] + raise ParserRejectedMarkup( + "The markup you provided was rejected by the parser. Trying a different parser or a different encoding may help.\n\nOriginal exception(s) from parser:\n " + + "\n ".join(other_exceptions) + ) + + # Clear out the markup and remove the builder's circular + # reference to this object. + self.markup = None + self.builder.soup = None + + def copy_self(self) -> "BeautifulSoup": + """Create a new BeautifulSoup object with the same TreeBuilder, + but not associated with any markup. + + This is the first step of the deepcopy process. + """ + clone = type(self)("", None, self.builder) + + # Keep track of the encoding of the original document, + # since we won't be parsing it again. + clone.original_encoding = self.original_encoding + return clone + + def __getstate__(self) -> Dict[str, Any]: + # Frequently a tree builder can't be pickled. + d = dict(self.__dict__) + if "builder" in d and d["builder"] is not None and not self.builder.picklable: + d["builder"] = type(self.builder) + # Store the contents as a Unicode string. + d["contents"] = [] + d["markup"] = self.decode() + + # If _most_recent_element is present, it's a Tag object left + # over from initial parse. It might not be picklable and we + # don't need it. + if "_most_recent_element" in d: + del d["_most_recent_element"] + return d + + def __setstate__(self, state: Dict[str, Any]) -> None: + # If necessary, restore the TreeBuilder by looking it up. + self.__dict__ = state + if isinstance(self.builder, type): + self.builder = self.builder() + elif not self.builder: + # We don't know which builder was used to build this + # parse tree, so use a default we know is always available. + self.builder = HTMLParserTreeBuilder() + self.builder.soup = self + self.reset() + self._feed() + + @classmethod + @_deprecated( + replaced_by="nothing (private method, will be removed)", version="4.13.0" + ) + def _decode_markup(cls, markup: _RawMarkup) -> str: + """Ensure `markup` is Unicode so it's safe to send into warnings.warn. + + warnings.warn had this problem back in 2010 but fortunately + not anymore. This has not been used for a long time; I just + noticed that fact while working on 4.13.0. + """ + if isinstance(markup, bytes): + decoded = markup.decode("utf-8", "replace") + else: + decoded = markup + return decoded + + @classmethod + def _markup_is_url(cls, markup: _RawMarkup) -> bool: + """Error-handling method to raise a warning if incoming markup looks + like a URL. + + :param markup: A string of markup. + :return: Whether or not the markup resembled a URL + closely enough to justify issuing a warning. + """ + problem: bool = False + if isinstance(markup, bytes): + problem = ( + any(markup.startswith(prefix) for prefix in (b"http:", b"https:")) + and b" " not in markup + ) + elif isinstance(markup, str): + problem = ( + any(markup.startswith(prefix) for prefix in ("http:", "https:")) + and " " not in markup + ) + else: + return False + + if not problem: + return False + warnings.warn( + MarkupResemblesLocatorWarning.URL_MESSAGE % dict(what="URL"), + MarkupResemblesLocatorWarning, + stacklevel=3, + ) + return True + + @classmethod + def _markup_resembles_filename(cls, markup: _RawMarkup) -> bool: + """Error-handling method to issue a warning if incoming markup + resembles a filename. + + :param markup: A string of markup. + :return: Whether or not the markup resembled a filename + closely enough to justify issuing a warning. + """ + markup_b: bytes + + # We're only checking ASCII characters, so rather than write + # the same tests twice, convert Unicode to a bytestring and + # operate on the bytestring. + if isinstance(markup, str): + markup_b = markup.encode("utf8") + else: + markup_b = markup + + # Step 1: does it end with a common textual file extension? + filelike = False + lower = markup_b.lower() + extensions = [b".html", b".htm", b".xml", b".xhtml", b".txt"] + if any(lower.endswith(ext) for ext in extensions): + filelike = True + if not filelike: + return False + + # Step 2: it _might_ be a file, but there are a few things + # we can look for that aren't very common in filenames. + + # Characters that have special meaning to Unix shells. (< was + # excluded before this method was called.) + # + # Many of these are also reserved characters that cannot + # appear in Windows filenames. + for byte in markup_b: + if byte in b"?*#&;>$|": + return False + + # Two consecutive forward slashes (as seen in a URL) or two + # consecutive spaces (as seen in fixed-width data). + # + # (Paths to Windows network shares contain consecutive + # backslashes, so checking that doesn't seem as helpful.) + if b"//" in markup_b: + return False + if b" " in markup_b: + return False + + # A colon in any position other than position 1 (e.g. after a + # Windows drive letter). + if markup_b.startswith(b":"): + return False + colon_i = markup_b.rfind(b":") + if colon_i not in (-1, 1): + return False + + # Step 3: If it survived all of those checks, it's similar + # enough to a file to justify issuing a warning. + warnings.warn( + MarkupResemblesLocatorWarning.FILENAME_MESSAGE % dict(what="filename"), + MarkupResemblesLocatorWarning, + stacklevel=3, + ) + return True + + def _feed(self) -> None: + """Internal method that parses previously set markup, creating a large + number of Tag and NavigableString objects. + """ + # Convert the document to Unicode. + self.builder.reset() + + if self.markup is not None: + self.builder.feed(self.markup) + # Close out any unfinished strings and close all the open tags. + self.endData() + while ( + self.currentTag is not None and self.currentTag.name != self.ROOT_TAG_NAME + ): + self.popTag() + + def reset(self) -> None: + """Reset this object to a state as though it had never parsed any + markup. + """ + Tag.__init__(self, self, self.builder, self.ROOT_TAG_NAME) + self.hidden = True + self.builder.reset() + self.current_data = [] + self.currentTag = None + self.tagStack = [] + self.open_tag_counter = Counter() + self.preserve_whitespace_tag_stack = [] + self.string_container_stack = [] + self._most_recent_element = None + self.pushTag(self) + + def new_tag( + self, + name: str, + namespace: Optional[str] = None, + nsprefix: Optional[str] = None, + attrs: Optional[_RawAttributeValues] = None, + sourceline: Optional[int] = None, + sourcepos: Optional[int] = None, + string: Optional[str] = None, + **kwattrs: _RawAttributeValue, + ) -> Tag: + """Create a new Tag associated with this BeautifulSoup object. + + :param name: The name of the new Tag. + :param namespace: The URI of the new Tag's XML namespace, if any. + :param prefix: The prefix for the new Tag's XML namespace, if any. + :param attrs: A dictionary of this Tag's attribute values; can + be used instead of ``kwattrs`` for attributes like 'class' + that are reserved words in Python. + :param sourceline: The line number where this tag was + (purportedly) found in its source document. + :param sourcepos: The character position within ``sourceline`` where this + tag was (purportedly) found. + :param string: String content for the new Tag, if any. + :param kwattrs: Keyword arguments for the new Tag's attribute values. + + """ + attr_container = self.builder.attribute_dict_class(**kwattrs) + if attrs is not None: + attr_container.update(attrs) + tag_class = self.element_classes.get(Tag, Tag) + + # Assume that this is either Tag or a subclass of Tag. If not, + # the user brought type-unsafety upon themselves. + tag_class = cast(Type[Tag], tag_class) + tag = tag_class( + None, + self.builder, + name, + namespace, + nsprefix, + attr_container, + sourceline=sourceline, + sourcepos=sourcepos, + ) + + if string is not None: + tag.string = string + return tag + + def string_container( + self, base_class: Optional[Type[NavigableString]] = None + ) -> Type[NavigableString]: + """Find the class that should be instantiated to hold a given kind of + string. + + This may be a built-in Beautiful Soup class or a custom class passed + in to the BeautifulSoup constructor. + """ + container = base_class or NavigableString + + # The user may want us to use some other class (hopefully a + # custom subclass) instead of the one we'd use normally. + container = cast( + Type[NavigableString], self.element_classes.get(container, container) + ) + + # On top of that, we may be inside a tag that needs a special + # container class. + if self.string_container_stack and container is NavigableString: + container = self.builder.string_containers.get( + self.string_container_stack[-1].name, container + ) + return container + + def new_string( + self, s: str, subclass: Optional[Type[NavigableString]] = None + ) -> NavigableString: + """Create a new `NavigableString` associated with this `BeautifulSoup` + object. + + :param s: The string content of the `NavigableString` + :param subclass: The subclass of `NavigableString`, if any, to + use. If a document is being processed, an appropriate + subclass for the current location in the document will + be determined automatically. + """ + container = self.string_container(subclass) + return container(s) + + def insert_before(self, *args: _InsertableElement) -> List[PageElement]: + """This method is part of the PageElement API, but `BeautifulSoup` doesn't implement + it because there is nothing before or after it in the parse tree. + """ + raise NotImplementedError( + "BeautifulSoup objects don't support insert_before()." + ) + + def insert_after(self, *args: _InsertableElement) -> List[PageElement]: + """This method is part of the PageElement API, but `BeautifulSoup` doesn't implement + it because there is nothing before or after it in the parse tree. + """ + raise NotImplementedError("BeautifulSoup objects don't support insert_after().") + + def popTag(self) -> Optional[Tag]: + """Internal method called by _popToTag when a tag is closed. + + :meta private: + """ + if not self.tagStack: + # Nothing to pop. This shouldn't happen. + return None + tag = self.tagStack.pop() + if tag.name in self.open_tag_counter: + self.open_tag_counter[tag.name] -= 1 + if ( + self.preserve_whitespace_tag_stack + and tag == self.preserve_whitespace_tag_stack[-1] + ): + self.preserve_whitespace_tag_stack.pop() + if self.string_container_stack and tag == self.string_container_stack[-1]: + self.string_container_stack.pop() + # print("Pop", tag.name) + if self.tagStack: + self.currentTag = self.tagStack[-1] + return self.currentTag + + def pushTag(self, tag: Tag) -> None: + """Internal method called by handle_starttag when a tag is opened. + + :meta private: + """ + # print("Push", tag.name) + if self.currentTag is not None: + self.currentTag.contents.append(tag) + self.tagStack.append(tag) + self.currentTag = self.tagStack[-1] + if tag.name != self.ROOT_TAG_NAME: + self.open_tag_counter[tag.name] += 1 + if tag.name in self.builder.preserve_whitespace_tags: + self.preserve_whitespace_tag_stack.append(tag) + if tag.name in self.builder.string_containers: + self.string_container_stack.append(tag) + + def endData(self, containerClass: Optional[Type[NavigableString]] = None) -> None: + """Method called by the TreeBuilder when the end of a data segment + occurs. + + :param containerClass: The class to use when incorporating the + data segment into the parse tree. + + :meta private: + """ + if self.current_data: + current_data = "".join(self.current_data) + # If whitespace is not preserved, and this string contains + # nothing but ASCII spaces, replace it with a single space + # or newline. + if not self.preserve_whitespace_tag_stack: + strippable = True + for i in current_data: + if i not in self.ASCII_SPACES: + strippable = False + break + if strippable: + if "\n" in current_data: + current_data = "\n" + else: + current_data = " " + + # Reset the data collector. + self.current_data = [] + + # Should we add this string to the tree at all? + if ( + self.parse_only + and len(self.tagStack) <= 1 + and (not self.parse_only.allow_string_creation(current_data)) + ): + return + + containerClass = self.string_container(containerClass) + o = containerClass(current_data) + self.object_was_parsed(o) + + def object_was_parsed( + self, + o: PageElement, + parent: Optional[Tag] = None, + most_recent_element: Optional[PageElement] = None, + ) -> None: + """Method called by the TreeBuilder to integrate an object into the + parse tree. + + :meta private: + """ + if parent is None: + parent = self.currentTag + assert parent is not None + previous_element: Optional[PageElement] + if most_recent_element is not None: + previous_element = most_recent_element + else: + previous_element = self._most_recent_element + + next_element = previous_sibling = next_sibling = None + if isinstance(o, Tag): + next_element = o.next_element + next_sibling = o.next_sibling + previous_sibling = o.previous_sibling + if previous_element is None: + previous_element = o.previous_element + + fix = parent.next_element is not None + + o.setup(parent, previous_element, next_element, previous_sibling, next_sibling) + + self._most_recent_element = o + parent.contents.append(o) + + # Check if we are inserting into an already parsed node. + if fix: + self._linkage_fixer(parent) + + def _linkage_fixer(self, el: Tag) -> None: + """Make sure linkage of this fragment is sound.""" + + first = el.contents[0] + child = el.contents[-1] + descendant: PageElement = child + + if child is first and el.parent is not None: + # Parent should be linked to first child + el.next_element = child + # We are no longer linked to whatever this element is + prev_el = child.previous_element + if prev_el is not None and prev_el is not el: + prev_el.next_element = None + # First child should be linked to the parent, and no previous siblings. + child.previous_element = el + child.previous_sibling = None + + # We have no sibling as we've been appended as the last. + child.next_sibling = None + + # This index is a tag, dig deeper for a "last descendant" + if isinstance(child, Tag) and child.contents: + # _last_decendant is typed as returning Optional[PageElement], + # but the value can't be None here, because el is a Tag + # which we know has contents. + descendant = cast(PageElement, child._last_descendant(False)) + + # As the final step, link last descendant. It should be linked + # to the parent's next sibling (if found), else walk up the chain + # and find a parent with a sibling. It should have no next sibling. + descendant.next_element = None + descendant.next_sibling = None + + target: Optional[Tag] = el + while True: + if target is None: + break + elif target.next_sibling is not None: + descendant.next_element = target.next_sibling + target.next_sibling.previous_element = child + break + target = target.parent + + def _popToTag( + self, name: str, nsprefix: Optional[str] = None, inclusivePop: bool = True + ) -> Optional[Tag]: + """Pops the tag stack up to and including the most recent + instance of the given tag. + + If there are no open tags with the given name, nothing will be + popped. + + :param name: Pop up to the most recent tag with this name. + :param nsprefix: The namespace prefix that goes with `name`. + :param inclusivePop: It this is false, pops the tag stack up + to but *not* including the most recent instqance of the + given tag. + + :meta private: + """ + # print("Popping to %s" % name) + if name == self.ROOT_TAG_NAME: + # The BeautifulSoup object itself can never be popped. + return None + + most_recently_popped = None + + stack_size = len(self.tagStack) + for i in range(stack_size - 1, 0, -1): + if not self.open_tag_counter.get(name): + break + t = self.tagStack[i] + if name == t.name and nsprefix == t.prefix: + if inclusivePop: + most_recently_popped = self.popTag() + break + most_recently_popped = self.popTag() + + return most_recently_popped + + def handle_starttag( + self, + name: str, + namespace: Optional[str], + nsprefix: Optional[str], + attrs: _RawAttributeValues, + sourceline: Optional[int] = None, + sourcepos: Optional[int] = None, + namespaces: Optional[Dict[str, str]] = None, + ) -> Optional[Tag]: + """Called by the tree builder when a new tag is encountered. + + :param name: Name of the tag. + :param nsprefix: Namespace prefix for the tag. + :param attrs: A dictionary of attribute values. Note that + attribute values are expected to be simple strings; processing + of multi-valued attributes such as "class" comes later. + :param sourceline: The line number where this tag was found in its + source document. + :param sourcepos: The character position within `sourceline` where this + tag was found. + :param namespaces: A dictionary of all namespace prefix mappings + currently in scope in the document. + + If this method returns None, the tag was rejected by an active + `ElementFilter`. You should proceed as if the tag had not occurred + in the document. For instance, if this was a self-closing tag, + don't call handle_endtag. + + :meta private: + """ + # print("Start tag %s: %s" % (name, attrs)) + self.endData() + + if ( + self.parse_only + and len(self.tagStack) <= 1 + and not self.parse_only.allow_tag_creation(nsprefix, name, attrs) + ): + return None + + tag_class = self.element_classes.get(Tag, Tag) + # Assume that this is either Tag or a subclass of Tag. If not, + # the user brought type-unsafety upon themselves. + tag_class = cast(Type[Tag], tag_class) + tag = tag_class( + self, + self.builder, + name, + namespace, + nsprefix, + attrs, + self.currentTag, + self._most_recent_element, + sourceline=sourceline, + sourcepos=sourcepos, + namespaces=namespaces, + ) + if tag is None: + return tag + if self._most_recent_element is not None: + self._most_recent_element.next_element = tag + self._most_recent_element = tag + self.pushTag(tag) + return tag + + def handle_endtag(self, name: str, nsprefix: Optional[str] = None) -> None: + """Called by the tree builder when an ending tag is encountered. + + :param name: Name of the tag. + :param nsprefix: Namespace prefix for the tag. + + :meta private: + """ + # print("End tag: " + name) + self.endData() + self._popToTag(name, nsprefix) + + def handle_data(self, data: str) -> None: + """Called by the tree builder when a chunk of textual data is + encountered. + + :meta private: + """ + self.current_data.append(data) + + def decode( + self, + indent_level: Optional[int] = None, + eventual_encoding: _Encoding = DEFAULT_OUTPUT_ENCODING, + formatter: Union[Formatter, str] = "minimal", + iterator: Optional[Iterator[PageElement]] = None, + **kwargs: Any, + ) -> str: + """Returns a string representation of the parse tree + as a full HTML or XML document. + + :param indent_level: Each line of the rendering will be + indented this many levels. (The ``formatter`` decides what a + 'level' means, in terms of spaces or other characters + output.) This is used internally in recursive calls while + pretty-printing. + :param eventual_encoding: The encoding of the final document. + If this is None, the document will be a Unicode string. + :param formatter: Either a `Formatter` object, or a string naming one of + the standard formatters. + :param iterator: The iterator to use when navigating over the + parse tree. This is only used by `Tag.decode_contents` and + you probably won't need to use it. + """ + if self.is_xml: + # Print the XML declaration + encoding_part = "" + declared_encoding: Optional[str] = eventual_encoding + if eventual_encoding in PYTHON_SPECIFIC_ENCODINGS: + # This is a special Python encoding; it can't actually + # go into an XML document because it means nothing + # outside of Python. + declared_encoding = None + if declared_encoding is not None: + encoding_part = ' encoding="%s"' % declared_encoding + prefix = '\n' % encoding_part + else: + prefix = "" + + # Prior to 4.13.0, the first argument to this method was a + # bool called pretty_print, which gave the method a different + # signature from its superclass implementation, Tag.decode. + # + # The signatures of the two methods now match, but just in + # case someone is still passing a boolean in as the first + # argument to this method (or a keyword argument with the old + # name), we can handle it and put out a DeprecationWarning. + warning: Optional[str] = None + pretty_print: Optional[bool] = None + if isinstance(indent_level, bool): + if indent_level is True: + indent_level = 0 + elif indent_level is False: + indent_level = None + warning = f"As of 4.13.0, the first argument to BeautifulSoup.decode has been changed from bool to int, to match Tag.decode. Pass in a value of {indent_level} instead." + else: + pretty_print = kwargs.pop("pretty_print", None) + assert not kwargs + if pretty_print is not None: + if pretty_print is True: + indent_level = 0 + elif pretty_print is False: + indent_level = None + warning = f"As of 4.13.0, the pretty_print argument to BeautifulSoup.decode has been removed, to match Tag.decode. Pass in a value of indent_level={indent_level} instead." + + if warning: + warnings.warn(warning, DeprecationWarning, stacklevel=2) + elif indent_level is False or pretty_print is False: + indent_level = None + return prefix + super(BeautifulSoup, self).decode( + indent_level, eventual_encoding, formatter, iterator + ) + + +# Aliases to make it easier to get started quickly, e.g. 'from bs4 import _soup' +_s = BeautifulSoup +_soup = BeautifulSoup + + +class BeautifulStoneSoup(BeautifulSoup): + """Deprecated interface to an XML parser.""" + + def __init__(self, *args: Any, **kwargs: Any): + kwargs["features"] = "xml" + warnings.warn( + "The BeautifulStoneSoup class was deprecated in version 4.0.0. Instead of using " + 'it, pass features="xml" into the BeautifulSoup constructor.', + DeprecationWarning, + stacklevel=2, + ) + super(BeautifulStoneSoup, self).__init__(*args, **kwargs) + + +# If this file is run as a script, act as an HTML pretty-printer. +if __name__ == "__main__": + import sys + + soup = BeautifulSoup(sys.stdin) + print((soup.prettify())) diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..7854b4d Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/__init__.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/_deprecation.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_deprecation.cpython-310.pyc new file mode 100644 index 0000000..a62c8fd Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_deprecation.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/_typing.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_typing.cpython-310.pyc new file mode 100644 index 0000000..d4992de Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_typing.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/_warnings.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_warnings.cpython-310.pyc new file mode 100644 index 0000000..a5d574d Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/_warnings.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/css.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/css.cpython-310.pyc new file mode 100644 index 0000000..4fa9396 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/css.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/dammit.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/dammit.cpython-310.pyc new file mode 100644 index 0000000..8912163 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/dammit.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/diagnose.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/diagnose.cpython-310.pyc new file mode 100644 index 0000000..9ed0b07 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/diagnose.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/element.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/element.cpython-310.pyc new file mode 100644 index 0000000..11e5953 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/element.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/exceptions.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000..930457e Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/exceptions.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/filter.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/filter.cpython-310.pyc new file mode 100644 index 0000000..056251a Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/filter.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/__pycache__/formatter.cpython-310.pyc b/.venv/lib/python3.10/site-packages/bs4/__pycache__/formatter.cpython-310.pyc new file mode 100644 index 0000000..f344467 Binary files /dev/null and b/.venv/lib/python3.10/site-packages/bs4/__pycache__/formatter.cpython-310.pyc differ diff --git a/.venv/lib/python3.10/site-packages/bs4/_deprecation.py b/.venv/lib/python3.10/site-packages/bs4/_deprecation.py new file mode 100644 index 0000000..a7b5685 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/bs4/_deprecation.py @@ -0,0 +1,80 @@ +"""Helper functions for deprecation. + +This interface is itself unstable and may change without warning. Do +not use these functions yourself, even as a joke. The underscores are +there for a reason. No support will be given. + +In particular, most of this will go away without warning once +Beautiful Soup drops support for Python 3.11, since Python 3.12 +defines a `@typing.deprecated() +decorator. `_ +""" + +import functools +import warnings + +from typing import ( + Any, + Callable, +) + + +def _deprecated_alias(old_name: str, new_name: str, version: str): + """Alias one attribute name to another for backward compatibility + + :meta private: + """ + + @property # type:ignore + def alias(self) -> Any: + ":meta private:" + warnings.warn( + f"Access to deprecated property {old_name}. (Replaced by {new_name}) -- Deprecated since version {version}.", + DeprecationWarning, + stacklevel=2, + ) + return getattr(self, new_name) + + @alias.setter + def alias(self, value: str) -> None: + ":meta private:" + warnings.warn( + f"Write to deprecated property {old_name}. (Replaced by {new_name}) -- Deprecated since version {version}.", + DeprecationWarning, + stacklevel=2, + ) + return setattr(self, new_name, value) + + return alias + + +def _deprecated_function_alias( + old_name: str, new_name: str, version: str +) -> Callable[[Any], Any]: + def alias(self, *args: Any, **kwargs: Any) -> Any: + ":meta private:" + warnings.warn( + f"Call to deprecated method {old_name}. (Replaced by {new_name}) -- Deprecated since version {version}.", + DeprecationWarning, + stacklevel=2, + ) + return getattr(self, new_name)(*args, **kwargs) + + return alias + + +def _deprecated(replaced_by: str, version: str) -> Callable: + def deprecate(func: Callable) -> Callable: + @functools.wraps(func) + def with_warning(*args: Any, **kwargs: Any) -> Any: + ":meta private:" + warnings.warn( + f"Call to deprecated method {func.__name__}. (Replaced by {replaced_by}) -- Deprecated since version {version}.", + DeprecationWarning, + stacklevel=2, + ) + return func(*args, **kwargs) + + return with_warning + + return deprecate diff --git a/.venv/lib/python3.10/site-packages/bs4/_typing.py b/.venv/lib/python3.10/site-packages/bs4/_typing.py new file mode 100644 index 0000000..0ab69df --- /dev/null +++ b/.venv/lib/python3.10/site-packages/bs4/_typing.py @@ -0,0 +1,205 @@ +# Custom type aliases used throughout Beautiful Soup to improve readability. + +# Notes on improvements to the type system in newer versions of Python +# that can be used once Beautiful Soup drops support for older +# versions: +# +# * ClassVar can be put on class variables now. +# * In 3.10, x|y is an accepted shorthand for Union[x,y]. +# * In 3.10, TypeAlias gains capabilities that can be used to +# improve the tree matching types (I don't remember what, exactly). +# * In 3.9 it's possible to specialize the re.Match type, +# e.g. re.Match[str]. In 3.8 there's a typing.re namespace for this, +# but it's removed in 3.12, so to support the widest possible set of +# versions I'm not using it. + +from typing_extensions import ( + runtime_checkable, + Protocol, + TypeAlias, +) +from typing import ( + Any, + Callable, + Dict, + IO, + Iterable, + Mapping, + Optional, + Pattern, + TYPE_CHECKING, + Union, +) + +if TYPE_CHECKING: + from bs4.element import ( + AttributeValueList, + NamespacedAttribute, + NavigableString, + PageElement, + ResultSet, + Tag, + ) + + +@runtime_checkable +class _RegularExpressionProtocol(Protocol): + """A protocol object which can accept either Python's built-in + `re.Pattern` objects, or the similar ``Regex`` objects defined by the + third-party ``regex`` package. + """ + + def search( + self, string: str, pos: int = ..., endpos: int = ... + ) -> Optional[Any]: ... + + @property + def pattern(self) -> str: ... + + +# Aliases for markup in various stages of processing. +# +#: The rawest form of markup: either a string, bytestring, or an open filehandle. +_IncomingMarkup: TypeAlias = Union[str, bytes, IO[str], IO[bytes]] + +#: Markup that is in memory but has (potentially) yet to be converted +#: to Unicode. +_RawMarkup: TypeAlias = Union[str, bytes] + +# Aliases for character encodings +# + +#: A data encoding. +_Encoding: TypeAlias = str + +#: One or more data encodings. +_Encodings: TypeAlias = Iterable[_Encoding] + +# Aliases for XML namespaces +# + +#: The prefix for an XML namespace. +_NamespacePrefix: TypeAlias = str + +#: The URL of an XML namespace +_NamespaceURL: TypeAlias = str + +#: A mapping of prefixes to namespace URLs. +_NamespaceMapping: TypeAlias = Dict[_NamespacePrefix, _NamespaceURL] + +#: A mapping of namespace URLs to prefixes +_InvertedNamespaceMapping: TypeAlias = Dict[_NamespaceURL, _NamespacePrefix] + +# Aliases for the attribute values associated with HTML/XML tags. +# + +#: The value associated with an HTML or XML attribute. This is the +#: relatively unprocessed value Beautiful Soup expects to come from a +#: `TreeBuilder`. +_RawAttributeValue: TypeAlias = str + +#: A dictionary of names to `_RawAttributeValue` objects. This is how +#: Beautiful Soup expects a `TreeBuilder` to represent a tag's +#: attribute values. +_RawAttributeValues: TypeAlias = ( + "Mapping[Union[str, NamespacedAttribute], _RawAttributeValue]" +) + +#: An attribute value in its final form, as stored in the +# `Tag` class, after it has been processed and (in some cases) +# split into a list of strings. +_AttributeValue: TypeAlias = Union[str, "AttributeValueList"] + +#: A dictionary of names to :py:data:`_AttributeValue` objects. This is what +#: a tag's attributes look like after processing. +_AttributeValues: TypeAlias = Dict[str, _AttributeValue] + +#: The methods that deal with turning :py:data:`_RawAttributeValue` into +#: :py:data:`_AttributeValue` may be called several times, even after the values +#: are already processed (e.g. when cloning a tag), so they need to +#: be able to acommodate both possibilities. +_RawOrProcessedAttributeValues: TypeAlias = Union[_RawAttributeValues, _AttributeValues] + +#: A number of tree manipulation methods can take either a `PageElement` or a +#: normal Python string (which will be converted to a `NavigableString`). +_InsertableElement: TypeAlias = Union["PageElement", str] + +# Aliases to represent the many possibilities for matching bits of a +# parse tree. +# +# This is very complicated because we're applying a formal type system +# to some very DWIM code. The types we end up with will be the types +# of the arguments to the SoupStrainer constructor and (more +# familiarly to Beautiful Soup users) the find* methods. + +#: A function that takes a PageElement and returns a yes-or-no answer. +_PageElementMatchFunction: TypeAlias = Callable[["PageElement"], bool] + +#: A function that takes the raw parsed ingredients of a markup tag +#: and returns a yes-or-no answer. +# Not necessary at the moment. +# _AllowTagCreationFunction:TypeAlias = Callable[[Optional[str], str, Optional[_RawAttributeValues]], bool] + +#: A function that takes the raw parsed ingredients of a markup string node +#: and returns a yes-or-no answer. +# Not necessary at the moment. +# _AllowStringCreationFunction:TypeAlias = Callable[[Optional[str]], bool] + +#: A function that takes a `Tag` and returns a yes-or-no answer. +#: A `TagNameMatchRule` expects this kind of function, if you're +#: going to pass it a function. +_TagMatchFunction: TypeAlias = Callable[["Tag"], bool] + +#: A function that takes a string (or None) and returns a yes-or-no +#: answer. An `AttributeValueMatchRule` expects this kind of function, if +#: you're going to pass it a function. +_NullableStringMatchFunction: TypeAlias = Callable[[Optional[str]], bool] + +#: A function that takes a string and returns a yes-or-no answer. A +# `StringMatchRule` expects this kind of function, if you're going to +# pass it a function. +_StringMatchFunction: TypeAlias = Callable[[str], bool] + +#: Either a tag name, an attribute value or a string can be matched +#: against a string, bytestring, regular expression, or a boolean. +_BaseStrainable: TypeAlias = Union[str, bytes, Pattern[str], bool] + +#: A tag can be matched either with the `_BaseStrainable` options, or +#: using a function that takes the `Tag` as its sole argument. +_BaseStrainableElement: TypeAlias = Union[_BaseStrainable, _TagMatchFunction] + +#: A tag's attribute value can be matched either with the +#: `_BaseStrainable` options, or using a function that takes that +#: value as its sole argument. +_BaseStrainableAttribute: TypeAlias = Union[_BaseStrainable, _NullableStringMatchFunction] + +#: A tag can be matched using either a single criterion or a list of +#: criteria. +_StrainableElement: TypeAlias = Union[ + _BaseStrainableElement, Iterable[_BaseStrainableElement] +] + +#: An attribute value can be matched using either a single criterion +#: or a list of criteria. +_StrainableAttribute: TypeAlias = Union[ + _BaseStrainableAttribute, Iterable[_BaseStrainableAttribute] +] + +#: An string can be matched using the same techniques as +#: an attribute value. +_StrainableString: TypeAlias = _StrainableAttribute + +#: A dictionary may be used to match against multiple attribute vlaues at once. +_StrainableAttributes: TypeAlias = Dict[str, _StrainableAttribute] + +#: Many Beautiful soup methods return a PageElement or an ResultSet of +#: PageElements. A PageElement is either a Tag or a NavigableString. +#: These convenience aliases make it easier for IDE users to see which methods +#: are available on the objects they're dealing with. +_OneElement: TypeAlias = Union["PageElement", "Tag", "NavigableString"] +_AtMostOneElement: TypeAlias = Optional[_OneElement] +_AtMostOneTag: TypeAlias = Optional["Tag"] +_AtMostOneNavigableString: TypeAlias = Optional["NavigableString"] +_QueryResults: TypeAlias = "ResultSet[_OneElement]" +_SomeTags: TypeAlias = "ResultSet[Tag]" +_SomeNavigableStrings: TypeAlias = "ResultSet[NavigableString]" diff --git a/.venv/lib/python3.10/site-packages/bs4/_warnings.py b/.venv/lib/python3.10/site-packages/bs4/_warnings.py new file mode 100644 index 0000000..4309473 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/bs4/_warnings.py @@ -0,0 +1,98 @@ +"""Define some custom warnings.""" + + +class GuessedAtParserWarning(UserWarning): + """The warning issued when BeautifulSoup has to guess what parser to + use -- probably because no parser was specified in the constructor. + """ + + MESSAGE: str = """No parser was explicitly specified, so I'm using the best available %(markup_type)s parser for this system ("%(parser)s"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently. + +The code that caused this warning is on line %(line_number)s of the file %(filename)s. To get rid of this warning, pass the additional argument 'features="%(parser)s"' to the BeautifulSoup constructor. +""" + + +class UnusualUsageWarning(UserWarning): + """A superclass for warnings issued when Beautiful Soup sees + something that is typically the result of a mistake in the calling + code, but might be intentional on the part of the user. If it is + in fact intentional, you can filter the individual warning class + to get rid of the warning. If you don't like Beautiful Soup + second-guessing what you are doing, you can filter the + UnusualUsageWarningclass itself and get rid of these entirely. + """ + + +class MarkupResemblesLocatorWarning(UnusualUsageWarning): + """The warning issued when BeautifulSoup is given 'markup' that + actually looks like a resource locator -- a URL or a path to a file + on disk. + """ + + #: :meta private: + GENERIC_MESSAGE: str = """ + +However, if you want to parse some data that happens to look like a %(what)s, then nothing has gone wrong: you are using Beautiful Soup correctly, and this warning is spurious and can be filtered. To make this warning go away, run this code before calling the BeautifulSoup constructor: + + from bs4 import MarkupResemblesLocatorWarning + import warnings + + warnings.filterwarnings("ignore", category=MarkupResemblesLocatorWarning) + """ + + URL_MESSAGE: str = ( + """The input passed in on this line looks more like a URL than HTML or XML. + +If you meant to use Beautiful Soup to parse the web page found at a certain URL, then something has gone wrong. You should use an Python package like 'requests' to fetch the content behind the URL. Once you have the content as a string, you can feed that string into Beautiful Soup.""" + + GENERIC_MESSAGE + ) + + FILENAME_MESSAGE: str = ( + """The input passed in on this line looks more like a filename than HTML or XML. + +If you meant to use Beautiful Soup to parse the contents of a file on disk, then something has gone wrong. You should open the file first, using code like this: + + filehandle = open(your filename) + +You can then feed the open filehandle into Beautiful Soup instead of using the filename.""" + + GENERIC_MESSAGE + ) + + +class AttributeResemblesVariableWarning(UnusualUsageWarning, SyntaxWarning): + """The warning issued when Beautiful Soup suspects a provided + attribute name may actually be the misspelled name of a Beautiful + Soup variable. Generally speaking, this is only used in cases like + "_class" where it's very unlikely the user would be referencing an + XML attribute with that name. + """ + + MESSAGE: str = """%(original)r is an unusual attribute name and is a common misspelling for %(autocorrect)r. + +If you meant %(autocorrect)r, change your code to use it, and this warning will go away. + +If you really did mean to check the %(original)r attribute, this warning is spurious and can be filtered. To make it go away, run this code before creating your BeautifulSoup object: + + from bs4 import AttributeResemblesVariableWarning + import warnings + + warnings.filterwarnings("ignore", category=AttributeResemblesVariableWarning) +""" + + +class XMLParsedAsHTMLWarning(UnusualUsageWarning): + """The warning issued when an HTML parser is used to parse + XML that is not (as far as we can tell) XHTML. + """ + + MESSAGE: str = """It looks like you're using an HTML parser to parse an XML document. + +Assuming this really is an XML document, what you're doing might work, but you should know that using an XML parser will be more reliable. To parse this document as XML, make sure you have the Python package 'lxml' installed, and pass the keyword argument `features="xml"` into the BeautifulSoup constructor. + +If you want or need to use an HTML parser on this document, you can make this warning go away by filtering it. To do that, run this code before calling the BeautifulSoup constructor: + + from bs4 import XMLParsedAsHTMLWarning + import warnings + + warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning) +""" diff --git a/.venv/lib/python3.10/site-packages/bs4/builder/__init__.py b/.venv/lib/python3.10/site-packages/bs4/builder/__init__.py new file mode 100644 index 0000000..4aae4d3 --- /dev/null +++ b/.venv/lib/python3.10/site-packages/bs4/builder/__init__.py @@ -0,0 +1,848 @@ +from __future__ import annotations + +# Use of this source code is governed by the MIT license. +__license__ = "MIT" + +from collections import defaultdict +import re +from types import ModuleType +from typing import ( + Any, + cast, + Dict, + Iterable, + List, + Optional, + Pattern, + Set, + Tuple, + Type, + TYPE_CHECKING, +) +import warnings +import sys +from bs4.element import ( + AttributeDict, + AttributeValueList, + CharsetMetaAttributeValue, + ContentMetaAttributeValue, + RubyParenthesisString, + RubyTextString, + Stylesheet, + Script, + TemplateString, + nonwhitespace_re, +) + +# Exceptions were moved to their own module in 4.13. Import here for +# backwards compatibility. +from bs4.exceptions import ParserRejectedMarkup + +from bs4._typing import ( + _AttributeValues, + _RawAttributeValue, +) + +from bs4._warnings import XMLParsedAsHTMLWarning + +if TYPE_CHECKING: + from bs4 import BeautifulSoup + from bs4.element import ( + NavigableString, + Tag, + ) + from bs4._typing import ( + _AttributeValue, + _Encoding, + _Encodings, + _RawOrProcessedAttributeValues, + _RawMarkup, + ) + +__all__ = [ + "HTMLTreeBuilder", + "SAXTreeBuilder", + "TreeBuilder", + "TreeBuilderRegistry", +] + +# Some useful features for a TreeBuilder to have. +FAST = "fast" +PERMISSIVE = "permissive" +STRICT = "strict" +XML = "xml" +HTML = "html" +HTML_5 = "html5" + +__all__ = [ + "TreeBuilderRegistry", + "TreeBuilder", + "HTMLTreeBuilder", + "DetectsXMLParsedAsHTML", + + "ParserRejectedMarkup", # backwards compatibility only as of 4.13.0 +] + +class TreeBuilderRegistry(object): + """A way of looking up TreeBuilder subclasses by their name or by desired + features. + """ + + builders_for_feature: Dict[str, List[Type[TreeBuilder]]] + builders: List[Type[TreeBuilder]] + + def __init__(self) -> None: + self.builders_for_feature = defaultdict(list) + self.builders = [] + + def register(self, treebuilder_class: type[TreeBuilder]) -> None: + """Register a treebuilder based on its advertised features. + + :param treebuilder_class: A subclass of `TreeBuilder`. its + `TreeBuilder.features` attribute should list its features. + """ + for feature in treebuilder_class.features: + self.builders_for_feature[feature].insert(0, treebuilder_class) + self.builders.insert(0, treebuilder_class) + + def lookup(self, *features: str) -> Optional[Type[TreeBuilder]]: + """Look up a TreeBuilder subclass with the desired features. + + :param features: A list of features to look for. If none are + provided, the most recently registered TreeBuilder subclass + will be used. + :return: A TreeBuilder subclass, or None if there's no + registered subclass with all the requested features. + """ + if len(self.builders) == 0: + # There are no builders at all. + return None + + if len(features) == 0: + # They didn't ask for any features. Give them the most + # recently registered builder. + return self.builders[0] + + # Go down the list of features in order, and eliminate any builders + # that don't match every feature. + feature_list = list(features) + feature_list.reverse() + candidates = None + candidate_set = None + while len(feature_list) > 0: + feature = feature_list.pop() + we_have_the_feature = self.builders_for_feature.get(feature, []) + if len(we_have_the_feature) > 0: + if candidates is None: + candidates = we_have_the_feature + candidate_set = set(candidates) + elif candidate_set is not None: + # Eliminate any candidates that don't have this feature. + candidate_set = candidate_set.intersection(set(we_have_the_feature)) + + # The only valid candidates are the ones in candidate_set. + # Go through the original list of candidates and pick the first one + # that's in candidate_set. + if candidate_set is None or candidates is None: + return None + for candidate in candidates: + if candidate in candidate_set: + return candidate + return None + + +#: The `BeautifulSoup` constructor will take a list of features +#: and use it to look up `TreeBuilder` classes in this registry. +builder_registry: TreeBuilderRegistry = TreeBuilderRegistry() + + +class TreeBuilder(object): + """Turn a textual document into a Beautiful Soup object tree. + + This is an abstract superclass which smooths out the behavior of + different parser libraries into a single, unified interface. + + :param multi_valued_attributes: If this is set to None, the + TreeBuilder will not turn any values for attributes like + 'class' into lists. Setting this to a dictionary will + customize this behavior; look at :py:attr:`bs4.builder.HTMLTreeBuilder.DEFAULT_CDATA_LIST_ATTRIBUTES` + for an example. + + Internally, these are called "CDATA list attributes", but that + probably doesn't make sense to an end-user, so the argument name + is ``multi_valued_attributes``. + + :param preserve_whitespace_tags: A set of tags to treat + the way 
 tags are treated in HTML. Tags in this set
+     are immune from pretty-printing; their contents will always be
+     output as-is.
+
+    :param string_containers: A dictionary mapping tag names to
+     the classes that should be instantiated to contain the textual
+     contents of those tags. The default is to use NavigableString
+     for every tag, no matter what the name. You can override the
+     default by changing :py:attr:`DEFAULT_STRING_CONTAINERS`.
+
+    :param store_line_numbers: If the parser keeps track of the line
+     numbers and positions of the original markup, that information
+     will, by default, be stored in each corresponding
+     :py:class:`bs4.element.Tag` object. You can turn this off by
+     passing store_line_numbers=False; then Tag.sourcepos and
+     Tag.sourceline will always be None. If the parser you're using
+     doesn't keep track of this information, then store_line_numbers
+     is irrelevant.
+
+    :param attribute_dict_class: The value of a multi-valued attribute
+      (such as HTML's 'class') willl be stored in an instance of this
+      class.  The default is Beautiful Soup's built-in
+      `AttributeValueList`, which is a normal Python list, and you
+      will probably never need to change it.
+    """
+
+    USE_DEFAULT: Any = object()  #: :meta private:
+
+    def __init__(
+        self,
+        multi_valued_attributes: Dict[str, Set[str]] = USE_DEFAULT,
+        preserve_whitespace_tags: Set[str] = USE_DEFAULT,
+        store_line_numbers: bool = USE_DEFAULT,
+        string_containers: Dict[str, Type[NavigableString]] = USE_DEFAULT,
+        empty_element_tags: Set[str] = USE_DEFAULT,
+        attribute_dict_class: Type[AttributeDict] = AttributeDict,
+        attribute_value_list_class: Type[AttributeValueList] = AttributeValueList,
+    ):
+        self.soup = None
+        if multi_valued_attributes is self.USE_DEFAULT:
+            multi_valued_attributes = self.DEFAULT_CDATA_LIST_ATTRIBUTES
+        self.cdata_list_attributes = multi_valued_attributes
+        if preserve_whitespace_tags is self.USE_DEFAULT:
+            preserve_whitespace_tags = self.DEFAULT_PRESERVE_WHITESPACE_TAGS
+        self.preserve_whitespace_tags = preserve_whitespace_tags
+        if empty_element_tags is self.USE_DEFAULT:
+            self.empty_element_tags = self.DEFAULT_EMPTY_ELEMENT_TAGS
+        else:
+            self.empty_element_tags = empty_element_tags
+        # TODO: store_line_numbers is probably irrelevant now that
+        # the behavior of sourceline and sourcepos has been made consistent
+        # everywhere.
+        if store_line_numbers == self.USE_DEFAULT:
+            store_line_numbers = self.TRACKS_LINE_NUMBERS
+        self.store_line_numbers = store_line_numbers
+        if string_containers == self.USE_DEFAULT:
+            string_containers = self.DEFAULT_STRING_CONTAINERS
+        self.string_containers = string_containers
+        self.attribute_dict_class = attribute_dict_class
+        self.attribute_value_list_class = attribute_value_list_class
+
+    NAME: str = "[Unknown tree builder]"
+    ALTERNATE_NAMES: Iterable[str] = []
+    features: Iterable[str] = []
+
+    is_xml: bool = False
+    picklable: bool = False
+
+    soup: Optional[BeautifulSoup]  #: :meta private:
+
+    #: A tag will be considered an empty-element
+    #: tag when and only when it has no contents.
+    empty_element_tags: Optional[Set[str]] = None  #: :meta private:
+    cdata_list_attributes: Dict[str, Set[str]]  #: :meta private:
+    preserve_whitespace_tags: Set[str]  #: :meta private:
+    string_containers: Dict[str, Type[NavigableString]]  #: :meta private:
+    tracks_line_numbers: bool  #: :meta private:
+
+    #: A value for these tag/attribute combinations is a space- or
+    #: comma-separated list of CDATA, rather than a single CDATA.
+    DEFAULT_CDATA_LIST_ATTRIBUTES: Dict[str, Set[str]] = defaultdict(set)
+
+    #: Whitespace should be preserved inside these tags.
+    DEFAULT_PRESERVE_WHITESPACE_TAGS: Set[str] = set()
+
+    #: The textual contents of tags with these names should be
+    #: instantiated with some class other than `bs4.element.NavigableString`.
+    DEFAULT_STRING_CONTAINERS: Dict[str, Type[bs4.element.NavigableString]] = {} # type:ignore
+
+    #: By default, tags are treated as empty-element tags if they have
+    #: no contents--that is, using XML rules. HTMLTreeBuilder
+    #: defines a different set of DEFAULT_EMPTY_ELEMENT_TAGS based on the
+    #: HTML 4 and HTML5 standards.
+    DEFAULT_EMPTY_ELEMENT_TAGS: Optional[Set[str]] = None
+
+    #: Most parsers don't keep track of line numbers.
+    TRACKS_LINE_NUMBERS: bool = False
+
+    def initialize_soup(self, soup: BeautifulSoup) -> None:
+        """The BeautifulSoup object has been initialized and is now
+        being associated with the TreeBuilder.
+
+        :param soup: A BeautifulSoup object.
+        """
+        self.soup = soup
+
+    def reset(self) -> None:
+        """Do any work necessary to reset the underlying parser
+        for a new document.
+
+        By default, this does nothing.
+        """
+        pass
+
+    def can_be_empty_element(self, tag_name: str) -> bool:
+        """Might a tag with this name be an empty-element tag?
+
+        The final markup may or may not actually present this tag as
+        self-closing.
+
+        For instance: an HTMLBuilder does not consider a 
 tag to be
+        an empty-element tag (it's not in
+        HTMLBuilder.empty_element_tags). This means an empty 
 tag
+        will be presented as "
", not "
" or "
".
+
+        The default implementation has no opinion about which tags are
+        empty-element tags, so a tag will be presented as an
+        empty-element tag if and only if it has no children.
+        "" will become "", and "bar" will
+        be left alone.
+
+        :param tag_name: The name of a markup tag.
+        """
+        if self.empty_element_tags is None:
+            return True
+        return tag_name in self.empty_element_tags
+
+    def feed(self, markup: _RawMarkup) -> None:
+        """Run incoming markup through some parsing process."""
+        raise NotImplementedError()
+
+    def prepare_markup(
+        self,
+        markup: _RawMarkup,
+        user_specified_encoding: Optional[_Encoding] = None,
+        document_declared_encoding: Optional[_Encoding] = None,
+        exclude_encodings: Optional[_Encodings] = None,
+    ) -> Iterable[Tuple[_RawMarkup, Optional[_Encoding], Optional[_Encoding], bool]]:
+        """Run any preliminary steps necessary to make incoming markup
+        acceptable to the parser.
+
+        :param markup: The markup that's about to be parsed.
+        :param user_specified_encoding: The user asked to try this encoding
+           to convert the markup into a Unicode string.
+        :param document_declared_encoding: The markup itself claims to be
+            in this encoding. NOTE: This argument is not used by the
+            calling code and can probably be removed.
+        :param exclude_encodings: The user asked *not* to try any of
+            these encodings.
+
+        :yield: A series of 4-tuples: (markup, encoding, declared encoding,
+            has undergone character replacement)
+
+            Each 4-tuple represents a strategy that the parser can try
+            to convert the document to Unicode and parse it. Each
+            strategy will be tried in turn.
+
+         By default, the only strategy is to parse the markup
+         as-is. See `LXMLTreeBuilderForXML` and
+         `HTMLParserTreeBuilder` for implementations that take into
+         account the quirks of particular parsers.
+
+        :meta private:
+
+        """
+        yield markup, None, None, False
+
+    def test_fragment_to_document(self, fragment: str) -> str:
+        """Wrap an HTML fragment to make it look like a document.
+
+        Different parsers do this differently. For instance, lxml
+        introduces an empty  tag, and html5lib
+        doesn't. Abstracting this away lets us write simple tests
+        which run HTML fragments through the parser and compare the
+        results against other HTML fragments.
+
+        This method should not be used outside of unit tests.
+
+        :param fragment: A fragment of HTML.
+        :return: A full HTML document.
+        :meta private:
+        """
+        return fragment
+
+    def set_up_substitutions(self, tag: Tag) -> bool:
+        """Set up any substitutions that will need to be performed on
+        a `Tag` when it's output as a string.
+
+        By default, this does nothing. See `HTMLTreeBuilder` for a
+        case where this is used.
+
+        :return: Whether or not a substitution was performed.
+        :meta private:
+        """
+        return False
+
+    def _replace_cdata_list_attribute_values(
+        self, tag_name: str, attrs: _RawOrProcessedAttributeValues
+    ) -> _AttributeValues:
+        """When an attribute value is associated with a tag that can
+        have multiple values for that attribute, convert the string
+        value to a list of strings.
+
+        Basically, replaces class="foo bar" with class=["foo", "bar"]
+
+        NOTE: This method modifies its input in place.
+
+        :param tag_name: The name of a tag.
+        :param attrs: A dictionary containing the tag's attributes.
+           Any appropriate attribute values will be modified in place.
+        :return: The modified dictionary that was originally passed in.
+        """
+
+        # First, cast the attrs dict to _AttributeValues. This might
+        # not be accurate yet, but it will be by the time this method
+        # returns.
+        modified_attrs = cast(_AttributeValues, attrs)
+        if not modified_attrs or not self.cdata_list_attributes:
+            # Nothing to do.
+            return modified_attrs
+
+        # There is at least a possibility that we need to modify one of
+        # the attribute values.
+        universal: Set[str] = self.cdata_list_attributes.get("*", set())
+        tag_specific = self.cdata_list_attributes.get(tag_name.lower(), None)
+        for attr in list(modified_attrs.keys()):
+            modified_value: _AttributeValue
+            if attr in universal or (tag_specific and attr in tag_specific):
+                # We have a "class"-type attribute whose string
+                # value is a whitespace-separated list of
+                # values. Split it into a list.
+                original_value: _AttributeValue = modified_attrs[attr]
+                if isinstance(original_value, _RawAttributeValue):
+                    # This is a _RawAttributeValue (a string) that
+                    # needs to be split and converted to a
+                    # AttributeValueList so it can be an
+                    # _AttributeValue.
+                    modified_value = self.attribute_value_list_class(
+                        nonwhitespace_re.findall(original_value)
+                    )
+                else:
+                    # html5lib calls setAttributes twice for the
+                    # same tag when rearranging the parse tree. On
+                    # the second call the attribute value here is
+                    # already a list. This can also happen when a
+                    # Tag object is cloned. If this happens, leave
+                    # the value alone rather than trying to split
+                    # it again.
+                    modified_value = original_value
+                modified_attrs[attr] = modified_value
+        return modified_attrs
+
+
+class SAXTreeBuilder(TreeBuilder):
+    """A Beautiful Soup treebuilder that listens for SAX events.
+
+    This is not currently used for anything, and it will be removed
+    soon. It was a good idea, but it wasn't properly integrated into the
+    rest of Beautiful Soup, so there have been long stretches where it
+    hasn't worked properly.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        warnings.warn(
+            "The SAXTreeBuilder class was deprecated in 4.13.0 and will be removed soon thereafter. It is completely untested and probably doesn't work; do not use it.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super(SAXTreeBuilder, self).__init__(*args, **kwargs)
+
+    def feed(self, markup: _RawMarkup) -> None:
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        pass
+
+    def startElement(self, name: str, attrs: Dict[str, str]) -> None:
+        attrs = AttributeDict((key[1], value) for key, value in list(attrs.items()))
+        # print("Start %s, %r" % (name, attrs))
+        assert self.soup is not None
+        self.soup.handle_starttag(name, None, None, attrs)
+
+    def endElement(self, name: str) -> None:
+        # print("End %s" % name)
+        assert self.soup is not None
+        self.soup.handle_endtag(name)
+
+    def startElementNS(
+        self, nsTuple: Tuple[str, str], nodeName: str, attrs: Dict[str, str]
+    ) -> None:
+        # Throw away (ns, nodeName) for now.
+        self.startElement(nodeName, attrs)
+
+    def endElementNS(self, nsTuple: Tuple[str, str], nodeName: str) -> None:
+        # Throw away (ns, nodeName) for now.
+        self.endElement(nodeName)
+        # handler.endElementNS((ns, node.nodeName), node.nodeName)
+
+    def startPrefixMapping(self, prefix: str, nodeValue: str) -> None:
+        # Ignore the prefix for now.
+        pass
+
+    def endPrefixMapping(self, prefix: str) -> None:
+        # Ignore the prefix for now.
+        # handler.endPrefixMapping(prefix)
+        pass
+
+    def characters(self, content: str) -> None:
+        assert self.soup is not None
+        self.soup.handle_data(content)
+
+    def startDocument(self) -> None:
+        pass
+
+    def endDocument(self) -> None:
+        pass
+
+
+class HTMLTreeBuilder(TreeBuilder):
+    """This TreeBuilder knows facts about HTML, such as which tags are treated
+    specially by the HTML standard.
+    """
+
+    #: Some HTML tags are defined as having no contents. Beautiful Soup
+    #: treats these specially.
+    DEFAULT_EMPTY_ELEMENT_TAGS: Optional[Set[str]] = set(
+        [
+            # These are from HTML5.
+            "area",
+            "base",
+            "br",
+            "col",
+            "embed",
+            "hr",
+            "img",
+            "input",
+            "keygen",
+            "link",
+            "menuitem",
+            "meta",
+            "param",
+            "source",
+            "track",
+            "wbr",
+            # These are from earlier versions of HTML and are removed in HTML5.
+            "basefont",
+            "bgsound",
+            "command",
+            "frame",
+            "image",
+            "isindex",
+            "nextid",
+            "spacer",
+        ]
+    )
+
+    #: The HTML standard defines these tags as block-level elements. Beautiful
+    #: Soup does not treat these elements differently from other elements,
+    #: but it may do so eventually, and this information is available if
+    #: you need to use it.
+    DEFAULT_BLOCK_ELEMENTS: Set[str] = set(
+        [
+            "address",
+            "article",
+            "aside",
+            "blockquote",
+            "canvas",
+            "dd",
+            "div",
+            "dl",
+            "dt",
+            "fieldset",
+            "figcaption",
+            "figure",
+            "footer",
+            "form",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "header",
+            "hr",
+            "li",
+            "main",
+            "nav",
+            "noscript",
+            "ol",
+            "output",
+            "p",
+            "pre",
+            "section",
+            "table",
+            "tfoot",
+            "ul",
+            "video",
+        ]
+    )
+
+    #: These HTML tags need special treatment so they can be
+    #: represented by a string class other than `bs4.element.NavigableString`.
+    #:
+    #: For some of these tags, it's because the HTML standard defines
+    #: an unusual content model for them. I made this list by going
+    #: through the HTML spec
+    #: (https://html.spec.whatwg.org/#metadata-content) and looking for
+    #: "metadata content" elements that can contain strings.
+    #:
+    #: The Ruby tags ( and ) are here despite being normal
+    #: "phrasing content" tags, because the content they contain is
+    #: qualitatively different from other text in the document, and it
+    #: can be useful to be able to distinguish it.
+    #:
+    #: TODO: Arguably 

+  HTTPX
+

+
+
HTTPX - A next-generation HTTP client for Python.

+
+

+
+    Test Suite
+
+
+    Package version
+
+

+
+HTTPX is a fully featured HTTP client library for Python 3. It includes **an integrated command line client**, has support for both **HTTP/1.1 and HTTP/2**, and provides both **sync and async APIs**.
+
+---
+
+Install HTTPX using pip:
+
+```shell
+$ pip install httpx
+```
+
+Now, let's get started:
+
+```pycon
+>>> import httpx
+>>> r = httpx.get('https://www.example.org/')
+>>> r
+
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'text/html; charset=UTF-8'
+>>> r.text
+'\n\n\nExample Domain...'
+```
+
+Or, using the command-line client.
+
+```shell
+$ pip install 'httpx[cli]'  # The command line client is an optional dependency.
+```
+
+Which now allows us to use HTTPX directly from the command-line...
+
+

+  httpx --help
+

+
+Sending a request...
+
+

+  httpx http://httpbin.org/json
+

+
+## Features
+
+HTTPX builds on the well-established usability of `requests`, and gives you:
+
+* A broadly [requests-compatible API](https://www.python-httpx.org/compatibility/).
+* An integrated command-line client.
+* HTTP/1.1 [and HTTP/2 support](https://www.python-httpx.org/http2/).
+* Standard synchronous interface, but with [async support if you need it](https://www.python-httpx.org/async/).
+* Ability to make requests directly to [WSGI applications](https://www.python-httpx.org/advanced/transports/#wsgi-transport) or [ASGI applications](https://www.python-httpx.org/advanced/transports/#asgi-transport).
+* Strict timeouts everywhere.
+* Fully type annotated.
+* 100% test coverage.
+
+Plus all the standard features of `requests`...
+
+* International Domains and URLs
+* Keep-Alive & Connection Pooling
+* Sessions with Cookie Persistence
+* Browser-style SSL Verification
+* Basic/Digest Authentication
+* Elegant Key/Value Cookies
+* Automatic Decompression
+* Automatic Content Decoding
+* Unicode Response Bodies
+* Multipart File Uploads
+* HTTP(S) Proxy Support
+* Connection Timeouts
+* Streaming Downloads
+* .netrc Support
+* Chunked Requests
+
+## Installation
+
+Install with pip:
+
+```shell
+$ pip install httpx
+```
+
+Or, to include the optional HTTP/2 support, use:
+
+```shell
+$ pip install httpx[http2]
+```
+
+HTTPX requires Python 3.8+.
+
+## Documentation
+
+Project documentation is available at [https://www.python-httpx.org/](https://www.python-httpx.org/).
+
+For a run-through of all the basics, head over to the [QuickStart](https://www.python-httpx.org/quickstart/).
+
+For more advanced topics, see the [Advanced Usage](https://www.python-httpx.org/advanced/) section, the [async support](https://www.python-httpx.org/async/) section, or the [HTTP/2](https://www.python-httpx.org/http2/) section.
+
+The [Developer Interface](https://www.python-httpx.org/api/) provides a comprehensive API reference.
+
+To find out about tools that integrate with HTTPX, see [Third Party Packages](https://www.python-httpx.org/third_party_packages/).
+
+## Contribute
+
+If you want to contribute with HTTPX check out the [Contributing Guide](https://www.python-httpx.org/contributing/) to learn how to start.
+
+## Dependencies
+
+The HTTPX project relies on these excellent libraries:
+
+* `httpcore` - The underlying transport implementation for `httpx`.
+  * `h11` - HTTP/1.1 support.
+* `certifi` - SSL certificates.
+* `idna` - Internationalized domain name support.
+* `sniffio` - Async library autodetection.
+
+As well as these optional installs:
+
+* `h2` - HTTP/2 support. *(Optional, with `httpx[http2]`)*
+* `socksio` - SOCKS proxy support. *(Optional, with `httpx[socks]`)*
+* `rich` - Rich terminal support. *(Optional, with `httpx[cli]`)*
+* `click` - Command line client support. *(Optional, with `httpx[cli]`)*
+* `brotli` or `brotlicffi` - Decoding for "brotli" compressed responses. *(Optional, with `httpx[brotli]`)*
+* `zstandard` - Decoding for "zstd" compressed responses. *(Optional, with `httpx[zstd]`)*
+
+A huge amount of credit is due to `requests` for the API layout that
+much of this work follows, as well as to `urllib3` for plenty of design
+inspiration around the lower-level networking details.
+
+---
+
+
HTTPX is BSD licensed code.
Designed & crafted with care.
— 🦋 —

+
+## Release Information
+
+### Fixed
+
+* Reintroduced supposedly-private `URLTypes` shortcut. (#2673)
+
+
+---
+
+[Full changelog](https://github.com/encode/httpx/blob/master/CHANGELOG.md)
diff --git a/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/RECORD b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/RECORD
new file mode 100644
index 0000000..6a45bb9
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/RECORD
@@ -0,0 +1,54 @@
+../../../bin/httpx,sha256=HtE632UzWio8Nhq-6ZBs4nzSZzIGDCyYChz4Fs2Gezo,177
+httpx-0.28.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+httpx-0.28.1.dist-info/METADATA,sha256=_rubD48-gNV8gZnDBPNcQzboWB0dGNeYPJJ2a4J5OyU,7052
+httpx-0.28.1.dist-info/RECORD,,
+httpx-0.28.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+httpx-0.28.1.dist-info/entry_points.txt,sha256=2lVkdQmxLA1pNMgSN2eV89o90HCZezhmNwsy6ryKDSA,37
+httpx-0.28.1.dist-info/licenses/LICENSE.md,sha256=TsWdVE8StfU5o6cW_TIaxYzNgDC0ZSIfLIgCAM3yjY0,1508
+httpx/__init__.py,sha256=CsaZe6yZj0rHg6322AWKWHGTMVr9txgEfD5P3_Rrz60,2171
+httpx/__pycache__/__init__.cpython-310.pyc,,
+httpx/__pycache__/__version__.cpython-310.pyc,,
+httpx/__pycache__/_api.cpython-310.pyc,,
+httpx/__pycache__/_auth.cpython-310.pyc,,
+httpx/__pycache__/_client.cpython-310.pyc,,
+httpx/__pycache__/_config.cpython-310.pyc,,
+httpx/__pycache__/_content.cpython-310.pyc,,
+httpx/__pycache__/_decoders.cpython-310.pyc,,
+httpx/__pycache__/_exceptions.cpython-310.pyc,,
+httpx/__pycache__/_main.cpython-310.pyc,,
+httpx/__pycache__/_models.cpython-310.pyc,,
+httpx/__pycache__/_multipart.cpython-310.pyc,,
+httpx/__pycache__/_status_codes.cpython-310.pyc,,
+httpx/__pycache__/_types.cpython-310.pyc,,
+httpx/__pycache__/_urlparse.cpython-310.pyc,,
+httpx/__pycache__/_urls.cpython-310.pyc,,
+httpx/__pycache__/_utils.cpython-310.pyc,,
+httpx/__version__.py,sha256=LoUyYeOXTieGzuP_64UL0wxdtxjuu_QbOvE7NOg-IqU,108
+httpx/_api.py,sha256=r_Zgs4jIpcPJLqK5dbbSayqo_iVMKFaxZCd-oOHxLEs,11743
+httpx/_auth.py,sha256=Yr3QwaUSK17rGYx-7j-FdicFIzz4Y9FFV-1F4-7RXX4,11891
+httpx/_client.py,sha256=xD-UG67-WMkeltAAOeGGj-cZ2RRTAm19sWRxlFY7_40,65714
+httpx/_config.py,sha256=pPp2U-wicfcKsF-KYRE1LYdt3e6ERGeIoXZ8Gjo3LWc,8547
+httpx/_content.py,sha256=LGGzrJTR3OvN4Mb1GVVNLXkXJH-6oKlwAttO9p5w_yg,8161
+httpx/_decoders.py,sha256=p0dX8I0NEHexs3UGp4SsZutiMhsXrrWl6-GnqVb0iKM,12041
+httpx/_exceptions.py,sha256=bxW7fxzgVMAdNTbwT0Vnq04gJDW1_gI_GFiQPuMyjL0,8527
+httpx/_main.py,sha256=Cg9GMabiTT_swaDfUgIRitSwxLRMSwUDOm7LdSGqlA4,15626
+httpx/_models.py,sha256=4__Guyv1gLxuZChwim8kfQNiIOcJ9acreFOSurvZfms,44700
+httpx/_multipart.py,sha256=KOHEZZl6oohg9mPaKyyu345qq1rJLg35TUG3YAzXB3Y,9843
+httpx/_status_codes.py,sha256=DYn-2ufBgMeXy5s8x3_TB7wjAuAAMewTakPrm5rXEsc,5639
+httpx/_transports/__init__.py,sha256=GbUoBSAOp7z-l-9j5YhMhR3DMIcn6FVLhj072O3Nnno,275
+httpx/_transports/__pycache__/__init__.cpython-310.pyc,,
+httpx/_transports/__pycache__/asgi.cpython-310.pyc,,
+httpx/_transports/__pycache__/base.cpython-310.pyc,,
+httpx/_transports/__pycache__/default.cpython-310.pyc,,
+httpx/_transports/__pycache__/mock.cpython-310.pyc,,
+httpx/_transports/__pycache__/wsgi.cpython-310.pyc,,
+httpx/_transports/asgi.py,sha256=HRfiDYMPt4wQH2gFgHZg4c-i3sblo6bL5GTqcET-xz8,5501
+httpx/_transports/base.py,sha256=kZS_VMbViYfF570pogUCJ1bulz-ybfL51Pqs9yktebU,2523
+httpx/_transports/default.py,sha256=AzeaRUyVwCccTyyNJexDf0n1dFfzzydpdIQgvw7PLnk,13983
+httpx/_transports/mock.py,sha256=PTo0d567RITXxGrki6kN7_67wwAxfwiMDcuXJiZCjEo,1232
+httpx/_transports/wsgi.py,sha256=NcPX3Xap_EwCFZWO_OaSyQNuInCYx1QMNbO8GAei6jY,4825
+httpx/_types.py,sha256=Jyh41GQq7AOev8IOWKDAg7zCbvHAfufmW5g_PiTtErY,2965
+httpx/_urlparse.py,sha256=ZAmH47ONfkxrrj-PPYhGeiHjb6AjKCS-ANWIN4OL_KY,18546
+httpx/_urls.py,sha256=dX99VR1DSOHpgo9Aq7PzYO4FKdxqKjwyNp8grf8dHN0,21550
+httpx/_utils.py,sha256=_TVeqAKvxJkKHdz7dFeb4s0LZqQXgeFkXSgfiHBK_1o,8285
+httpx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/WHEEL
new file mode 100644
index 0000000..21aaa72
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/entry_points.txt b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/entry_points.txt
new file mode 100644
index 0000000..8ae9600
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+httpx = httpx:main
diff --git a/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/licenses/LICENSE.md b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/licenses/LICENSE.md
new file mode 100644
index 0000000..ab79d16
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx-0.28.1.dist-info/licenses/LICENSE.md
@@ -0,0 +1,12 @@
+Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* 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.
+
+* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.venv/lib/python3.10/site-packages/httpx/__init__.py b/.venv/lib/python3.10/site-packages/httpx/__init__.py
new file mode 100644
index 0000000..e9addde
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/__init__.py
@@ -0,0 +1,105 @@
+from .__version__ import __description__, __title__, __version__
+from ._api import *
+from ._auth import *
+from ._client import *
+from ._config import *
+from ._content import *
+from ._exceptions import *
+from ._models import *
+from ._status_codes import *
+from ._transports import *
+from ._types import *
+from ._urls import *
+
+try:
+    from ._main import main
+except ImportError:  # pragma: no cover
+
+    def main() -> None:  # type: ignore
+        import sys
+
+        print(
+            "The httpx command line client could not run because the required "
+            "dependencies were not installed.\nMake sure you've installed "
+            "everything with: pip install 'httpx[cli]'"
+        )
+        sys.exit(1)
+
+
+__all__ = [
+    "__description__",
+    "__title__",
+    "__version__",
+    "ASGITransport",
+    "AsyncBaseTransport",
+    "AsyncByteStream",
+    "AsyncClient",
+    "AsyncHTTPTransport",
+    "Auth",
+    "BaseTransport",
+    "BasicAuth",
+    "ByteStream",
+    "Client",
+    "CloseError",
+    "codes",
+    "ConnectError",
+    "ConnectTimeout",
+    "CookieConflict",
+    "Cookies",
+    "create_ssl_context",
+    "DecodingError",
+    "delete",
+    "DigestAuth",
+    "get",
+    "head",
+    "Headers",
+    "HTTPError",
+    "HTTPStatusError",
+    "HTTPTransport",
+    "InvalidURL",
+    "Limits",
+    "LocalProtocolError",
+    "main",
+    "MockTransport",
+    "NetRCAuth",
+    "NetworkError",
+    "options",
+    "patch",
+    "PoolTimeout",
+    "post",
+    "ProtocolError",
+    "Proxy",
+    "ProxyError",
+    "put",
+    "QueryParams",
+    "ReadError",
+    "ReadTimeout",
+    "RemoteProtocolError",
+    "request",
+    "Request",
+    "RequestError",
+    "RequestNotRead",
+    "Response",
+    "ResponseNotRead",
+    "stream",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "SyncByteStream",
+    "Timeout",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "UnsupportedProtocol",
+    "URL",
+    "USE_CLIENT_DEFAULT",
+    "WriteError",
+    "WriteTimeout",
+    "WSGITransport",
+]
+
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "httpx")  # noqa
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..924689d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/__init__.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/__version__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/__version__.cpython-310.pyc
new file mode 100644
index 0000000..e739aa4
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/__version__.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_api.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_api.cpython-310.pyc
new file mode 100644
index 0000000..b62114b
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_api.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_auth.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_auth.cpython-310.pyc
new file mode 100644
index 0000000..c702118
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_auth.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_client.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_client.cpython-310.pyc
new file mode 100644
index 0000000..471867a
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_client.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_config.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_config.cpython-310.pyc
new file mode 100644
index 0000000..1676c06
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_config.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_content.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_content.cpython-310.pyc
new file mode 100644
index 0000000..2990652
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_content.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_decoders.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_decoders.cpython-310.pyc
new file mode 100644
index 0000000..19715c9
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_decoders.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_exceptions.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_exceptions.cpython-310.pyc
new file mode 100644
index 0000000..edbb1b4
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_exceptions.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_main.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_main.cpython-310.pyc
new file mode 100644
index 0000000..885b9aa
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_main.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_models.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_models.cpython-310.pyc
new file mode 100644
index 0000000..d9c176a
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_models.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_multipart.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_multipart.cpython-310.pyc
new file mode 100644
index 0000000..011b717
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_multipart.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_status_codes.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_status_codes.cpython-310.pyc
new file mode 100644
index 0000000..431e64f
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_status_codes.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_types.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_types.cpython-310.pyc
new file mode 100644
index 0000000..4caa17d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_types.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urlparse.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urlparse.cpython-310.pyc
new file mode 100644
index 0000000..014442d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urlparse.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urls.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urls.cpython-310.pyc
new file mode 100644
index 0000000..f13f94a
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_urls.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__pycache__/_utils.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_utils.cpython-310.pyc
new file mode 100644
index 0000000..56e13c3
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/__pycache__/_utils.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/__version__.py b/.venv/lib/python3.10/site-packages/httpx/__version__.py
new file mode 100644
index 0000000..801bfac
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/__version__.py
@@ -0,0 +1,3 @@
+__title__ = "httpx"
+__description__ = "A next generation HTTP client, for Python 3."
+__version__ = "0.28.1"
diff --git a/.venv/lib/python3.10/site-packages/httpx/_api.py b/.venv/lib/python3.10/site-packages/httpx/_api.py
new file mode 100644
index 0000000..c3cda1e
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_api.py
@@ -0,0 +1,438 @@
+from __future__ import annotations
+
+import typing
+from contextlib import contextmanager
+
+from ._client import Client
+from ._config import DEFAULT_TIMEOUT_CONFIG
+from ._models import Response
+from ._types import (
+    AuthTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxyTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    TimeoutTypes,
+)
+from ._urls import URL
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+
+__all__ = [
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "request",
+    "stream",
+]
+
+
+def request(
+    method: str,
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends an HTTP request.
+
+    **Parameters:**
+
+    * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`,
+    `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`.
+    * **url** - URL for the new `Request` object.
+    * **params** - *(optional)* Query parameters to include in the URL, as a
+    string, dictionary, or sequence of two-tuples.
+    * **content** - *(optional)* Binary content to include in the body of the
+    request, as bytes or a byte iterator.
+    * **data** - *(optional)* Form data to include in the body of the request,
+    as a dictionary.
+    * **files** - *(optional)* A dictionary of upload files to include in the
+    body of the request.
+    * **json** - *(optional)* A JSON serializable object to include in the body
+    of the request.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include in the
+    request.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include in the
+    request.
+    * **auth** - *(optional)* An authentication class to use when sending the
+    request.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    the request.
+    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+
+    **Returns:** `Response`
+
+    Usage:
+
+    ```
+    >>> import httpx
+    >>> response = httpx.request('GET', 'https://httpbin.org/get')
+    >>> response
+    
+    ```
+    """
+    with Client(
+        cookies=cookies,
+        proxy=proxy,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        return client.request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        )
+
+
+@contextmanager
+def stream(
+    method: str,
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> typing.Iterator[Response]:
+    """
+    Alternative to `httpx.request()` that streams the response body
+    instead of loading it into memory at once.
+
+    **Parameters**: See `httpx.request`.
+
+    See also: [Streaming Responses][0]
+
+    [0]: /quickstart#streaming-responses
+    """
+    with Client(
+        cookies=cookies,
+        proxy=proxy,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        with client.stream(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        ) as response:
+            yield response
+
+
+def get(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `GET` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `GET` requests should not include a request body.
+    """
+    return request(
+        "GET",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def options(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends an `OPTIONS` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `OPTIONS` requests should not include a request body.
+    """
+    return request(
+        "OPTIONS",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def head(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `HEAD` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `HEAD` requests should not include a request body.
+    """
+    return request(
+        "HEAD",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def post(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `POST` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "POST",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def put(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PUT` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "PUT",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def patch(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PATCH` request.
+
+    **Parameters**: See `httpx.request`.
+    """
+    return request(
+        "PATCH",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def delete(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `DELETE` request.
+
+    **Parameters**: See `httpx.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `DELETE` requests should not include a request body.
+    """
+    return request(
+        "DELETE",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
diff --git a/.venv/lib/python3.10/site-packages/httpx/_auth.py b/.venv/lib/python3.10/site-packages/httpx/_auth.py
new file mode 100644
index 0000000..b03971a
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_auth.py
@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import time
+import typing
+from base64 import b64encode
+from urllib.request import parse_http_list
+
+from ._exceptions import ProtocolError
+from ._models import Cookies, Request, Response
+from ._utils import to_bytes, to_str, unquote
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from hashlib import _Hash
+
+
+__all__ = ["Auth", "BasicAuth", "DigestAuth", "NetRCAuth"]
+
+
+class Auth:
+    """
+    Base class for all authentication schemes.
+
+    To implement a custom authentication scheme, subclass `Auth` and override
+    the `.auth_flow()` method.
+
+    If the authentication scheme does I/O such as disk access or network calls, or uses
+    synchronization primitives such as locks, you should override `.sync_auth_flow()`
+    and/or `.async_auth_flow()` instead of `.auth_flow()` to provide specialized
+    implementations that will be used by `Client` and `AsyncClient` respectively.
+    """
+
+    requires_request_body = False
+    requires_response_body = False
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow.
+
+        To dispatch a request, `yield` it:
+
+        ```
+        yield request
+        ```
+
+        The client will `.send()` the response back into the flow generator. You can
+        access it like so:
+
+        ```
+        response = yield request
+        ```
+
+        A `return` (or reaching the end of the generator) will result in the
+        client returning the last response obtained from the server.
+
+        You can dispatch as many requests as is necessary.
+        """
+        yield request
+
+    def sync_auth_flow(
+        self, request: Request
+    ) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow synchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            request.read()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                response.read()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+    async def async_auth_flow(
+        self, request: Request
+    ) -> typing.AsyncGenerator[Request, Response]:
+        """
+        Execute the authentication flow asynchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            await request.aread()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                await response.aread()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+
+class FunctionAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a simple callable function,
+    that takes the request, and returns a new, modified request.
+    """
+
+    def __init__(self, func: typing.Callable[[Request], Request]) -> None:
+        self._func = func
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        yield self._func(request)
+
+
+class BasicAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a (username, password) pair,
+    and uses HTTP Basic authentication.
+    """
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        self._auth_header = self._build_auth_header(username, password)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        request.headers["Authorization"] = self._auth_header
+        yield request
+
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class NetRCAuth(Auth):
+    """
+    Use a 'netrc' file to lookup basic auth credentials based on the url host.
+    """
+
+    def __init__(self, file: str | None = None) -> None:
+        # Lazily import 'netrc'.
+        # There's no need for us to load this module unless 'NetRCAuth' is being used.
+        import netrc
+
+        self._netrc_info = netrc.netrc(file)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        auth_info = self._netrc_info.authenticators(request.url.host)
+        if auth_info is None or not auth_info[2]:
+            # The netrc file did not have authentication credentials for this host.
+            yield request
+        else:
+            # Build a basic auth header with credentials from the netrc file.
+            request.headers["Authorization"] = self._build_auth_header(
+                username=auth_info[0], password=auth_info[2]
+            )
+            yield request
+
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class DigestAuth(Auth):
+    _ALGORITHM_TO_HASH_FUNCTION: dict[str, typing.Callable[[bytes], _Hash]] = {
+        "MD5": hashlib.md5,
+        "MD5-SESS": hashlib.md5,
+        "SHA": hashlib.sha1,
+        "SHA-SESS": hashlib.sha1,
+        "SHA-256": hashlib.sha256,
+        "SHA-256-SESS": hashlib.sha256,
+        "SHA-512": hashlib.sha512,
+        "SHA-512-SESS": hashlib.sha512,
+    }
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        self._username = to_bytes(username)
+        self._password = to_bytes(password)
+        self._last_challenge: _DigestAuthChallenge | None = None
+        self._nonce_count = 1
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        if self._last_challenge:
+            request.headers["Authorization"] = self._build_auth_header(
+                request, self._last_challenge
+            )
+
+        response = yield request
+
+        if response.status_code != 401 or "www-authenticate" not in response.headers:
+            # If the response is not a 401 then we don't
+            # need to build an authenticated request.
+            return
+
+        for auth_header in response.headers.get_list("www-authenticate"):
+            if auth_header.lower().startswith("digest "):
+                break
+        else:
+            # If the response does not include a 'WWW-Authenticate: Digest ...'
+            # header, then we don't need to build an authenticated request.
+            return
+
+        self._last_challenge = self._parse_challenge(request, response, auth_header)
+        self._nonce_count = 1
+
+        request.headers["Authorization"] = self._build_auth_header(
+            request, self._last_challenge
+        )
+        if response.cookies:
+            Cookies(response.cookies).set_cookie_header(request=request)
+        yield request
+
+    def _parse_challenge(
+        self, request: Request, response: Response, auth_header: str
+    ) -> _DigestAuthChallenge:
+        """
+        Returns a challenge from a Digest WWW-Authenticate header.
+        These take the form of:
+        `Digest realm="realm@host.com",qop="auth,auth-int",nonce="abc",opaque="xyz"`
+        """
+        scheme, _, fields = auth_header.partition(" ")
+
+        # This method should only ever have been called with a Digest auth header.
+        assert scheme.lower() == "digest"
+
+        header_dict: dict[str, str] = {}
+        for field in parse_http_list(fields):
+            key, value = field.strip().split("=", 1)
+            header_dict[key] = unquote(value)
+
+        try:
+            realm = header_dict["realm"].encode()
+            nonce = header_dict["nonce"].encode()
+            algorithm = header_dict.get("algorithm", "MD5")
+            opaque = header_dict["opaque"].encode() if "opaque" in header_dict else None
+            qop = header_dict["qop"].encode() if "qop" in header_dict else None
+            return _DigestAuthChallenge(
+                realm=realm, nonce=nonce, algorithm=algorithm, opaque=opaque, qop=qop
+            )
+        except KeyError as exc:
+            message = "Malformed Digest WWW-Authenticate header"
+            raise ProtocolError(message, request=request) from exc
+
+    def _build_auth_header(
+        self, request: Request, challenge: _DigestAuthChallenge
+    ) -> str:
+        hash_func = self._ALGORITHM_TO_HASH_FUNCTION[challenge.algorithm.upper()]
+
+        def digest(data: bytes) -> bytes:
+            return hash_func(data).hexdigest().encode()
+
+        A1 = b":".join((self._username, challenge.realm, self._password))
+
+        path = request.url.raw_path
+        A2 = b":".join((request.method.encode(), path))
+        # TODO: implement auth-int
+        HA2 = digest(A2)
+
+        nc_value = b"%08x" % self._nonce_count
+        cnonce = self._get_client_nonce(self._nonce_count, challenge.nonce)
+        self._nonce_count += 1
+
+        HA1 = digest(A1)
+        if challenge.algorithm.lower().endswith("-sess"):
+            HA1 = digest(b":".join((HA1, challenge.nonce, cnonce)))
+
+        qop = self._resolve_qop(challenge.qop, request=request)
+        if qop is None:
+            # Following RFC 2069
+            digest_data = [HA1, challenge.nonce, HA2]
+        else:
+            # Following RFC 2617/7616
+            digest_data = [HA1, challenge.nonce, nc_value, cnonce, qop, HA2]
+
+        format_args = {
+            "username": self._username,
+            "realm": challenge.realm,
+            "nonce": challenge.nonce,
+            "uri": path,
+            "response": digest(b":".join(digest_data)),
+            "algorithm": challenge.algorithm.encode(),
+        }
+        if challenge.opaque:
+            format_args["opaque"] = challenge.opaque
+        if qop:
+            format_args["qop"] = b"auth"
+            format_args["nc"] = nc_value
+            format_args["cnonce"] = cnonce
+
+        return "Digest " + self._get_header_value(format_args)
+
+    def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
+        s = str(nonce_count).encode()
+        s += nonce
+        s += time.ctime().encode()
+        s += os.urandom(8)
+
+        return hashlib.sha1(s).hexdigest()[:16].encode()
+
+    def _get_header_value(self, header_fields: dict[str, bytes]) -> str:
+        NON_QUOTED_FIELDS = ("algorithm", "qop", "nc")
+        QUOTED_TEMPLATE = '{}="{}"'
+        NON_QUOTED_TEMPLATE = "{}={}"
+
+        header_value = ""
+        for i, (field, value) in enumerate(header_fields.items()):
+            if i > 0:
+                header_value += ", "
+            template = (
+                QUOTED_TEMPLATE
+                if field not in NON_QUOTED_FIELDS
+                else NON_QUOTED_TEMPLATE
+            )
+            header_value += template.format(field, to_str(value))
+
+        return header_value
+
+    def _resolve_qop(self, qop: bytes | None, request: Request) -> bytes | None:
+        if qop is None:
+            return None
+        qops = re.split(b", ?", qop)
+        if b"auth" in qops:
+            return b"auth"
+
+        if qops == [b"auth-int"]:
+            raise NotImplementedError("Digest auth-int support is not yet implemented")
+
+        message = f'Unexpected qop value "{qop!r}" in digest auth'
+        raise ProtocolError(message, request=request)
+
+
+class _DigestAuthChallenge(typing.NamedTuple):
+    realm: bytes
+    nonce: bytes
+    algorithm: str
+    opaque: bytes | None
+    qop: bytes | None
diff --git a/.venv/lib/python3.10/site-packages/httpx/_client.py b/.venv/lib/python3.10/site-packages/httpx/_client.py
new file mode 100644
index 0000000..2249231
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_client.py
@@ -0,0 +1,2019 @@
+from __future__ import annotations
+
+import datetime
+import enum
+import logging
+import time
+import typing
+import warnings
+from contextlib import asynccontextmanager, contextmanager
+from types import TracebackType
+
+from .__version__ import __version__
+from ._auth import Auth, BasicAuth, FunctionAuth
+from ._config import (
+    DEFAULT_LIMITS,
+    DEFAULT_MAX_REDIRECTS,
+    DEFAULT_TIMEOUT_CONFIG,
+    Limits,
+    Proxy,
+    Timeout,
+)
+from ._decoders import SUPPORTED_DECODERS
+from ._exceptions import (
+    InvalidURL,
+    RemoteProtocolError,
+    TooManyRedirects,
+    request_context,
+)
+from ._models import Cookies, Headers, Request, Response
+from ._status_codes import codes
+from ._transports.base import AsyncBaseTransport, BaseTransport
+from ._transports.default import AsyncHTTPTransport, HTTPTransport
+from ._types import (
+    AsyncByteStream,
+    AuthTypes,
+    CertTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxyTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestExtensions,
+    RequestFiles,
+    SyncByteStream,
+    TimeoutTypes,
+)
+from ._urls import URL, QueryParams
+from ._utils import URLPattern, get_environment_proxies
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+__all__ = ["USE_CLIENT_DEFAULT", "AsyncClient", "Client"]
+
+# The type annotation for @classmethod and context managers here follows PEP 484
+# https://www.python.org/dev/peps/pep-0484/#annotating-instance-and-class-methods
+T = typing.TypeVar("T", bound="Client")
+U = typing.TypeVar("U", bound="AsyncClient")
+
+
+def _is_https_redirect(url: URL, location: URL) -> bool:
+    """
+    Return 'True' if 'location' is a HTTPS upgrade of 'url'
+    """
+    if url.host != location.host:
+        return False
+
+    return (
+        url.scheme == "http"
+        and _port_or_default(url) == 80
+        and location.scheme == "https"
+        and _port_or_default(location) == 443
+    )
+
+
+def _port_or_default(url: URL) -> int | None:
+    if url.port is not None:
+        return url.port
+    return {"http": 80, "https": 443}.get(url.scheme)
+
+
+def _same_origin(url: URL, other: URL) -> bool:
+    """
+    Return 'True' if the given URLs share the same origin.
+    """
+    return (
+        url.scheme == other.scheme
+        and url.host == other.host
+        and _port_or_default(url) == _port_or_default(other)
+    )
+
+
+class UseClientDefault:
+    """
+    For some parameters such as `auth=...` and `timeout=...` we need to be able
+    to indicate the default "unset" state, in a way that is distinctly different
+    to using `None`.
+
+    The default "unset" state indicates that whatever default is set on the
+    client should be used. This is different to setting `None`, which
+    explicitly disables the parameter, possibly overriding a client default.
+
+    For example we use `timeout=USE_CLIENT_DEFAULT` in the `request()` signature.
+    Omitting the `timeout` parameter will send a request using whatever default
+    timeout has been configured on the client. Including `timeout=None` will
+    ensure no timeout is used.
+
+    Note that user code shouldn't need to use the `USE_CLIENT_DEFAULT` constant,
+    but it is used internally when a parameter is not included.
+    """
+
+
+USE_CLIENT_DEFAULT = UseClientDefault()
+
+
+logger = logging.getLogger("httpx")
+
+USER_AGENT = f"python-httpx/{__version__}"
+ACCEPT_ENCODING = ", ".join(
+    [key for key in SUPPORTED_DECODERS.keys() if key != "identity"]
+)
+
+
+class ClientState(enum.Enum):
+    # UNOPENED:
+    #   The client has been instantiated, but has not been used to send a request,
+    #   or been opened by entering the context of a `with` block.
+    UNOPENED = 1
+    # OPENED:
+    #   The client has either sent a request, or is within a `with` block.
+    OPENED = 2
+    # CLOSED:
+    #   The client has either exited the `with` block, or `close()` has
+    #   been called explicitly.
+    CLOSED = 3
+
+
+class BoundSyncStream(SyncByteStream):
+    """
+    A byte stream that is bound to a given response instance, and that
+    ensures the `response.elapsed` is set once the response is closed.
+    """
+
+    def __init__(
+        self, stream: SyncByteStream, response: Response, start: float
+    ) -> None:
+        self._stream = stream
+        self._response = response
+        self._start = start
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for chunk in self._stream:
+            yield chunk
+
+    def close(self) -> None:
+        elapsed = time.perf_counter() - self._start
+        self._response.elapsed = datetime.timedelta(seconds=elapsed)
+        self._stream.close()
+
+
+class BoundAsyncStream(AsyncByteStream):
+    """
+    An async byte stream that is bound to a given response instance, and that
+    ensures the `response.elapsed` is set once the response is closed.
+    """
+
+    def __init__(
+        self, stream: AsyncByteStream, response: Response, start: float
+    ) -> None:
+        self._stream = stream
+        self._response = response
+        self._start = start
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        async for chunk in self._stream:
+            yield chunk
+
+    async def aclose(self) -> None:
+        elapsed = time.perf_counter() - self._start
+        self._response.elapsed = datetime.timedelta(seconds=elapsed)
+        await self._stream.aclose()
+
+
+EventHook = typing.Callable[..., typing.Any]
+
+
+class BaseClient:
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        trust_env: bool = True,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
+        event_hooks = {} if event_hooks is None else event_hooks
+
+        self._base_url = self._enforce_trailing_slash(URL(base_url))
+
+        self._auth = self._build_auth(auth)
+        self._params = QueryParams(params)
+        self.headers = Headers(headers)
+        self._cookies = Cookies(cookies)
+        self._timeout = Timeout(timeout)
+        self.follow_redirects = follow_redirects
+        self.max_redirects = max_redirects
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+        self._trust_env = trust_env
+        self._default_encoding = default_encoding
+        self._state = ClientState.UNOPENED
+
+    @property
+    def is_closed(self) -> bool:
+        """
+        Check if the client being closed
+        """
+        return self._state == ClientState.CLOSED
+
+    @property
+    def trust_env(self) -> bool:
+        return self._trust_env
+
+    def _enforce_trailing_slash(self, url: URL) -> URL:
+        if url.raw_path.endswith(b"/"):
+            return url
+        return url.copy_with(raw_path=url.raw_path + b"/")
+
+    def _get_proxy_map(
+        self, proxy: ProxyTypes | None, allow_env_proxies: bool
+    ) -> dict[str, Proxy | None]:
+        if proxy is None:
+            if allow_env_proxies:
+                return {
+                    key: None if url is None else Proxy(url=url)
+                    for key, url in get_environment_proxies().items()
+                }
+            return {}
+        else:
+            proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+            return {"all://": proxy}
+
+    @property
+    def timeout(self) -> Timeout:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, timeout: TimeoutTypes) -> None:
+        self._timeout = Timeout(timeout)
+
+    @property
+    def event_hooks(self) -> dict[str, list[EventHook]]:
+        return self._event_hooks
+
+    @event_hooks.setter
+    def event_hooks(self, event_hooks: dict[str, list[EventHook]]) -> None:
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+
+    @property
+    def auth(self) -> Auth | None:
+        """
+        Authentication class used when none is passed at the request-level.
+
+        See also [Authentication][0].
+
+        [0]: /quickstart/#authentication
+        """
+        return self._auth
+
+    @auth.setter
+    def auth(self, auth: AuthTypes) -> None:
+        self._auth = self._build_auth(auth)
+
+    @property
+    def base_url(self) -> URL:
+        """
+        Base URL to use when sending requests with relative URLs.
+        """
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, url: URL | str) -> None:
+        self._base_url = self._enforce_trailing_slash(URL(url))
+
+    @property
+    def headers(self) -> Headers:
+        """
+        HTTP headers to include when sending requests.
+        """
+        return self._headers
+
+    @headers.setter
+    def headers(self, headers: HeaderTypes) -> None:
+        client_headers = Headers(
+            {
+                b"Accept": b"*/*",
+                b"Accept-Encoding": ACCEPT_ENCODING.encode("ascii"),
+                b"Connection": b"keep-alive",
+                b"User-Agent": USER_AGENT.encode("ascii"),
+            }
+        )
+        client_headers.update(headers)
+        self._headers = client_headers
+
+    @property
+    def cookies(self) -> Cookies:
+        """
+        Cookie values to include when sending requests.
+        """
+        return self._cookies
+
+    @cookies.setter
+    def cookies(self, cookies: CookieTypes) -> None:
+        self._cookies = Cookies(cookies)
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        Query parameters to include in the URL when sending requests.
+        """
+        return self._params
+
+    @params.setter
+    def params(self, params: QueryParamTypes) -> None:
+        self._params = QueryParams(params)
+
+    def build_request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Request:
+        """
+        Build and return a request instance.
+
+        * The `params`, `headers` and `cookies` arguments
+        are merged with any values set on the client.
+        * The `url` argument is merged with any `base_url` set on the client.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/clients/#request-instances
+        """
+        url = self._merge_url(url)
+        headers = self._merge_headers(headers)
+        cookies = self._merge_cookies(cookies)
+        params = self._merge_queryparams(params)
+        extensions = {} if extensions is None else extensions
+        if "timeout" not in extensions:
+            timeout = (
+                self.timeout
+                if isinstance(timeout, UseClientDefault)
+                else Timeout(timeout)
+            )
+            extensions = dict(**extensions, timeout=timeout.as_dict())
+        return Request(
+            method,
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            extensions=extensions,
+        )
+
+    def _merge_url(self, url: URL | str) -> URL:
+        """
+        Merge a URL argument together with any 'base_url' on the client,
+        to create the URL used for the outgoing request.
+        """
+        merge_url = URL(url)
+        if merge_url.is_relative_url:
+            # To merge URLs we always append to the base URL. To get this
+            # behaviour correct we always ensure the base URL ends in a '/'
+            # separator, and strip any leading '/' from the merge URL.
+            #
+            # So, eg...
+            #
+            # >>> client = Client(base_url="https://www.example.com/subpath")
+            # >>> client.base_url
+            # URL('https://www.example.com/subpath/')
+            # >>> client.build_request("GET", "/path").url
+            # URL('https://www.example.com/subpath/path')
+            merge_raw_path = self.base_url.raw_path + merge_url.raw_path.lstrip(b"/")
+            return self.base_url.copy_with(raw_path=merge_raw_path)
+        return merge_url
+
+    def _merge_cookies(self, cookies: CookieTypes | None = None) -> CookieTypes | None:
+        """
+        Merge a cookies argument together with any cookies on the client,
+        to create the cookies used for the outgoing request.
+        """
+        if cookies or self.cookies:
+            merged_cookies = Cookies(self.cookies)
+            merged_cookies.update(cookies)
+            return merged_cookies
+        return cookies
+
+    def _merge_headers(self, headers: HeaderTypes | None = None) -> HeaderTypes | None:
+        """
+        Merge a headers argument together with any headers on the client,
+        to create the headers used for the outgoing request.
+        """
+        merged_headers = Headers(self.headers)
+        merged_headers.update(headers)
+        return merged_headers
+
+    def _merge_queryparams(
+        self, params: QueryParamTypes | None = None
+    ) -> QueryParamTypes | None:
+        """
+        Merge a queryparams argument together with any queryparams on the client,
+        to create the queryparams used for the outgoing request.
+        """
+        if params or self.params:
+            merged_queryparams = QueryParams(self.params)
+            return merged_queryparams.merge(params)
+        return params
+
+    def _build_auth(self, auth: AuthTypes | None) -> Auth | None:
+        if auth is None:
+            return None
+        elif isinstance(auth, tuple):
+            return BasicAuth(username=auth[0], password=auth[1])
+        elif isinstance(auth, Auth):
+            return auth
+        elif callable(auth):
+            return FunctionAuth(func=auth)
+        else:
+            raise TypeError(f'Invalid "auth" argument: {auth!r}')
+
+    def _build_request_auth(
+        self,
+        request: Request,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+    ) -> Auth:
+        auth = (
+            self._auth if isinstance(auth, UseClientDefault) else self._build_auth(auth)
+        )
+
+        if auth is not None:
+            return auth
+
+        username, password = request.url.username, request.url.password
+        if username or password:
+            return BasicAuth(username=username, password=password)
+
+        return Auth()
+
+    def _build_redirect_request(self, request: Request, response: Response) -> Request:
+        """
+        Given a request and a redirect response, return a new request that
+        should be used to effect the redirect.
+        """
+        method = self._redirect_method(request, response)
+        url = self._redirect_url(request, response)
+        headers = self._redirect_headers(request, url, method)
+        stream = self._redirect_stream(request, method)
+        cookies = Cookies(self.cookies)
+        return Request(
+            method=method,
+            url=url,
+            headers=headers,
+            cookies=cookies,
+            stream=stream,
+            extensions=request.extensions,
+        )
+
+    def _redirect_method(self, request: Request, response: Response) -> str:
+        """
+        When being redirected we may want to change the method of the request
+        based on certain specs or browser behavior.
+        """
+        method = request.method
+
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
+        if response.status_code == codes.SEE_OTHER and method != "HEAD":
+            method = "GET"
+
+        # Do what the browsers do, despite standards...
+        # Turn 302s into GETs.
+        if response.status_code == codes.FOUND and method != "HEAD":
+            method = "GET"
+
+        # If a POST is responded to with a 301, turn it into a GET.
+        # This bizarre behaviour is explained in 'requests' issue 1704.
+        if response.status_code == codes.MOVED_PERMANENTLY and method == "POST":
+            method = "GET"
+
+        return method
+
+    def _redirect_url(self, request: Request, response: Response) -> URL:
+        """
+        Return the URL for the redirect to follow.
+        """
+        location = response.headers["Location"]
+
+        try:
+            url = URL(location)
+        except InvalidURL as exc:
+            raise RemoteProtocolError(
+                f"Invalid URL in location header: {exc}.", request=request
+            ) from None
+
+        # Handle malformed 'Location' headers that are "absolute" form, have no host.
+        # See: https://github.com/encode/httpx/issues/771
+        if url.scheme and not url.host:
+            url = url.copy_with(host=request.url.host)
+
+        # Facilitate relative 'Location' headers, as allowed by RFC 7231.
+        # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+        if url.is_relative_url:
+            url = request.url.join(url)
+
+        # Attach previous fragment if needed (RFC 7231 7.1.2)
+        if request.url.fragment and not url.fragment:
+            url = url.copy_with(fragment=request.url.fragment)
+
+        return url
+
+    def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
+        """
+        Return the headers that should be used for the redirect request.
+        """
+        headers = Headers(request.headers)
+
+        if not _same_origin(url, request.url):
+            if not _is_https_redirect(request.url, url):
+                # Strip Authorization headers when responses are redirected
+                # away from the origin. (Except for direct HTTP to HTTPS redirects.)
+                headers.pop("Authorization", None)
+
+            # Update the Host header.
+            headers["Host"] = url.netloc.decode("ascii")
+
+        if method != request.method and method == "GET":
+            # If we've switch to a 'GET' request, then strip any headers which
+            # are only relevant to the request body.
+            headers.pop("Content-Length", None)
+            headers.pop("Transfer-Encoding", None)
+
+        # We should use the client cookie store to determine any cookie header,
+        # rather than whatever was on the original outgoing request.
+        headers.pop("Cookie", None)
+
+        return headers
+
+    def _redirect_stream(
+        self, request: Request, method: str
+    ) -> SyncByteStream | AsyncByteStream | None:
+        """
+        Return the body that should be used for the redirect request.
+        """
+        if method != request.method and method == "GET":
+            return None
+
+        return request.stream
+
+    def _set_timeout(self, request: Request) -> None:
+        if "timeout" not in request.extensions:
+            timeout = (
+                self.timeout
+                if isinstance(self.timeout, UseClientDefault)
+                else Timeout(self.timeout)
+            )
+            request.extensions = dict(**request.extensions, timeout=timeout.as_dict())
+
+
+class Client(BaseClient):
+    """
+    An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc.
+
+    It can be shared between threads.
+
+    Usage:
+
+    ```python
+    >>> client = httpx.Client()
+    >>> response = client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, BaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        transport: BaseTransport | None = None,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and transport is None
+        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+        )
+        self._mounts: dict[URLPattern, BaseTransport | None] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                trust_env=trust_env,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update(
+                {URLPattern(key): transport for key, transport in mounts.items()}
+            )
+
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: BaseTransport | None = None,
+    ) -> BaseTransport:
+        if transport is not None:
+            return transport
+
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+    ) -> BaseTransport:
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> BaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    def request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = client.send(request, ...)
+        ```
+
+        See `Client.build_request()`, `Client.send()` and
+        [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: /advanced/clients/#merging-of-configuration
+        """
+        if cookies is not None:
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @contextmanager
+    def stream(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> typing.Iterator[Response]:
+        """
+        Alternative to `httpx.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: /quickstart#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            response.close()
+
+    def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `Client.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/clients/#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
+        )
+
+        self._set_timeout(request)
+
+        auth = self._build_request_auth(request, auth)
+
+        response = self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                response.read()
+
+            return response
+
+        except BaseException as exc:
+            response.close()
+            raise exc
+
+    def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        auth_flow = auth.sync_auth_flow(request)
+        try:
+            request = next(auth_flow)
+
+            while True:
+                response = self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = auth_flow.send(response)
+                    except StopIteration:
+                        return response
+
+                    response.history = list(history)
+                    response.read()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    response.close()
+                    raise exc
+        finally:
+            auth_flow.close()
+
+    def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects(
+                    "Exceeded maximum allowed redirects.", request=request
+                )
+
+            for hook in self._event_hooks["request"]:
+                hook(request)
+
+            response = self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    hook(response)
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    response.read()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                response.close()
+                raise exc
+
+    def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        start = time.perf_counter()
+
+        if not isinstance(request.stream, SyncByteStream):
+            raise RuntimeError(
+                "Attempted to send an async request with a sync Client instance."
+            )
+
+        with request_context(request=request):
+            response = transport.handle_request(request)
+
+        assert isinstance(response.stream, SyncByteStream)
+
+        response.request = request
+        response.stream = BoundSyncStream(
+            response.stream, response=response, start=start
+        )
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
+
+        return response
+
+    def get(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def options(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def head(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def post(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def put(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def patch(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def delete(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def close(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            self._transport.close()
+            for transport in self._mounts.values():
+                if transport is not None:
+                    transport.close()
+
+    def __enter__(self: T) -> T:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: (
+                    "Cannot reopen a client instance, once it has been closed."
+                ),
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        self._transport.__enter__()
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        self._transport.__exit__(exc_type, exc_value, traceback)
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__exit__(exc_type, exc_value, traceback)
+
+
+class AsyncClient(BaseClient):
+    """
+    An asynchronous HTTP client, with connection pooling, HTTP/2, redirects,
+    cookie persistence, etc.
+
+    It can be shared between tasks.
+
+    Usage:
+
+    ```python
+    >>> async with httpx.AsyncClient() as client:
+    >>>     response = await client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        transport: AsyncBaseTransport | None = None,
+        trust_env: bool = True,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and transport is None
+        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+        )
+
+        self._mounts: dict[URLPattern, AsyncBaseTransport | None] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                trust_env=trust_env,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update(
+                {URLPattern(key): transport for key, transport in mounts.items()}
+            )
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: AsyncBaseTransport | None = None,
+    ) -> AsyncBaseTransport:
+        if transport is not None:
+            return transport
+
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+    ) -> AsyncBaseTransport:
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> AsyncBaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    async def request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = await client.send(request, ...)
+        ```
+
+        See `AsyncClient.build_request()`, `AsyncClient.send()`
+        and [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: /advanced/clients/#merging-of-configuration
+        """
+
+        if cookies is not None:  # pragma: no cover
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return await self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> typing.AsyncIterator[Response]:
+        """
+        Alternative to `httpx.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: /quickstart#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = await self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    async def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `AsyncClient.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: /advanced/clients/#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
+        )
+
+        self._set_timeout(request)
+
+        auth = self._build_request_auth(request, auth)
+
+        response = await self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                await response.aread()
+
+            return response
+
+        except BaseException as exc:
+            await response.aclose()
+            raise exc
+
+    async def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        auth_flow = auth.async_auth_flow(request)
+        try:
+            request = await auth_flow.__anext__()
+
+            while True:
+                response = await self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = await auth_flow.asend(response)
+                    except StopAsyncIteration:
+                        return response
+
+                    response.history = list(history)
+                    await response.aread()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    await response.aclose()
+                    raise exc
+        finally:
+            await auth_flow.aclose()
+
+    async def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects(
+                    "Exceeded maximum allowed redirects.", request=request
+                )
+
+            for hook in self._event_hooks["request"]:
+                await hook(request)
+
+            response = await self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    await hook(response)
+
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    await response.aread()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                await response.aclose()
+                raise exc
+
+    async def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        start = time.perf_counter()
+
+        if not isinstance(request.stream, AsyncByteStream):
+            raise RuntimeError(
+                "Attempted to send an sync request with an AsyncClient instance."
+            )
+
+        with request_context(request=request):
+            response = await transport.handle_async_request(request)
+
+        assert isinstance(response.stream, AsyncByteStream)
+        response.request = request
+        response.stream = BoundAsyncStream(
+            response.stream, response=response, start=start
+        )
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
+
+        return response
+
+    async def get(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def options(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def head(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def post(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def put(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def patch(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def delete(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx.request`.
+        """
+        return await self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def aclose(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            await self._transport.aclose()
+            for proxy in self._mounts.values():
+                if proxy is not None:
+                    await proxy.aclose()
+
+    async def __aenter__(self: U) -> U:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: (
+                    "Cannot reopen a client instance, once it has been closed."
+                ),
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        await self._transport.__aenter__()
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        await self._transport.__aexit__(exc_type, exc_value, traceback)
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aexit__(exc_type, exc_value, traceback)
diff --git a/.venv/lib/python3.10/site-packages/httpx/_config.py b/.venv/lib/python3.10/site-packages/httpx/_config.py
new file mode 100644
index 0000000..467a6c9
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_config.py
@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import os
+import typing
+
+from ._models import Headers
+from ._types import CertTypes, HeaderTypes, TimeoutTypes
+from ._urls import URL
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+__all__ = ["Limits", "Proxy", "Timeout", "create_ssl_context"]
+
+
+class UnsetType:
+    pass  # pragma: no cover
+
+
+UNSET = UnsetType()
+
+
+def create_ssl_context(
+    verify: ssl.SSLContext | str | bool = True,
+    cert: CertTypes | None = None,
+    trust_env: bool = True,
+) -> ssl.SSLContext:
+    import ssl
+    import warnings
+
+    import certifi
+
+    if verify is True:
+        if trust_env and os.environ.get("SSL_CERT_FILE"):  # pragma: nocover
+            ctx = ssl.create_default_context(cafile=os.environ["SSL_CERT_FILE"])
+        elif trust_env and os.environ.get("SSL_CERT_DIR"):  # pragma: nocover
+            ctx = ssl.create_default_context(capath=os.environ["SSL_CERT_DIR"])
+        else:
+            # Default case...
+            ctx = ssl.create_default_context(cafile=certifi.where())
+    elif verify is False:
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    elif isinstance(verify, str):  # pragma: nocover
+        message = (
+            "`verify=` is deprecated. "
+            "Use `verify=ssl.create_default_context(cafile=...)` "
+            "or `verify=ssl.create_default_context(capath=...)` instead."
+        )
+        warnings.warn(message, DeprecationWarning)
+        if os.path.isdir(verify):
+            return ssl.create_default_context(capath=verify)
+        return ssl.create_default_context(cafile=verify)
+    else:
+        ctx = verify
+
+    if cert:  # pragma: nocover
+        message = (
+            "`cert=...` is deprecated. Use `verify=` instead,"
+            "with `.load_cert_chain()` to configure the certificate chain."
+        )
+        warnings.warn(message, DeprecationWarning)
+        if isinstance(cert, str):
+            ctx.load_cert_chain(cert)
+        else:
+            ctx.load_cert_chain(*cert)
+
+    return ctx
+
+
+class Timeout:
+    """
+    Timeout configuration.
+
+    **Usage**:
+
+    Timeout(None)               # No timeouts.
+    Timeout(5.0)                # 5s timeout on all operations.
+    Timeout(None, connect=5.0)  # 5s timeout on connect, no other timeouts.
+    Timeout(5.0, connect=10.0)  # 10s timeout on connect. 5s timeout elsewhere.
+    Timeout(5.0, pool=None)     # No timeout on acquiring connection from pool.
+                                # 5s timeout elsewhere.
+    """
+
+    def __init__(
+        self,
+        timeout: TimeoutTypes | UnsetType = UNSET,
+        *,
+        connect: None | float | UnsetType = UNSET,
+        read: None | float | UnsetType = UNSET,
+        write: None | float | UnsetType = UNSET,
+        pool: None | float | UnsetType = UNSET,
+    ) -> None:
+        if isinstance(timeout, Timeout):
+            # Passed as a single explicit Timeout.
+            assert connect is UNSET
+            assert read is UNSET
+            assert write is UNSET
+            assert pool is UNSET
+            self.connect = timeout.connect  # type: typing.Optional[float]
+            self.read = timeout.read  # type: typing.Optional[float]
+            self.write = timeout.write  # type: typing.Optional[float]
+            self.pool = timeout.pool  # type: typing.Optional[float]
+        elif isinstance(timeout, tuple):
+            # Passed as a tuple.
+            self.connect = timeout[0]
+            self.read = timeout[1]
+            self.write = None if len(timeout) < 3 else timeout[2]
+            self.pool = None if len(timeout) < 4 else timeout[3]
+        elif not (
+            isinstance(connect, UnsetType)
+            or isinstance(read, UnsetType)
+            or isinstance(write, UnsetType)
+            or isinstance(pool, UnsetType)
+        ):
+            self.connect = connect
+            self.read = read
+            self.write = write
+            self.pool = pool
+        else:
+            if isinstance(timeout, UnsetType):
+                raise ValueError(
+                    "httpx.Timeout must either include a default, or set all "
+                    "four parameters explicitly."
+                )
+            self.connect = timeout if isinstance(connect, UnsetType) else connect
+            self.read = timeout if isinstance(read, UnsetType) else read
+            self.write = timeout if isinstance(write, UnsetType) else write
+            self.pool = timeout if isinstance(pool, UnsetType) else pool
+
+    def as_dict(self) -> dict[str, float | None]:
+        return {
+            "connect": self.connect,
+            "read": self.read,
+            "write": self.write,
+            "pool": self.pool,
+        }
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.connect == other.connect
+            and self.read == other.read
+            and self.write == other.write
+            and self.pool == other.pool
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        if len({self.connect, self.read, self.write, self.pool}) == 1:
+            return f"{class_name}(timeout={self.connect})"
+        return (
+            f"{class_name}(connect={self.connect}, "
+            f"read={self.read}, write={self.write}, pool={self.pool})"
+        )
+
+
+class Limits:
+    """
+    Configuration for limits to various client behaviors.
+
+    **Parameters:**
+
+    * **max_connections** - The maximum number of concurrent connections that may be
+            established.
+    * **max_keepalive_connections** - Allow the connection pool to maintain
+            keep-alive connections below this point. Should be less than or equal
+            to `max_connections`.
+    * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_connections: int | None = None,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = 5.0,
+    ) -> None:
+        self.max_connections = max_connections
+        self.max_keepalive_connections = max_keepalive_connections
+        self.keepalive_expiry = keepalive_expiry
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, self.__class__)
+            and self.max_connections == other.max_connections
+            and self.max_keepalive_connections == other.max_keepalive_connections
+            and self.keepalive_expiry == other.keepalive_expiry
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(max_connections={self.max_connections}, "
+            f"max_keepalive_connections={self.max_keepalive_connections}, "
+            f"keepalive_expiry={self.keepalive_expiry})"
+        )
+
+
+class Proxy:
+    def __init__(
+        self,
+        url: URL | str,
+        *,
+        ssl_context: ssl.SSLContext | None = None,
+        auth: tuple[str, str] | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> None:
+        url = URL(url)
+        headers = Headers(headers)
+
+        if url.scheme not in ("http", "https", "socks5", "socks5h"):
+            raise ValueError(f"Unknown scheme for proxy URL {url!r}")
+
+        if url.username or url.password:
+            # Remove any auth credentials from the URL.
+            auth = (url.username, url.password)
+            url = url.copy_with(username=None, password=None)
+
+        self.url = url
+        self.auth = auth
+        self.headers = headers
+        self.ssl_context = ssl_context
+
+    @property
+    def raw_auth(self) -> tuple[bytes, bytes] | None:
+        # The proxy authentication as raw bytes.
+        return (
+            None
+            if self.auth is None
+            else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8"))
+        )
+
+    def __repr__(self) -> str:
+        # The authentication is represented with the password component masked.
+        auth = (self.auth[0], "********") if self.auth else None
+
+        # Build a nice concise representation.
+        url_str = f"{str(self.url)!r}"
+        auth_str = f", auth={auth!r}" if auth else ""
+        headers_str = f", headers={dict(self.headers)!r}" if self.headers else ""
+        return f"Proxy({url_str}{auth_str}{headers_str})"
+
+
+DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0)
+DEFAULT_LIMITS = Limits(max_connections=100, max_keepalive_connections=20)
+DEFAULT_MAX_REDIRECTS = 20
diff --git a/.venv/lib/python3.10/site-packages/httpx/_content.py b/.venv/lib/python3.10/site-packages/httpx/_content.py
new file mode 100644
index 0000000..6f479a0
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_content.py
@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from json import dumps as json_dumps
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Iterable,
+    Iterator,
+    Mapping,
+)
+from urllib.parse import urlencode
+
+from ._exceptions import StreamClosed, StreamConsumed
+from ._multipart import MultipartStream
+from ._types import (
+    AsyncByteStream,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    ResponseContent,
+    SyncByteStream,
+)
+from ._utils import peek_filelike_length, primitive_value_to_str
+
+__all__ = ["ByteStream"]
+
+
+class ByteStream(AsyncByteStream, SyncByteStream):
+    def __init__(self, stream: bytes) -> None:
+        self._stream = stream
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield self._stream
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self._stream
+
+
+class IteratorByteStream(SyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: Iterable[bytes]) -> None:
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isgenerator(stream)
+
+    def __iter__(self) -> Iterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "read"):
+            # File-like interfaces should use 'read' directly.
+            chunk = self._stream.read(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = self._stream.read(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate.
+            for part in self._stream:
+                yield part
+
+
+class AsyncIteratorByteStream(AsyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: AsyncIterable[bytes]) -> None:
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isasyncgen(stream)
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "aread"):
+            # File-like interfaces should use 'aread' directly.
+            chunk = await self._stream.aread(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = await self._stream.aread(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate.
+            async for part in self._stream:
+                yield part
+
+
+class UnattachedStream(AsyncByteStream, SyncByteStream):
+    """
+    If a request or response is serialized using pickle, then it is no longer
+    attached to a stream for I/O purposes. Any stream operations should result
+    in `httpx.StreamClosed`.
+    """
+
+    def __iter__(self) -> Iterator[bytes]:
+        raise StreamClosed()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise StreamClosed()
+        yield b""  # pragma: no cover
+
+
+def encode_content(
+    content: str | bytes | Iterable[bytes] | AsyncIterable[bytes],
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    if isinstance(content, (bytes, str)):
+        body = content.encode("utf-8") if isinstance(content, str) else content
+        content_length = len(body)
+        headers = {"Content-Length": str(content_length)} if body else {}
+        return headers, ByteStream(body)
+
+    elif isinstance(content, Iterable) and not isinstance(content, dict):
+        # `not isinstance(content, dict)` is a bit oddly specific, but it
+        # catches a case that's easy for users to make in error, and would
+        # otherwise pass through here, like any other bytes-iterable,
+        # because `dict` happens to be iterable. See issue #2491.
+        content_length_or_none = peek_filelike_length(content)
+
+        if content_length_or_none is None:
+            headers = {"Transfer-Encoding": "chunked"}
+        else:
+            headers = {"Content-Length": str(content_length_or_none)}
+        return headers, IteratorByteStream(content)  # type: ignore
+
+    elif isinstance(content, AsyncIterable):
+        headers = {"Transfer-Encoding": "chunked"}
+        return headers, AsyncIteratorByteStream(content)
+
+    raise TypeError(f"Unexpected type for 'content', {type(content)!r}")
+
+
+def encode_urlencoded_data(
+    data: RequestData,
+) -> tuple[dict[str, str], ByteStream]:
+    plain_data = []
+    for key, value in data.items():
+        if isinstance(value, (list, tuple)):
+            plain_data.extend([(key, primitive_value_to_str(item)) for item in value])
+        else:
+            plain_data.append((key, primitive_value_to_str(value)))
+    body = urlencode(plain_data, doseq=True).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/x-www-form-urlencoded"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_multipart_data(
+    data: RequestData, files: RequestFiles, boundary: bytes | None
+) -> tuple[dict[str, str], MultipartStream]:
+    multipart = MultipartStream(data=data, files=files, boundary=boundary)
+    headers = multipart.get_headers()
+    return headers, multipart
+
+
+def encode_text(text: str) -> tuple[dict[str, str], ByteStream]:
+    body = text.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/plain; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_html(html: str) -> tuple[dict[str, str], ByteStream]:
+    body = html.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/html; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_json(json: Any) -> tuple[dict[str, str], ByteStream]:
+    body = json_dumps(
+        json, ensure_ascii=False, separators=(",", ":"), allow_nan=False
+    ).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_request(
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: Any | None = None,
+    boundary: bytes | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    """
+    Handles encoding the given `content`, `data`, `files`, and `json`,
+    returning a two-tuple of (, ).
+    """
+    if data is not None and not isinstance(data, Mapping):
+        # We prefer to separate `content=`
+        # for raw request content, and `data=
` for url encoded or
+        # multipart form content.
+        #
+        # However for compat with requests, we *do* still support
+        # `data=` usages. We deal with that case here, treating it
+        # as if `content=<...>` had been supplied instead.
+        message = "Use 'content=<...>' to upload raw bytes/text content."
+        warnings.warn(message, DeprecationWarning, stacklevel=2)
+        return encode_content(data)
+
+    if content is not None:
+        return encode_content(content)
+    elif files:
+        return encode_multipart_data(data or {}, files, boundary)
+    elif data:
+        return encode_urlencoded_data(data)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
+
+
+def encode_response(
+    content: ResponseContent | None = None,
+    text: str | None = None,
+    html: str | None = None,
+    json: Any | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    """
+    Handles encoding the given `content`, returning a two-tuple of
+    (, ).
+    """
+    if content is not None:
+        return encode_content(content)
+    elif text is not None:
+        return encode_text(text)
+    elif html is not None:
+        return encode_html(html)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
diff --git a/.venv/lib/python3.10/site-packages/httpx/_decoders.py b/.venv/lib/python3.10/site-packages/httpx/_decoders.py
new file mode 100644
index 0000000..899dfad
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_decoders.py
@@ -0,0 +1,393 @@
+"""
+Handlers for Content-Encoding.
+
+See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+"""
+
+from __future__ import annotations
+
+import codecs
+import io
+import typing
+import zlib
+
+from ._exceptions import DecodingError
+
+# Brotli support is optional
+try:
+    # The C bindings in `brotli` are recommended for CPython.
+    import brotli
+except ImportError:  # pragma: no cover
+    try:
+        # The CFFI bindings in `brotlicffi` are recommended for PyPy
+        # and other environments.
+        import brotlicffi as brotli
+    except ImportError:
+        brotli = None
+
+
+# Zstandard support is optional
+try:
+    import zstandard
+except ImportError:  # pragma: no cover
+    zstandard = None  # type: ignore
+
+
+class ContentDecoder:
+    def decode(self, data: bytes) -> bytes:
+        raise NotImplementedError()  # pragma: no cover
+
+    def flush(self) -> bytes:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class IdentityDecoder(ContentDecoder):
+    """
+    Handle unencoded data.
+    """
+
+    def decode(self, data: bytes) -> bytes:
+        return data
+
+    def flush(self) -> bytes:
+        return b""
+
+
+class DeflateDecoder(ContentDecoder):
+    """
+    Handle 'deflate' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.first_attempt = True
+        self.decompressor = zlib.decompressobj()
+
+    def decode(self, data: bytes) -> bytes:
+        was_first_attempt = self.first_attempt
+        self.first_attempt = False
+        try:
+            return self.decompressor.decompress(data)
+        except zlib.error as exc:
+            if was_first_attempt:
+                self.decompressor = zlib.decompressobj(-zlib.MAX_WBITS)
+                return self.decode(data)
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        try:
+            return self.decompressor.flush()
+        except zlib.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+
+
+class GZipDecoder(ContentDecoder):
+    """
+    Handle 'gzip' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.decompressor = zlib.decompressobj(zlib.MAX_WBITS | 16)
+
+    def decode(self, data: bytes) -> bytes:
+        try:
+            return self.decompressor.decompress(data)
+        except zlib.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        try:
+            return self.decompressor.flush()
+        except zlib.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+
+
+class BrotliDecoder(ContentDecoder):
+    """
+    Handle 'brotli' decoding.
+
+    Requires `pip install brotlipy`. See: https://brotlipy.readthedocs.io/
+        or   `pip install brotli`. See https://github.com/google/brotli
+    Supports both 'brotlipy' and 'Brotli' packages since they share an import
+    name. The top branches are for 'brotlipy' and bottom branches for 'Brotli'
+    """
+
+    def __init__(self) -> None:
+        if brotli is None:  # pragma: no cover
+            raise ImportError(
+                "Using 'BrotliDecoder', but neither of the 'brotlicffi' or 'brotli' "
+                "packages have been installed. "
+                "Make sure to install httpx using `pip install httpx[brotli]`."
+            ) from None
+
+        self.decompressor = brotli.Decompressor()
+        self.seen_data = False
+        self._decompress: typing.Callable[[bytes], bytes]
+        if hasattr(self.decompressor, "decompress"):
+            # The 'brotlicffi' package.
+            self._decompress = self.decompressor.decompress  # pragma: no cover
+        else:
+            # The 'brotli' package.
+            self._decompress = self.decompressor.process  # pragma: no cover
+
+    def decode(self, data: bytes) -> bytes:
+        if not data:
+            return b""
+        self.seen_data = True
+        try:
+            return self._decompress(data)
+        except brotli.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> bytes:
+        if not self.seen_data:
+            return b""
+        try:
+            if hasattr(self.decompressor, "finish"):
+                # Only available in the 'brotlicffi' package.
+
+                # As the decompressor decompresses eagerly, this
+                # will never actually emit any data. However, it will potentially throw
+                # errors if a truncated or damaged data stream has been used.
+                self.decompressor.finish()  # pragma: no cover
+            return b""
+        except brotli.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+
+
+class ZStandardDecoder(ContentDecoder):
+    """
+    Handle 'zstd' RFC 8878 decoding.
+
+    Requires `pip install zstandard`.
+    Can be installed as a dependency of httpx using `pip install httpx[zstd]`.
+    """
+
+    # inspired by the ZstdDecoder implementation in urllib3
+    def __init__(self) -> None:
+        if zstandard is None:  # pragma: no cover
+            raise ImportError(
+                "Using 'ZStandardDecoder', ..."
+                "Make sure to install httpx using `pip install httpx[zstd]`."
+            ) from None
+
+        self.decompressor = zstandard.ZstdDecompressor().decompressobj()
+        self.seen_data = False
+
+    def decode(self, data: bytes) -> bytes:
+        assert zstandard is not None
+        self.seen_data = True
+        output = io.BytesIO()
+        try:
+            output.write(self.decompressor.decompress(data))
+            while self.decompressor.eof and self.decompressor.unused_data:
+                unused_data = self.decompressor.unused_data
+                self.decompressor = zstandard.ZstdDecompressor().decompressobj()
+                output.write(self.decompressor.decompress(unused_data))
+        except zstandard.ZstdError as exc:
+            raise DecodingError(str(exc)) from exc
+        return output.getvalue()
+
+    def flush(self) -> bytes:
+        if not self.seen_data:
+            return b""
+        ret = self.decompressor.flush()  # note: this is a no-op
+        if not self.decompressor.eof:
+            raise DecodingError("Zstandard data is incomplete")  # pragma: no cover
+        return bytes(ret)
+
+
+class MultiDecoder(ContentDecoder):
+    """
+    Handle the case where multiple encodings have been applied.
+    """
+
+    def __init__(self, children: typing.Sequence[ContentDecoder]) -> None:
+        """
+        'children' should be a sequence of decoders in the order in which
+        each was applied.
+        """
+        # Note that we reverse the order for decoding.
+        self.children = list(reversed(children))
+
+    def decode(self, data: bytes) -> bytes:
+        for child in self.children:
+            data = child.decode(data)
+        return data
+
+    def flush(self) -> bytes:
+        data = b""
+        for child in self.children:
+            data = child.decode(data) + child.flush()
+        return data
+
+
+class ByteChunker:
+    """
+    Handles returning byte content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: int | None = None) -> None:
+        self._buffer = io.BytesIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: bytes) -> list[bytes]:
+        if self._chunk_size is None:
+            return [content] if content else []
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [
+                value[i : i + self._chunk_size]
+                for i in range(0, len(value), self._chunk_size)
+            ]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> list[bytes]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextChunker:
+    """
+    Handles returning text content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: int | None = None) -> None:
+        self._buffer = io.StringIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: str) -> list[str]:
+        if self._chunk_size is None:
+            return [content] if content else []
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [
+                value[i : i + self._chunk_size]
+                for i in range(0, len(value), self._chunk_size)
+            ]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> list[str]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextDecoder:
+    """
+    Handles incrementally decoding bytes into text
+    """
+
+    def __init__(self, encoding: str = "utf-8") -> None:
+        self.decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
+
+    def decode(self, data: bytes) -> str:
+        return self.decoder.decode(data)
+
+    def flush(self) -> str:
+        return self.decoder.decode(b"", True)
+
+
+class LineDecoder:
+    """
+    Handles incrementally reading lines from text.
+
+    Has the same behaviour as the stdllib splitlines,
+    but handling the input iteratively.
+    """
+
+    def __init__(self) -> None:
+        self.buffer: list[str] = []
+        self.trailing_cr: bool = False
+
+    def decode(self, text: str) -> list[str]:
+        # See https://docs.python.org/3/library/stdtypes.html#str.splitlines
+        NEWLINE_CHARS = "\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029"
+
+        # We always push a trailing `\r` into the next decode iteration.
+        if self.trailing_cr:
+            text = "\r" + text
+            self.trailing_cr = False
+        if text.endswith("\r"):
+            self.trailing_cr = True
+            text = text[:-1]
+
+        if not text:
+            # NOTE: the edge case input of empty text doesn't occur in practice,
+            # because other httpx internals filter out this value
+            return []  # pragma: no cover
+
+        trailing_newline = text[-1] in NEWLINE_CHARS
+        lines = text.splitlines()
+
+        if len(lines) == 1 and not trailing_newline:
+            # No new lines, buffer the input and continue.
+            self.buffer.append(lines[0])
+            return []
+
+        if self.buffer:
+            # Include any existing buffer in the first portion of the
+            # splitlines result.
+            lines = ["".join(self.buffer) + lines[0]] + lines[1:]
+            self.buffer = []
+
+        if not trailing_newline:
+            # If the last segment of splitlines is not newline terminated,
+            # then drop it from our output and start a new buffer.
+            self.buffer = [lines.pop()]
+
+        return lines
+
+    def flush(self) -> list[str]:
+        if not self.buffer and not self.trailing_cr:
+            return []
+
+        lines = ["".join(self.buffer)]
+        self.buffer = []
+        self.trailing_cr = False
+        return lines
+
+
+SUPPORTED_DECODERS = {
+    "identity": IdentityDecoder,
+    "gzip": GZipDecoder,
+    "deflate": DeflateDecoder,
+    "br": BrotliDecoder,
+    "zstd": ZStandardDecoder,
+}
+
+
+if brotli is None:
+    SUPPORTED_DECODERS.pop("br")  # pragma: no cover
+if zstandard is None:
+    SUPPORTED_DECODERS.pop("zstd")  # pragma: no cover
diff --git a/.venv/lib/python3.10/site-packages/httpx/_exceptions.py b/.venv/lib/python3.10/site-packages/httpx/_exceptions.py
new file mode 100644
index 0000000..77f45a6
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_exceptions.py
@@ -0,0 +1,379 @@
+"""
+Our exception hierarchy:
+
+* HTTPError
+  x RequestError
+    + TransportError
+      - TimeoutException
+        · ConnectTimeout
+        · ReadTimeout
+        · WriteTimeout
+        · PoolTimeout
+      - NetworkError
+        · ConnectError
+        · ReadError
+        · WriteError
+        · CloseError
+      - ProtocolError
+        · LocalProtocolError
+        · RemoteProtocolError
+      - ProxyError
+      - UnsupportedProtocol
+    + DecodingError
+    + TooManyRedirects
+  x HTTPStatusError
+* InvalidURL
+* CookieConflict
+* StreamError
+  x StreamConsumed
+  x StreamClosed
+  x ResponseNotRead
+  x RequestNotRead
+"""
+
+from __future__ import annotations
+
+import contextlib
+import typing
+
+if typing.TYPE_CHECKING:
+    from ._models import Request, Response  # pragma: no cover
+
+__all__ = [
+    "CloseError",
+    "ConnectError",
+    "ConnectTimeout",
+    "CookieConflict",
+    "DecodingError",
+    "HTTPError",
+    "HTTPStatusError",
+    "InvalidURL",
+    "LocalProtocolError",
+    "NetworkError",
+    "PoolTimeout",
+    "ProtocolError",
+    "ProxyError",
+    "ReadError",
+    "ReadTimeout",
+    "RemoteProtocolError",
+    "RequestError",
+    "RequestNotRead",
+    "ResponseNotRead",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "UnsupportedProtocol",
+    "WriteError",
+    "WriteTimeout",
+]
+
+
+class HTTPError(Exception):
+    """
+    Base class for `RequestError` and `HTTPStatusError`.
+
+    Useful for `try...except` blocks when issuing a request,
+    and then calling `.raise_for_status()`.
+
+    For example:
+
+    ```
+    try:
+        response = httpx.get("https://www.example.com")
+        response.raise_for_status()
+    except httpx.HTTPError as exc:
+        print(f"HTTP Exception for {exc.request.url} - {exc}")
+    ```
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self._request: Request | None = None
+
+    @property
+    def request(self) -> Request:
+        if self._request is None:
+            raise RuntimeError("The .request property has not been set.")
+        return self._request
+
+    @request.setter
+    def request(self, request: Request) -> None:
+        self._request = request
+
+
+class RequestError(HTTPError):
+    """
+    Base class for all exceptions that may occur when issuing a `.request()`.
+    """
+
+    def __init__(self, message: str, *, request: Request | None = None) -> None:
+        super().__init__(message)
+        # At the point an exception is raised we won't typically have a request
+        # instance to associate it with.
+        #
+        # The 'request_context' context manager is used within the Client and
+        # Response methods in order to ensure that any raised exceptions
+        # have a `.request` property set on them.
+        self._request = request
+
+
+class TransportError(RequestError):
+    """
+    Base class for all exceptions that occur at the level of the Transport API.
+    """
+
+
+# Timeout exceptions...
+
+
+class TimeoutException(TransportError):
+    """
+    The base class for timeout errors.
+
+    An operation has timed out.
+    """
+
+
+class ConnectTimeout(TimeoutException):
+    """
+    Timed out while connecting to the host.
+    """
+
+
+class ReadTimeout(TimeoutException):
+    """
+    Timed out while receiving data from the host.
+    """
+
+
+class WriteTimeout(TimeoutException):
+    """
+    Timed out while sending data to the host.
+    """
+
+
+class PoolTimeout(TimeoutException):
+    """
+    Timed out waiting to acquire a connection from the pool.
+    """
+
+
+# Core networking exceptions...
+
+
+class NetworkError(TransportError):
+    """
+    The base class for network-related errors.
+
+    An error occurred while interacting with the network.
+    """
+
+
+class ReadError(NetworkError):
+    """
+    Failed to receive data from the network.
+    """
+
+
+class WriteError(NetworkError):
+    """
+    Failed to send data through the network.
+    """
+
+
+class ConnectError(NetworkError):
+    """
+    Failed to establish a connection.
+    """
+
+
+class CloseError(NetworkError):
+    """
+    Failed to close a connection.
+    """
+
+
+# Other transport exceptions...
+
+
+class ProxyError(TransportError):
+    """
+    An error occurred while establishing a proxy connection.
+    """
+
+
+class UnsupportedProtocol(TransportError):
+    """
+    Attempted to make a request to an unsupported protocol.
+
+    For example issuing a request to `ftp://www.example.com`.
+    """
+
+
+class ProtocolError(TransportError):
+    """
+    The protocol was violated.
+    """
+
+
+class LocalProtocolError(ProtocolError):
+    """
+    A protocol was violated by the client.
+
+    For example if the user instantiated a `Request` instance explicitly,
+    failed to include the mandatory `Host:` header, and then issued it directly
+    using `client.send()`.
+    """
+
+
+class RemoteProtocolError(ProtocolError):
+    """
+    The protocol was violated by the server.
+
+    For example, returning malformed HTTP.
+    """
+
+
+# Other request exceptions...
+
+
+class DecodingError(RequestError):
+    """
+    Decoding of the response failed, due to a malformed encoding.
+    """
+
+
+class TooManyRedirects(RequestError):
+    """
+    Too many redirects.
+    """
+
+
+# Client errors
+
+
+class HTTPStatusError(HTTPError):
+    """
+    The response had an error HTTP status of 4xx or 5xx.
+
+    May be raised when calling `response.raise_for_status()`
+    """
+
+    def __init__(self, message: str, *, request: Request, response: Response) -> None:
+        super().__init__(message)
+        self.request = request
+        self.response = response
+
+
+class InvalidURL(Exception):
+    """
+    URL is improperly formed or cannot be parsed.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class CookieConflict(Exception):
+    """
+    Attempted to lookup a cookie by name, but multiple cookies existed.
+
+    Can occur when calling `response.cookies.get(...)`.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+# Stream exceptions...
+
+# These may occur as the result of a programming error, by accessing
+# the request/response stream in an invalid manner.
+
+
+class StreamError(RuntimeError):
+    """
+    The base class for stream exceptions.
+
+    The developer made an error in accessing the request stream in
+    an invalid way.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class StreamConsumed(StreamError):
+    """
+    Attempted to read or stream content, but the content has already
+    been streamed.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to read or stream some content, but the content has "
+            "already been streamed. For requests, this could be due to passing "
+            "a generator as request content, and then receiving a redirect "
+            "response or a secondary request as part of an authentication flow."
+            "For responses, this could be due to attempting to stream the response "
+            "content more than once."
+        )
+        super().__init__(message)
+
+
+class StreamClosed(StreamError):
+    """
+    Attempted to read or stream response content, but the request has been
+    closed.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to read or stream content, but the stream has " "been closed."
+        )
+        super().__init__(message)
+
+
+class ResponseNotRead(StreamError):
+    """
+    Attempted to access streaming response content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to access streaming response content,"
+            " without having called `read()`."
+        )
+        super().__init__(message)
+
+
+class RequestNotRead(StreamError):
+    """
+    Attempted to access streaming request content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to access streaming request content,"
+            " without having called `read()`."
+        )
+        super().__init__(message)
+
+
+@contextlib.contextmanager
+def request_context(
+    request: Request | None = None,
+) -> typing.Iterator[None]:
+    """
+    A context manager that can be used to attach the given request context
+    to any `RequestError` exceptions that are raised within the block.
+    """
+    try:
+        yield
+    except RequestError as exc:
+        if request is not None:
+            exc.request = request
+        raise exc
diff --git a/.venv/lib/python3.10/site-packages/httpx/_main.py b/.venv/lib/python3.10/site-packages/httpx/_main.py
new file mode 100644
index 0000000..cffa4bb
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_main.py
@@ -0,0 +1,506 @@
+from __future__ import annotations
+
+import functools
+import json
+import sys
+import typing
+
+import click
+import pygments.lexers
+import pygments.util
+import rich.console
+import rich.markup
+import rich.progress
+import rich.syntax
+import rich.table
+
+from ._client import Client
+from ._exceptions import RequestError
+from ._models import Response
+from ._status_codes import codes
+
+if typing.TYPE_CHECKING:
+    import httpcore  # pragma: no cover
+
+
+def print_help() -> None:
+    console = rich.console.Console()
+
+    console.print("[bold]HTTPX :butterfly:", justify="center")
+    console.print()
+    console.print("A next generation HTTP client.", justify="center")
+    console.print()
+    console.print(
+        "Usage: [bold]httpx[/bold] [cyan] [OPTIONS][/cyan] ", justify="left"
+    )
+    console.print()
+
+    table = rich.table.Table.grid(padding=1, pad_edge=True)
+    table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
+    table.add_column("Description")
+    table.add_row(
+        "-m, --method [cyan]METHOD",
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.\n"
+        "[Default: GET, or POST if a request body is included]",
+    )
+    table.add_row(
+        "-p, --params [cyan] ...",
+        "Query parameters to include in the request URL.",
+    )
+    table.add_row(
+        "-c, --content [cyan]TEXT", "Byte content to include in the request body."
+    )
+    table.add_row(
+        "-d, --data [cyan] ...", "Form data to include in the request body."
+    )
+    table.add_row(
+        "-f, --files [cyan] ...",
+        "Form files to include in the request body.",
+    )
+    table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
+    table.add_row(
+        "-h, --headers [cyan] ...",
+        "Include additional HTTP headers in the request.",
+    )
+    table.add_row(
+        "--cookies [cyan] ...", "Cookies to include in the request."
+    )
+    table.add_row(
+        "--auth [cyan]",
+        "Username and password to include in the request. Specify '-' for the password"
+        " to use a password prompt. Note that using --verbose/-v will expose"
+        " the Authorization header, including the password encoding"
+        " in a trivially reversible format.",
+    )
+
+    table.add_row(
+        "--proxy [cyan]URL",
+        "Send the request via a proxy. Should be the URL giving the proxy address.",
+    )
+
+    table.add_row(
+        "--timeout [cyan]FLOAT",
+        "Timeout value to use for network operations, such as establishing the"
+        " connection, reading some data, etc... [Default: 5.0]",
+    )
+
+    table.add_row("--follow-redirects", "Automatically follow redirects.")
+    table.add_row("--no-verify", "Disable SSL verification.")
+    table.add_row(
+        "--http2", "Send the request using HTTP/2, if the remote server supports it."
+    )
+
+    table.add_row(
+        "--download [cyan]FILE",
+        "Save the response content as a file, rather than displaying it.",
+    )
+
+    table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
+    table.add_row("--help", "Show this message and exit.")
+    console.print(table)
+
+
+def get_lexer_for_response(response: Response) -> str:
+    content_type = response.headers.get("Content-Type")
+    if content_type is not None:
+        mime_type, _, _ = content_type.partition(";")
+        try:
+            return typing.cast(
+                str, pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name
+            )
+        except pygments.util.ClassNotFound:  # pragma: no cover
+            pass
+    return ""  # pragma: no cover
+
+
+def format_request_headers(request: httpcore.Request, http2: bool = False) -> str:
+    version = "HTTP/2" if http2 else "HTTP/1.1"
+    headers = [
+        (name.lower() if http2 else name, value) for name, value in request.headers
+    ]
+    method = request.method.decode("ascii")
+    target = request.url.target.decode("ascii")
+    lines = [f"{method} {target} {version}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def format_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> str:
+    version = http_version.decode("ascii")
+    reason = (
+        codes.get_reason_phrase(status)
+        if reason_phrase is None
+        else reason_phrase.decode("ascii")
+    )
+    lines = [f"{version} {status} {reason}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def print_request_headers(request: httpcore.Request, http2: bool = False) -> None:
+    console = rich.console.Console()
+    http_text = format_request_headers(request, http2=http2)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> None:
+    console = rich.console.Console()
+    http_text = format_response_headers(http_version, status, reason_phrase, headers)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response(response: Response) -> None:
+    console = rich.console.Console()
+    lexer_name = get_lexer_for_response(response)
+    if lexer_name:
+        if lexer_name.lower() == "json":
+            try:
+                data = response.json()
+                text = json.dumps(data, indent=4)
+            except ValueError:  # pragma: no cover
+                text = response.text
+        else:
+            text = response.text
+
+        syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
+        console.print(syntax)
+    else:
+        console.print(f"<{len(response.content)} bytes of binary data>")
+
+
+_PCTRTT = typing.Tuple[typing.Tuple[str, str], ...]
+_PCTRTTT = typing.Tuple[_PCTRTT, ...]
+_PeerCertRetDictType = typing.Dict[str, typing.Union[str, _PCTRTTT, _PCTRTT]]
+
+
+def format_certificate(cert: _PeerCertRetDictType) -> str:  # pragma: no cover
+    lines = []
+    for key, value in cert.items():
+        if isinstance(value, (list, tuple)):
+            lines.append(f"*   {key}:")
+            for item in value:
+                if key in ("subject", "issuer"):
+                    for sub_item in item:
+                        lines.append(f"*     {sub_item[0]}: {sub_item[1]!r}")
+                elif isinstance(item, tuple) and len(item) == 2:
+                    lines.append(f"*     {item[0]}: {item[1]!r}")
+                else:
+                    lines.append(f"*     {item!r}")
+        else:
+            lines.append(f"*   {key}: {value!r}")
+    return "\n".join(lines)
+
+
+def trace(
+    name: str, info: typing.Mapping[str, typing.Any], verbose: bool = False
+) -> None:
+    console = rich.console.Console()
+    if name == "connection.connect_tcp.started" and verbose:
+        host = info["host"]
+        console.print(f"* Connecting to {host!r}")
+    elif name == "connection.connect_tcp.complete" and verbose:
+        stream = info["return_value"]
+        server_addr = stream.get_extra_info("server_addr")
+        console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
+    elif name == "connection.start_tls.complete" and verbose:  # pragma: no cover
+        stream = info["return_value"]
+        ssl_object = stream.get_extra_info("ssl_object")
+        version = ssl_object.version()
+        cipher = ssl_object.cipher()
+        server_cert = ssl_object.getpeercert()
+        alpn = ssl_object.selected_alpn_protocol()
+        console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
+        console.print(f"* Selected ALPN protocol: {alpn!r}")
+        if server_cert:
+            console.print("* Server certificate:")
+            console.print(format_certificate(server_cert))
+    elif name == "http11.send_request_headers.started" and verbose:
+        request = info["request"]
+        print_request_headers(request, http2=False)
+    elif name == "http2.send_request_headers.started" and verbose:  # pragma: no cover
+        request = info["request"]
+        print_request_headers(request, http2=True)
+    elif name == "http11.receive_response_headers.complete":
+        http_version, status, reason_phrase, headers = info["return_value"]
+        print_response_headers(http_version, status, reason_phrase, headers)
+    elif name == "http2.receive_response_headers.complete":  # pragma: no cover
+        status, headers = info["return_value"]
+        http_version = b"HTTP/2"
+        reason_phrase = None
+        print_response_headers(http_version, status, reason_phrase, headers)
+
+
+def download_response(response: Response, download: typing.BinaryIO) -> None:
+    console = rich.console.Console()
+    console.print()
+    content_length = response.headers.get("Content-Length")
+    with rich.progress.Progress(
+        "[progress.description]{task.description}",
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        rich.progress.BarColumn(bar_width=None),
+        rich.progress.DownloadColumn(),
+        rich.progress.TransferSpeedColumn(),
+    ) as progress:
+        description = f"Downloading [bold]{rich.markup.escape(download.name)}"
+        download_task = progress.add_task(
+            description,
+            total=int(content_length or 0),
+            start=content_length is not None,
+        )
+        for chunk in response.iter_bytes():
+            download.write(chunk)
+            progress.update(download_task, completed=response.num_bytes_downloaded)
+
+
+def validate_json(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value is None:
+        return None
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:  # pragma: no cover
+        raise click.BadParameter("Not valid JSON")
+
+
+def validate_auth(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value == (None, None):
+        return None
+
+    username, password = value
+    if password == "-":  # pragma: no cover
+        password = click.prompt("Password", hide_input=True)
+    return (username, password)
+
+
+def handle_help(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> None:
+    if not value or ctx.resilient_parsing:
+        return
+
+    print_help()
+    ctx.exit()
+
+
+@click.command(add_help_option=False)
+@click.argument("url", type=str)
+@click.option(
+    "--method",
+    "-m",
+    "method",
+    type=str,
+    help=(
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD. "
+        "[Default: GET, or POST if a request body is included]"
+    ),
+)
+@click.option(
+    "--params",
+    "-p",
+    "params",
+    type=(str, str),
+    multiple=True,
+    help="Query parameters to include in the request URL.",
+)
+@click.option(
+    "--content",
+    "-c",
+    "content",
+    type=str,
+    help="Byte content to include in the request body.",
+)
+@click.option(
+    "--data",
+    "-d",
+    "data",
+    type=(str, str),
+    multiple=True,
+    help="Form data to include in the request body.",
+)
+@click.option(
+    "--files",
+    "-f",
+    "files",
+    type=(str, click.File(mode="rb")),
+    multiple=True,
+    help="Form files to include in the request body.",
+)
+@click.option(
+    "--json",
+    "-j",
+    "json",
+    type=str,
+    callback=validate_json,
+    help="JSON data to include in the request body.",
+)
+@click.option(
+    "--headers",
+    "-h",
+    "headers",
+    type=(str, str),
+    multiple=True,
+    help="Include additional HTTP headers in the request.",
+)
+@click.option(
+    "--cookies",
+    "cookies",
+    type=(str, str),
+    multiple=True,
+    help="Cookies to include in the request.",
+)
+@click.option(
+    "--auth",
+    "auth",
+    type=(str, str),
+    default=(None, None),
+    callback=validate_auth,
+    help=(
+        "Username and password to include in the request. "
+        "Specify '-' for the password to use a password prompt. "
+        "Note that using --verbose/-v will expose the Authorization header, "
+        "including the password encoding in a trivially reversible format."
+    ),
+)
+@click.option(
+    "--proxy",
+    "proxy",
+    type=str,
+    default=None,
+    help="Send the request via a proxy. Should be the URL giving the proxy address.",
+)
+@click.option(
+    "--timeout",
+    "timeout",
+    type=float,
+    default=5.0,
+    help=(
+        "Timeout value to use for network operations, such as establishing the "
+        "connection, reading some data, etc... [Default: 5.0]"
+    ),
+)
+@click.option(
+    "--follow-redirects",
+    "follow_redirects",
+    is_flag=True,
+    default=False,
+    help="Automatically follow redirects.",
+)
+@click.option(
+    "--no-verify",
+    "verify",
+    is_flag=True,
+    default=True,
+    help="Disable SSL verification.",
+)
+@click.option(
+    "--http2",
+    "http2",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Send the request using HTTP/2, if the remote server supports it.",
+)
+@click.option(
+    "--download",
+    type=click.File("wb"),
+    help="Save the response content as a file, rather than displaying it.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Verbose. Show request as well as response.",
+)
+@click.option(
+    "--help",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=handle_help,
+    help="Show this message and exit.",
+)
+def main(
+    url: str,
+    method: str,
+    params: list[tuple[str, str]],
+    content: str,
+    data: list[tuple[str, str]],
+    files: list[tuple[str, click.File]],
+    json: str,
+    headers: list[tuple[str, str]],
+    cookies: list[tuple[str, str]],
+    auth: tuple[str, str] | None,
+    proxy: str,
+    timeout: float,
+    follow_redirects: bool,
+    verify: bool,
+    http2: bool,
+    download: typing.BinaryIO | None,
+    verbose: bool,
+) -> None:
+    """
+    An HTTP command line client.
+    Sends a request and displays the response.
+    """
+    if not method:
+        method = "POST" if content or data or files or json else "GET"
+
+    try:
+        with Client(proxy=proxy, timeout=timeout, http2=http2, verify=verify) as client:
+            with client.stream(
+                method,
+                url,
+                params=list(params),
+                content=content,
+                data=dict(data),
+                files=files,  # type: ignore
+                json=json,
+                headers=headers,
+                cookies=dict(cookies),
+                auth=auth,
+                follow_redirects=follow_redirects,
+                extensions={"trace": functools.partial(trace, verbose=verbose)},
+            ) as response:
+                if download is not None:
+                    download_response(response, download)
+                else:
+                    response.read()
+                    if response.content:
+                        print_response(response)
+
+    except RequestError as exc:
+        console = rich.console.Console()
+        console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
+        sys.exit(1)
+
+    sys.exit(0 if response.is_success else 1)
diff --git a/.venv/lib/python3.10/site-packages/httpx/_models.py b/.venv/lib/python3.10/site-packages/httpx/_models.py
new file mode 100644
index 0000000..67d74bf
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_models.py
@@ -0,0 +1,1277 @@
+from __future__ import annotations
+
+import codecs
+import datetime
+import email.message
+import json as jsonlib
+import re
+import typing
+import urllib.request
+from collections.abc import Mapping
+from http.cookiejar import Cookie, CookieJar
+
+from ._content import ByteStream, UnattachedStream, encode_request, encode_response
+from ._decoders import (
+    SUPPORTED_DECODERS,
+    ByteChunker,
+    ContentDecoder,
+    IdentityDecoder,
+    LineDecoder,
+    MultiDecoder,
+    TextChunker,
+    TextDecoder,
+)
+from ._exceptions import (
+    CookieConflict,
+    HTTPStatusError,
+    RequestNotRead,
+    ResponseNotRead,
+    StreamClosed,
+    StreamConsumed,
+    request_context,
+)
+from ._multipart import get_multipart_boundary_from_content_type
+from ._status_codes import codes
+from ._types import (
+    AsyncByteStream,
+    CookieTypes,
+    HeaderTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestExtensions,
+    RequestFiles,
+    ResponseContent,
+    ResponseExtensions,
+    SyncByteStream,
+)
+from ._urls import URL
+from ._utils import to_bytes_or_str, to_str
+
+__all__ = ["Cookies", "Headers", "Request", "Response"]
+
+SENSITIVE_HEADERS = {"authorization", "proxy-authorization"}
+
+
+def _is_known_encoding(encoding: str) -> bool:
+    """
+    Return `True` if `encoding` is a known codec.
+    """
+    try:
+        codecs.lookup(encoding)
+    except LookupError:
+        return False
+    return True
+
+
+def _normalize_header_key(key: str | bytes, encoding: str | None = None) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header key.
+    """
+    return key if isinstance(key, bytes) else key.encode(encoding or "ascii")
+
+
+def _normalize_header_value(value: str | bytes, encoding: str | None = None) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header value.
+    """
+    if isinstance(value, bytes):
+        return value
+    if not isinstance(value, str):
+        raise TypeError(f"Header value must be str or bytes, not {type(value)}")
+    return value.encode(encoding or "ascii")
+
+
+def _parse_content_type_charset(content_type: str) -> str | None:
+    # We used to use `cgi.parse_header()` here, but `cgi` became a dead battery.
+    # See: https://peps.python.org/pep-0594/#cgi
+    msg = email.message.Message()
+    msg["content-type"] = content_type
+    return msg.get_content_charset(failobj=None)
+
+
+def _parse_header_links(value: str) -> list[dict[str, str]]:
+    """
+    Returns a list of parsed link headers, for more info see:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
+    The generic syntax of those is:
+    Link: < uri-reference >; param1=value1; param2="value2"
+    So for instance:
+    Link; '; type="image/jpeg",;'
+    would return
+        [
+            {"url": "http:/.../front.jpeg", "type": "image/jpeg"},
+            {"url": "http://.../back.jpeg"},
+        ]
+    :param value: HTTP Link entity-header field
+    :return: list of parsed link headers
+    """
+    links: list[dict[str, str]] = []
+    replace_chars = " '\""
+    value = value.strip(replace_chars)
+    if not value:
+        return links
+    for val in re.split(", *<", value):
+        try:
+            url, params = val.split(";", 1)
+        except ValueError:
+            url, params = val, ""
+        link = {"url": url.strip("<> '\"")}
+        for param in params.split(";"):
+            try:
+                key, value = param.split("=")
+            except ValueError:
+                break
+            link[key.strip(replace_chars)] = value.strip(replace_chars)
+        links.append(link)
+    return links
+
+
+def _obfuscate_sensitive_headers(
+    items: typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]],
+) -> typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]:
+    for k, v in items:
+        if to_str(k.lower()) in SENSITIVE_HEADERS:
+            v = to_bytes_or_str("[secure]", match_type_of=v)
+        yield k, v
+
+
+class Headers(typing.MutableMapping[str, str]):
+    """
+    HTTP headers, as a case-insensitive multi-dict.
+    """
+
+    def __init__(
+        self,
+        headers: HeaderTypes | None = None,
+        encoding: str | None = None,
+    ) -> None:
+        self._list = []  # type: typing.List[typing.Tuple[bytes, bytes, bytes]]
+
+        if isinstance(headers, Headers):
+            self._list = list(headers._list)
+        elif isinstance(headers, Mapping):
+            for k, v in headers.items():
+                bytes_key = _normalize_header_key(k, encoding)
+                bytes_value = _normalize_header_value(v, encoding)
+                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
+        elif headers is not None:
+            for k, v in headers:
+                bytes_key = _normalize_header_key(k, encoding)
+                bytes_value = _normalize_header_value(v, encoding)
+                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
+
+        self._encoding = encoding
+
+    @property
+    def encoding(self) -> str:
+        """
+        Header encoding is mandated as ascii, but we allow fallbacks to utf-8
+        or iso-8859-1.
+        """
+        if self._encoding is None:
+            for encoding in ["ascii", "utf-8"]:
+                for key, value in self.raw:
+                    try:
+                        key.decode(encoding)
+                        value.decode(encoding)
+                    except UnicodeDecodeError:
+                        break
+                else:
+                    # The else block runs if 'break' did not occur, meaning
+                    # all values fitted the encoding.
+                    self._encoding = encoding
+                    break
+            else:
+                # The ISO-8859-1 encoding covers all 256 code points in a byte,
+                # so will never raise decode errors.
+                self._encoding = "iso-8859-1"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        self._encoding = value
+
+    @property
+    def raw(self) -> list[tuple[bytes, bytes]]:
+        """
+        Returns a list of the raw header items, as byte pairs.
+        """
+        return [(raw_key, value) for raw_key, _, value in self._list]
+
+    def keys(self) -> typing.KeysView[str]:
+        return {key.decode(self.encoding): None for _, key, value in self._list}.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        values_dict: dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return `(key, value)` items of headers. Concatenate headers
+        into a single comma separated value when a key occurs multiple times.
+        """
+        values_dict: dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return a list of `(key, value)` pairs of headers. Allow multiple
+        occurrences of the same key without concatenating into a single
+        comma separated value.
+        """
+        return [
+            (key.decode(self.encoding), value.decode(self.encoding))
+            for _, key, value in self._list
+        ]
+
+    def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        """
+        Return a header value. If multiple occurrences of the header occur
+        then concatenate them together with commas.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def get_list(self, key: str, split_commas: bool = False) -> list[str]:
+        """
+        Return a list of all header values for a given key.
+        If `split_commas=True` is passed, then any comma separated header
+        values are split into multiple return strings.
+        """
+        get_header_key = key.lower().encode(self.encoding)
+
+        values = [
+            item_value.decode(self.encoding)
+            for _, item_key, item_value in self._list
+            if item_key.lower() == get_header_key
+        ]
+
+        if not split_commas:
+            return values
+
+        split_values = []
+        for value in values:
+            split_values.extend([item.strip() for item in value.split(",")])
+        return split_values
+
+    def update(self, headers: HeaderTypes | None = None) -> None:  # type: ignore
+        headers = Headers(headers)
+        for key in headers.keys():
+            if key in self:
+                self.pop(key)
+        self._list.extend(headers._list)
+
+    def copy(self) -> Headers:
+        return Headers(self, encoding=self.encoding)
+
+    def __getitem__(self, key: str) -> str:
+        """
+        Return a single header value.
+
+        If there are multiple headers with the same key, then we concatenate
+        them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2
+        """
+        normalized_key = key.lower().encode(self.encoding)
+
+        items = [
+            header_value.decode(self.encoding)
+            for _, header_key, header_value in self._list
+            if header_key == normalized_key
+        ]
+
+        if items:
+            return ", ".join(items)
+
+        raise KeyError(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        """
+        Set the header `key` to `value`, removing any duplicate entries.
+        Retains insertion order.
+        """
+        set_key = key.encode(self._encoding or "utf-8")
+        set_value = value.encode(self._encoding or "utf-8")
+        lookup_key = set_key.lower()
+
+        found_indexes = [
+            idx
+            for idx, (_, item_key, _) in enumerate(self._list)
+            if item_key == lookup_key
+        ]
+
+        for idx in reversed(found_indexes[1:]):
+            del self._list[idx]
+
+        if found_indexes:
+            idx = found_indexes[0]
+            self._list[idx] = (set_key, lookup_key, set_value)
+        else:
+            self._list.append((set_key, lookup_key, set_value))
+
+    def __delitem__(self, key: str) -> None:
+        """
+        Remove the header `key`.
+        """
+        del_key = key.lower().encode(self.encoding)
+
+        pop_indexes = [
+            idx
+            for idx, (_, item_key, _) in enumerate(self._list)
+            if item_key.lower() == del_key
+        ]
+
+        if not pop_indexes:
+            raise KeyError(key)
+
+        for idx in reversed(pop_indexes):
+            del self._list[idx]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        header_key = key.lower().encode(self.encoding)
+        return header_key in [key for _, key, _ in self._list]
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        try:
+            other_headers = Headers(other)
+        except ValueError:
+            return False
+
+        self_list = [(key, value) for _, key, value in self._list]
+        other_list = [(key, value) for _, key, value in other_headers._list]
+        return sorted(self_list) == sorted(other_list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+
+        encoding_str = ""
+        if self.encoding != "ascii":
+            encoding_str = f", encoding={self.encoding!r}"
+
+        as_list = list(_obfuscate_sensitive_headers(self.multi_items()))
+        as_dict = dict(as_list)
+
+        no_duplicate_keys = len(as_dict) == len(as_list)
+        if no_duplicate_keys:
+            return f"{class_name}({as_dict!r}{encoding_str})"
+        return f"{class_name}({as_list!r}{encoding_str})"
+
+
+class Request:
+    def __init__(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        extensions: RequestExtensions | None = None,
+    ) -> None:
+        self.method = method.upper()
+        self.url = URL(url) if params is None else URL(url, params=params)
+        self.headers = Headers(headers)
+        self.extensions = {} if extensions is None else dict(extensions)
+
+        if cookies:
+            Cookies(cookies).set_cookie_header(self)
+
+        if stream is None:
+            content_type: str | None = self.headers.get("content-type")
+            headers, stream = encode_request(
+                content=content,
+                data=data,
+                files=files,
+                json=json,
+                boundary=get_multipart_boundary_from_content_type(
+                    content_type=content_type.encode(self.headers.encoding)
+                    if content_type
+                    else None
+                ),
+            )
+            self._prepare(headers)
+            self.stream = stream
+            # Load the request body, except for streaming content.
+            if isinstance(stream, ByteStream):
+                self.read()
+        else:
+            # There's an important distinction between `Request(content=...)`,
+            # and `Request(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated `Host` and content
+            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include *any*
+            # auto-populated headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when:
+            #
+            # * Preserving the request stream when copying requests, eg for redirects.
+            # * Creating request instances on the *server-side* of the transport API.
+            self.stream = stream
+
+    def _prepare(self, default_headers: dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "Content-Length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+        auto_headers: list[tuple[bytes, bytes]] = []
+
+        has_host = "Host" in self.headers
+        has_content_length = (
+            "Content-Length" in self.headers or "Transfer-Encoding" in self.headers
+        )
+
+        if not has_host and self.url.host:
+            auto_headers.append((b"Host", self.url.netloc))
+        if not has_content_length and self.method in ("POST", "PUT", "PATCH"):
+            auto_headers.append((b"Content-Length", b"0"))
+
+        self.headers = Headers(auto_headers + self.headers.raw)
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise RequestNotRead()
+        return self._content
+
+    def read(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.Iterable)
+            self._content = b"".join(self.stream)
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.AsyncIterable)
+            self._content = b"".join([part async for part in self.stream])
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        url = str(self.url)
+        return f"<{class_name}({self.method!r}, {url!r})>"
+
+    def __getstate__(self) -> dict[str, typing.Any]:
+        return {
+            name: value
+            for name, value in self.__dict__.items()
+            if name not in ["extensions", "stream"]
+        }
+
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+
+class Response:
+    def __init__(
+        self,
+        status_code: int,
+        *,
+        headers: HeaderTypes | None = None,
+        content: ResponseContent | None = None,
+        text: str | None = None,
+        html: str | None = None,
+        json: typing.Any = None,
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        request: Request | None = None,
+        extensions: ResponseExtensions | None = None,
+        history: list[Response] | None = None,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
+        self.status_code = status_code
+        self.headers = Headers(headers)
+
+        self._request: Request | None = request
+
+        # When follow_redirects=False and a redirect is received,
+        # the client will set `response.next_request`.
+        self.next_request: Request | None = None
+
+        self.extensions = {} if extensions is None else dict(extensions)
+        self.history = [] if history is None else list(history)
+
+        self.is_closed = False
+        self.is_stream_consumed = False
+
+        self.default_encoding = default_encoding
+
+        if stream is None:
+            headers, stream = encode_response(content, text, html, json)
+            self._prepare(headers)
+            self.stream = stream
+            if isinstance(stream, ByteStream):
+                # Load the response body, except for streaming content.
+                self.read()
+        else:
+            # There's an important distinction between `Response(content=...)`,
+            # and `Response(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated content headers,
+            # of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include any content headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when creating response instances having received a stream
+            # from the transport API.
+            self.stream = stream
+
+        self._num_bytes_downloaded = 0
+
+    def _prepare(self, default_headers: dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "content-length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+    @property
+    def elapsed(self) -> datetime.timedelta:
+        """
+        Returns the time taken for the complete request/response
+        cycle to complete.
+        """
+        if not hasattr(self, "_elapsed"):
+            raise RuntimeError(
+                "'.elapsed' may only be accessed after the response "
+                "has been read or closed."
+            )
+        return self._elapsed
+
+    @elapsed.setter
+    def elapsed(self, elapsed: datetime.timedelta) -> None:
+        self._elapsed = elapsed
+
+    @property
+    def request(self) -> Request:
+        """
+        Returns the request instance associated to the current response.
+        """
+        if self._request is None:
+            raise RuntimeError(
+                "The request instance has not been set on this response."
+            )
+        return self._request
+
+    @request.setter
+    def request(self, value: Request) -> None:
+        self._request = value
+
+    @property
+    def http_version(self) -> str:
+        try:
+            http_version: bytes = self.extensions["http_version"]
+        except KeyError:
+            return "HTTP/1.1"
+        else:
+            return http_version.decode("ascii", errors="ignore")
+
+    @property
+    def reason_phrase(self) -> str:
+        try:
+            reason_phrase: bytes = self.extensions["reason_phrase"]
+        except KeyError:
+            return codes.get_reason_phrase(self.status_code)
+        else:
+            return reason_phrase.decode("ascii", errors="ignore")
+
+    @property
+    def url(self) -> URL:
+        """
+        Returns the URL for which the request was made.
+        """
+        return self.request.url
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise ResponseNotRead()
+        return self._content
+
+    @property
+    def text(self) -> str:
+        if not hasattr(self, "_text"):
+            content = self.content
+            if not content:
+                self._text = ""
+            else:
+                decoder = TextDecoder(encoding=self.encoding or "utf-8")
+                self._text = "".join([decoder.decode(self.content), decoder.flush()])
+        return self._text
+
+    @property
+    def encoding(self) -> str | None:
+        """
+        Return an encoding to use for decoding the byte content into text.
+        The priority for determining this is given by...
+
+        * `.encoding = <>` has been set explicitly.
+        * The encoding as specified by the charset parameter in the Content-Type header.
+        * The encoding as determined by `default_encoding`, which may either be
+          a string like "utf-8" indicating the encoding to use, or may be a callable
+          which enables charset autodetection.
+        """
+        if not hasattr(self, "_encoding"):
+            encoding = self.charset_encoding
+            if encoding is None or not _is_known_encoding(encoding):
+                if isinstance(self.default_encoding, str):
+                    encoding = self.default_encoding
+                elif hasattr(self, "_content"):
+                    encoding = self.default_encoding(self._content)
+            self._encoding = encoding or "utf-8"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        """
+        Set the encoding to use for decoding the byte content into text.
+
+        If the `text` attribute has been accessed, attempting to set the
+        encoding will throw a ValueError.
+        """
+        if hasattr(self, "_text"):
+            raise ValueError(
+                "Setting encoding after `text` has been accessed is not allowed."
+            )
+        self._encoding = value
+
+    @property
+    def charset_encoding(self) -> str | None:
+        """
+        Return the encoding, as specified by the Content-Type header.
+        """
+        content_type = self.headers.get("Content-Type")
+        if content_type is None:
+            return None
+
+        return _parse_content_type_charset(content_type)
+
+    def _get_content_decoder(self) -> ContentDecoder:
+        """
+        Returns a decoder instance which can be used to decode the raw byte
+        content, depending on the Content-Encoding used in the response.
+        """
+        if not hasattr(self, "_decoder"):
+            decoders: list[ContentDecoder] = []
+            values = self.headers.get_list("content-encoding", split_commas=True)
+            for value in values:
+                value = value.strip().lower()
+                try:
+                    decoder_cls = SUPPORTED_DECODERS[value]
+                    decoders.append(decoder_cls())
+                except KeyError:
+                    continue
+
+            if len(decoders) == 1:
+                self._decoder = decoders[0]
+            elif len(decoders) > 1:
+                self._decoder = MultiDecoder(children=decoders)
+            else:
+                self._decoder = IdentityDecoder()
+
+        return self._decoder
+
+    @property
+    def is_informational(self) -> bool:
+        """
+        A property which is `True` for 1xx status codes, `False` otherwise.
+        """
+        return codes.is_informational(self.status_code)
+
+    @property
+    def is_success(self) -> bool:
+        """
+        A property which is `True` for 2xx status codes, `False` otherwise.
+        """
+        return codes.is_success(self.status_code)
+
+    @property
+    def is_redirect(self) -> bool:
+        """
+        A property which is `True` for 3xx status codes, `False` otherwise.
+
+        Note that not all responses with a 3xx status code indicate a URL redirect.
+
+        Use `response.has_redirect_location` to determine responses with a properly
+        formed URL redirection.
+        """
+        return codes.is_redirect(self.status_code)
+
+    @property
+    def is_client_error(self) -> bool:
+        """
+        A property which is `True` for 4xx status codes, `False` otherwise.
+        """
+        return codes.is_client_error(self.status_code)
+
+    @property
+    def is_server_error(self) -> bool:
+        """
+        A property which is `True` for 5xx status codes, `False` otherwise.
+        """
+        return codes.is_server_error(self.status_code)
+
+    @property
+    def is_error(self) -> bool:
+        """
+        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
+        """
+        return codes.is_error(self.status_code)
+
+    @property
+    def has_redirect_location(self) -> bool:
+        """
+        Returns True for 3xx responses with a properly formed URL redirection,
+        `False` otherwise.
+        """
+        return (
+            self.status_code
+            in (
+                # 301 (Cacheable redirect. Method may change to GET.)
+                codes.MOVED_PERMANENTLY,
+                # 302 (Uncacheable redirect. Method may change to GET.)
+                codes.FOUND,
+                # 303 (Client should make a GET or HEAD request.)
+                codes.SEE_OTHER,
+                # 307 (Equiv. 302, but retain method)
+                codes.TEMPORARY_REDIRECT,
+                # 308 (Equiv. 301, but retain method)
+                codes.PERMANENT_REDIRECT,
+            )
+            and "Location" in self.headers
+        )
+
+    def raise_for_status(self) -> Response:
+        """
+        Raise the `HTTPStatusError` if one occurred.
+        """
+        request = self._request
+        if request is None:
+            raise RuntimeError(
+                "Cannot call `raise_for_status` as the request "
+                "instance has not been set on this response."
+            )
+
+        if self.is_success:
+            return self
+
+        if self.has_redirect_location:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "Redirect location: '{0.headers[location]}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+        else:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+
+        status_class = self.status_code // 100
+        error_types = {
+            1: "Informational response",
+            3: "Redirect response",
+            4: "Client error",
+            5: "Server error",
+        }
+        error_type = error_types.get(status_class, "Invalid status code")
+        message = message.format(self, error_type=error_type)
+        raise HTTPStatusError(message, request=request, response=self)
+
+    def json(self, **kwargs: typing.Any) -> typing.Any:
+        return jsonlib.loads(self.content, **kwargs)
+
+    @property
+    def cookies(self) -> Cookies:
+        if not hasattr(self, "_cookies"):
+            self._cookies = Cookies()
+            self._cookies.extract_cookies(self)
+        return self._cookies
+
+    @property
+    def links(self) -> dict[str | None, dict[str, str]]:
+        """
+        Returns the parsed header links of the response, if any
+        """
+        header = self.headers.get("link")
+        if header is None:
+            return {}
+
+        return {
+            (link.get("rel") or link.get("url")): link
+            for link in _parse_header_links(header)
+        }
+
+    @property
+    def num_bytes_downloaded(self) -> int:
+        return self._num_bytes_downloaded
+
+    def __repr__(self) -> str:
+        return f""
+
+    def __getstate__(self) -> dict[str, typing.Any]:
+        return {
+            name: value
+            for name, value in self.__dict__.items()
+            if name not in ["extensions", "stream", "is_closed", "_decoder"]
+        }
+
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.is_closed = True
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+    def read(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            self._content = b"".join(self.iter_bytes())
+        return self._content
+
+    def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                for raw_bytes in self.iter_raw():
+                    decoded = decoder.decode(raw_bytes)
+                    for chunk in chunker.decode(decoded):
+                        yield chunk
+                decoded = decoder.flush()
+                for chunk in chunker.decode(decoded):
+                    yield chunk  # pragma: no cover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            for byte_content in self.iter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk  # pragma: no cover
+            for chunk in chunker.flush():
+                yield chunk
+
+    def iter_lines(self) -> typing.Iterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            for text in self.iter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call a sync iterator on an async stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        with request_context(request=self._request):
+            for raw_stream_bytes in self.stream:
+                self._num_bytes_downloaded += len(raw_stream_bytes)
+                for chunk in chunker.decode(raw_stream_bytes):
+                    yield chunk
+
+        for chunk in chunker.flush():
+            yield chunk
+
+        self.close()
+
+    def close(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call an sync close on an async stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                self.stream.close()
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part async for part in self.aiter_bytes()])
+        return self._content
+
+    async def aiter_bytes(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[bytes]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                async for raw_bytes in self.aiter_raw():
+                    decoded = decoder.decode(raw_bytes)
+                    for chunk in chunker.decode(decoded):
+                        yield chunk
+                decoded = decoder.flush()
+                for chunk in chunker.decode(decoded):
+                    yield chunk  # pragma: no cover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    async def aiter_text(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            async for byte_content in self.aiter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk  # pragma: no cover
+            for chunk in chunker.flush():
+                yield chunk
+
+    async def aiter_lines(self) -> typing.AsyncIterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            async for text in self.aiter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    async def aiter_raw(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[bytes]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async iterator on an sync stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        with request_context(request=self._request):
+            async for raw_stream_bytes in self.stream:
+                self._num_bytes_downloaded += len(raw_stream_bytes)
+                for chunk in chunker.decode(raw_stream_bytes):
+                    yield chunk
+
+        for chunk in chunker.flush():
+            yield chunk
+
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async close on an sync stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                await self.stream.aclose()
+
+
+class Cookies(typing.MutableMapping[str, str]):
+    """
+    HTTP Cookies, as a mutable mapping.
+    """
+
+    def __init__(self, cookies: CookieTypes | None = None) -> None:
+        if cookies is None or isinstance(cookies, dict):
+            self.jar = CookieJar()
+            if isinstance(cookies, dict):
+                for key, value in cookies.items():
+                    self.set(key, value)
+        elif isinstance(cookies, list):
+            self.jar = CookieJar()
+            for key, value in cookies:
+                self.set(key, value)
+        elif isinstance(cookies, Cookies):
+            self.jar = CookieJar()
+            for cookie in cookies.jar:
+                self.jar.set_cookie(cookie)
+        else:
+            self.jar = cookies
+
+    def extract_cookies(self, response: Response) -> None:
+        """
+        Loads any cookies based on the response `Set-Cookie` headers.
+        """
+        urllib_response = self._CookieCompatResponse(response)
+        urllib_request = self._CookieCompatRequest(response.request)
+
+        self.jar.extract_cookies(urllib_response, urllib_request)  # type: ignore
+
+    def set_cookie_header(self, request: Request) -> None:
+        """
+        Sets an appropriate 'Cookie:' HTTP header on the `Request`.
+        """
+        urllib_request = self._CookieCompatRequest(request)
+        self.jar.add_cookie_header(urllib_request)
+
+    def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None:
+        """
+        Set a cookie value by name. May optionally include domain and path.
+        """
+        kwargs = {
+            "version": 0,
+            "name": name,
+            "value": value,
+            "port": None,
+            "port_specified": False,
+            "domain": domain,
+            "domain_specified": bool(domain),
+            "domain_initial_dot": domain.startswith("."),
+            "path": path,
+            "path_specified": bool(path),
+            "secure": False,
+            "expires": None,
+            "discard": True,
+            "comment": None,
+            "comment_url": None,
+            "rest": {"HttpOnly": None},
+            "rfc2109": False,
+        }
+        cookie = Cookie(**kwargs)  # type: ignore
+        self.jar.set_cookie(cookie)
+
+    def get(  # type: ignore
+        self,
+        name: str,
+        default: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> str | None:
+        """
+        Get a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to retrieve.
+        """
+        value = None
+        for cookie in self.jar:
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        if value is not None:
+                            message = f"Multiple cookies exist with name={name}"
+                            raise CookieConflict(message)
+                        value = cookie.value
+
+        if value is None:
+            return default
+        return value
+
+    def delete(
+        self,
+        name: str,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> None:
+        """
+        Delete a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to delete.
+        """
+        if domain is not None and path is not None:
+            return self.jar.clear(domain, path, name)
+
+        remove = [
+            cookie
+            for cookie in self.jar
+            if cookie.name == name
+            and (domain is None or cookie.domain == domain)
+            and (path is None or cookie.path == path)
+        ]
+
+        for cookie in remove:
+            self.jar.clear(cookie.domain, cookie.path, cookie.name)
+
+    def clear(self, domain: str | None = None, path: str | None = None) -> None:
+        """
+        Delete all cookies. Optionally include a domain and path in
+        order to only delete a subset of all the cookies.
+        """
+        args = []
+        if domain is not None:
+            args.append(domain)
+        if path is not None:
+            assert domain is not None
+            args.append(path)
+        self.jar.clear(*args)
+
+    def update(self, cookies: CookieTypes | None = None) -> None:  # type: ignore
+        cookies = Cookies(cookies)
+        for cookie in cookies.jar:
+            self.jar.set_cookie(cookie)
+
+    def __setitem__(self, name: str, value: str) -> None:
+        return self.set(name, value)
+
+    def __getitem__(self, name: str) -> str:
+        value = self.get(name)
+        if value is None:
+            raise KeyError(name)
+        return value
+
+    def __delitem__(self, name: str) -> None:
+        return self.delete(name)
+
+    def __len__(self) -> int:
+        return len(self.jar)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return (cookie.name for cookie in self.jar)
+
+    def __bool__(self) -> bool:
+        for _ in self.jar:
+            return True
+        return False
+
+    def __repr__(self) -> str:
+        cookies_repr = ", ".join(
+            [
+                f""
+                for cookie in self.jar
+            ]
+        )
+
+        return f""
+
+    class _CookieCompatRequest(urllib.request.Request):
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, request: Request) -> None:
+            super().__init__(
+                url=str(request.url),
+                headers=dict(request.headers),
+                method=request.method,
+            )
+            self.request = request
+
+        def add_unredirected_header(self, key: str, value: str) -> None:
+            super().add_unredirected_header(key, value)
+            self.request.headers[key] = value
+
+    class _CookieCompatResponse:
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, response: Response) -> None:
+            self.response = response
+
+        def info(self) -> email.message.Message:
+            info = email.message.Message()
+            for key, value in self.response.headers.multi_items():
+                # Note that setting `info[key]` here is an "append" operation,
+                # not a "replace" operation.
+                # https://docs.python.org/3/library/email.compat32-message.html#email.message.Message.__setitem__
+                info[key] = value
+            return info
diff --git a/.venv/lib/python3.10/site-packages/httpx/_multipart.py b/.venv/lib/python3.10/site-packages/httpx/_multipart.py
new file mode 100644
index 0000000..b4761af
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_multipart.py
@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import io
+import mimetypes
+import os
+import re
+import typing
+from pathlib import Path
+
+from ._types import (
+    AsyncByteStream,
+    FileContent,
+    FileTypes,
+    RequestData,
+    RequestFiles,
+    SyncByteStream,
+)
+from ._utils import (
+    peek_filelike_length,
+    primitive_value_to_str,
+    to_bytes,
+)
+
+_HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
+_HTML5_FORM_ENCODING_REPLACEMENTS.update(
+    {chr(c): "%{:02X}".format(c) for c in range(0x1F + 1) if c != 0x1B}
+)
+_HTML5_FORM_ENCODING_RE = re.compile(
+    r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()])
+)
+
+
+def _format_form_param(name: str, value: str) -> bytes:
+    """
+    Encode a name/value pair within a multipart form.
+    """
+
+    def replacer(match: typing.Match[str]) -> str:
+        return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
+
+    value = _HTML5_FORM_ENCODING_RE.sub(replacer, value)
+    return f'{name}="{value}"'.encode()
+
+
+def _guess_content_type(filename: str | None) -> str | None:
+    """
+    Guesses the mimetype based on a filename. Defaults to `application/octet-stream`.
+
+    Returns `None` if `filename` is `None` or empty.
+    """
+    if filename:
+        return mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    return None
+
+
+def get_multipart_boundary_from_content_type(
+    content_type: bytes | None,
+) -> bytes | None:
+    if not content_type or not content_type.startswith(b"multipart/form-data"):
+        return None
+    # parse boundary according to
+    # https://www.rfc-editor.org/rfc/rfc2046#section-5.1.1
+    if b";" in content_type:
+        for section in content_type.split(b";"):
+            if section.strip().lower().startswith(b"boundary="):
+                return section.strip()[len(b"boundary=") :].strip(b'"')
+    return None
+
+
+class DataField:
+    """
+    A single form field item, within a multipart form field.
+    """
+
+    def __init__(self, name: str, value: str | bytes | int | float | None) -> None:
+        if not isinstance(name, str):
+            raise TypeError(
+                f"Invalid type for name. Expected str, got {type(name)}: {name!r}"
+            )
+        if value is not None and not isinstance(value, (str, bytes, int, float)):
+            raise TypeError(
+                "Invalid type for value. Expected primitive type,"
+                f" got {type(value)}: {value!r}"
+            )
+        self.name = name
+        self.value: str | bytes = (
+            value if isinstance(value, bytes) else primitive_value_to_str(value)
+        )
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            name = _format_form_param("name", self.name)
+            self._headers = b"".join(
+                [b"Content-Disposition: form-data; ", name, b"\r\n\r\n"]
+            )
+
+        return self._headers
+
+    def render_data(self) -> bytes:
+        if not hasattr(self, "_data"):
+            self._data = to_bytes(self.value)
+
+        return self._data
+
+    def get_length(self) -> int:
+        headers = self.render_headers()
+        data = self.render_data()
+        return len(headers) + len(data)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield self.render_data()
+
+
+class FileField:
+    """
+    A single file field item, within a multipart form field.
+    """
+
+    CHUNK_SIZE = 64 * 1024
+
+    def __init__(self, name: str, value: FileTypes) -> None:
+        self.name = name
+
+        fileobj: FileContent
+
+        headers: dict[str, str] = {}
+        content_type: str | None = None
+
+        # This large tuple based API largely mirror's requests' API
+        # It would be good to think of better APIs for this that we could
+        # include in httpx 2.0 since variable length tuples(especially of 4 elements)
+        # are quite unwieldly
+        if isinstance(value, tuple):
+            if len(value) == 2:
+                # neither the 3rd parameter (content_type) nor the 4th (headers)
+                # was included
+                filename, fileobj = value
+            elif len(value) == 3:
+                filename, fileobj, content_type = value
+            else:
+                # all 4 parameters included
+                filename, fileobj, content_type, headers = value  # type: ignore
+        else:
+            filename = Path(str(getattr(value, "name", "upload"))).name
+            fileobj = value
+
+        if content_type is None:
+            content_type = _guess_content_type(filename)
+
+        has_content_type_header = any("content-type" in key.lower() for key in headers)
+        if content_type is not None and not has_content_type_header:
+            # note that unlike requests, we ignore the content_type provided in the 3rd
+            # tuple element if it is also included in the headers requests does
+            # the opposite (it overwrites the headerwith the 3rd tuple element)
+            headers["Content-Type"] = content_type
+
+        if isinstance(fileobj, io.StringIO):
+            raise TypeError(
+                "Multipart file uploads require 'io.BytesIO', not 'io.StringIO'."
+            )
+        if isinstance(fileobj, io.TextIOBase):
+            raise TypeError(
+                "Multipart file uploads must be opened in binary mode, not text mode."
+            )
+
+        self.filename = filename
+        self.file = fileobj
+        self.headers = headers
+
+    def get_length(self) -> int | None:
+        headers = self.render_headers()
+
+        if isinstance(self.file, (str, bytes)):
+            return len(headers) + len(to_bytes(self.file))
+
+        file_length = peek_filelike_length(self.file)
+
+        # If we can't determine the filesize without reading it into memory,
+        # then return `None` here, to indicate an unknown file length.
+        if file_length is None:
+            return None
+
+        return len(headers) + file_length
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            parts = [
+                b"Content-Disposition: form-data; ",
+                _format_form_param("name", self.name),
+            ]
+            if self.filename:
+                filename = _format_form_param("filename", self.filename)
+                parts.extend([b"; ", filename])
+            for header_name, header_value in self.headers.items():
+                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
+                parts.extend([key, val])
+            parts.append(b"\r\n\r\n")
+            self._headers = b"".join(parts)
+
+        return self._headers
+
+    def render_data(self) -> typing.Iterator[bytes]:
+        if isinstance(self.file, (str, bytes)):
+            yield to_bytes(self.file)
+            return
+
+        if hasattr(self.file, "seek"):
+            try:
+                self.file.seek(0)
+            except io.UnsupportedOperation:
+                pass
+
+        chunk = self.file.read(self.CHUNK_SIZE)
+        while chunk:
+            yield to_bytes(chunk)
+            chunk = self.file.read(self.CHUNK_SIZE)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield from self.render_data()
+
+
+class MultipartStream(SyncByteStream, AsyncByteStream):
+    """
+    Request content as streaming multipart encoded form data.
+    """
+
+    def __init__(
+        self,
+        data: RequestData,
+        files: RequestFiles,
+        boundary: bytes | None = None,
+    ) -> None:
+        if boundary is None:
+            boundary = os.urandom(16).hex().encode("ascii")
+
+        self.boundary = boundary
+        self.content_type = "multipart/form-data; boundary=%s" % boundary.decode(
+            "ascii"
+        )
+        self.fields = list(self._iter_fields(data, files))
+
+    def _iter_fields(
+        self, data: RequestData, files: RequestFiles
+    ) -> typing.Iterator[FileField | DataField]:
+        for name, value in data.items():
+            if isinstance(value, (tuple, list)):
+                for item in value:
+                    yield DataField(name=name, value=item)
+            else:
+                yield DataField(name=name, value=value)
+
+        file_items = files.items() if isinstance(files, typing.Mapping) else files
+        for name, value in file_items:
+            yield FileField(name=name, value=value)
+
+    def iter_chunks(self) -> typing.Iterator[bytes]:
+        for field in self.fields:
+            yield b"--%s\r\n" % self.boundary
+            yield from field.render()
+            yield b"\r\n"
+        yield b"--%s--\r\n" % self.boundary
+
+    def get_content_length(self) -> int | None:
+        """
+        Return the length of the multipart encoded content, or `None` if
+        any of the files have a length that cannot be determined upfront.
+        """
+        boundary_length = len(self.boundary)
+        length = 0
+
+        for field in self.fields:
+            field_length = field.get_length()
+            if field_length is None:
+                return None
+
+            length += 2 + boundary_length + 2  # b"--{boundary}\r\n"
+            length += field_length
+            length += 2  # b"\r\n"
+
+        length += 2 + boundary_length + 4  # b"--{boundary}--\r\n"
+        return length
+
+    # Content stream interface.
+
+    def get_headers(self) -> dict[str, str]:
+        content_length = self.get_content_length()
+        content_type = self.content_type
+        if content_length is None:
+            return {"Transfer-Encoding": "chunked", "Content-Type": content_type}
+        return {"Content-Length": str(content_length), "Content-Type": content_type}
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for chunk in self.iter_chunks():
+            yield chunk
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        for chunk in self.iter_chunks():
+            yield chunk
diff --git a/.venv/lib/python3.10/site-packages/httpx/_status_codes.py b/.venv/lib/python3.10/site-packages/httpx/_status_codes.py
new file mode 100644
index 0000000..133a623
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_status_codes.py
@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+__all__ = ["codes"]
+
+
+class codes(IntEnum):
+    """HTTP status codes and reason phrases
+
+    Status codes from the following RFCs are all observed:
+
+        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+        * RFC 6585: Additional HTTP Status Codes
+        * RFC 3229: Delta encoding in HTTP
+        * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
+        * RFC 5842: Binding Extensions to WebDAV
+        * RFC 7238: Permanent Redirect
+        * RFC 2295: Transparent Content Negotiation in HTTP
+        * RFC 2774: An HTTP Extension Framework
+        * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
+        * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
+        * RFC 7725: An HTTP Status Code to Report Legal Obstacles
+        * RFC 8297: An HTTP Status Code for Indicating Hints
+        * RFC 8470: Using Early Data in HTTP
+    """
+
+    def __new__(cls, value: int, phrase: str = "") -> codes:
+        obj = int.__new__(cls, value)
+        obj._value_ = value
+
+        obj.phrase = phrase  # type: ignore[attr-defined]
+        return obj
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def get_reason_phrase(cls, value: int) -> str:
+        try:
+            return codes(value).phrase  # type: ignore
+        except ValueError:
+            return ""
+
+    @classmethod
+    def is_informational(cls, value: int) -> bool:
+        """
+        Returns `True` for 1xx status codes, `False` otherwise.
+        """
+        return 100 <= value <= 199
+
+    @classmethod
+    def is_success(cls, value: int) -> bool:
+        """
+        Returns `True` for 2xx status codes, `False` otherwise.
+        """
+        return 200 <= value <= 299
+
+    @classmethod
+    def is_redirect(cls, value: int) -> bool:
+        """
+        Returns `True` for 3xx status codes, `False` otherwise.
+        """
+        return 300 <= value <= 399
+
+    @classmethod
+    def is_client_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 499
+
+    @classmethod
+    def is_server_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 5xx status codes, `False` otherwise.
+        """
+        return 500 <= value <= 599
+
+    @classmethod
+    def is_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 599
+
+    # informational
+    CONTINUE = 100, "Continue"
+    SWITCHING_PROTOCOLS = 101, "Switching Protocols"
+    PROCESSING = 102, "Processing"
+    EARLY_HINTS = 103, "Early Hints"
+
+    # success
+    OK = 200, "OK"
+    CREATED = 201, "Created"
+    ACCEPTED = 202, "Accepted"
+    NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information"
+    NO_CONTENT = 204, "No Content"
+    RESET_CONTENT = 205, "Reset Content"
+    PARTIAL_CONTENT = 206, "Partial Content"
+    MULTI_STATUS = 207, "Multi-Status"
+    ALREADY_REPORTED = 208, "Already Reported"
+    IM_USED = 226, "IM Used"
+
+    # redirection
+    MULTIPLE_CHOICES = 300, "Multiple Choices"
+    MOVED_PERMANENTLY = 301, "Moved Permanently"
+    FOUND = 302, "Found"
+    SEE_OTHER = 303, "See Other"
+    NOT_MODIFIED = 304, "Not Modified"
+    USE_PROXY = 305, "Use Proxy"
+    TEMPORARY_REDIRECT = 307, "Temporary Redirect"
+    PERMANENT_REDIRECT = 308, "Permanent Redirect"
+
+    # client error
+    BAD_REQUEST = 400, "Bad Request"
+    UNAUTHORIZED = 401, "Unauthorized"
+    PAYMENT_REQUIRED = 402, "Payment Required"
+    FORBIDDEN = 403, "Forbidden"
+    NOT_FOUND = 404, "Not Found"
+    METHOD_NOT_ALLOWED = 405, "Method Not Allowed"
+    NOT_ACCEPTABLE = 406, "Not Acceptable"
+    PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required"
+    REQUEST_TIMEOUT = 408, "Request Timeout"
+    CONFLICT = 409, "Conflict"
+    GONE = 410, "Gone"
+    LENGTH_REQUIRED = 411, "Length Required"
+    PRECONDITION_FAILED = 412, "Precondition Failed"
+    REQUEST_ENTITY_TOO_LARGE = 413, "Request Entity Too Large"
+    REQUEST_URI_TOO_LONG = 414, "Request-URI Too Long"
+    UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type"
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416, "Requested Range Not Satisfiable"
+    EXPECTATION_FAILED = 417, "Expectation Failed"
+    IM_A_TEAPOT = 418, "I'm a teapot"
+    MISDIRECTED_REQUEST = 421, "Misdirected Request"
+    UNPROCESSABLE_ENTITY = 422, "Unprocessable Entity"
+    LOCKED = 423, "Locked"
+    FAILED_DEPENDENCY = 424, "Failed Dependency"
+    TOO_EARLY = 425, "Too Early"
+    UPGRADE_REQUIRED = 426, "Upgrade Required"
+    PRECONDITION_REQUIRED = 428, "Precondition Required"
+    TOO_MANY_REQUESTS = 429, "Too Many Requests"
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large"
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons"
+
+    # server errors
+    INTERNAL_SERVER_ERROR = 500, "Internal Server Error"
+    NOT_IMPLEMENTED = 501, "Not Implemented"
+    BAD_GATEWAY = 502, "Bad Gateway"
+    SERVICE_UNAVAILABLE = 503, "Service Unavailable"
+    GATEWAY_TIMEOUT = 504, "Gateway Timeout"
+    HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported"
+    VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates"
+    INSUFFICIENT_STORAGE = 507, "Insufficient Storage"
+    LOOP_DETECTED = 508, "Loop Detected"
+    NOT_EXTENDED = 510, "Not Extended"
+    NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required"
+
+
+# Include lower-case styles for `requests` compatibility.
+for code in codes:
+    setattr(codes, code._name_.lower(), int(code))
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__init__.py b/.venv/lib/python3.10/site-packages/httpx/_transports/__init__.py
new file mode 100644
index 0000000..7a32105
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/__init__.py
@@ -0,0 +1,15 @@
+from .asgi import *
+from .base import *
+from .default import *
+from .mock import *
+from .wsgi import *
+
+__all__ = [
+    "ASGITransport",
+    "AsyncBaseTransport",
+    "BaseTransport",
+    "AsyncHTTPTransport",
+    "HTTPTransport",
+    "MockTransport",
+    "WSGITransport",
+]
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..425e63b
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/__init__.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/asgi.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/asgi.cpython-310.pyc
new file mode 100644
index 0000000..83661a1
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/asgi.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/base.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000..b13248d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/base.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/default.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/default.cpython-310.pyc
new file mode 100644
index 0000000..2750fe1
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/default.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/mock.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/mock.cpython-310.pyc
new file mode 100644
index 0000000..a6c435f
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/mock.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/wsgi.cpython-310.pyc b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/wsgi.cpython-310.pyc
new file mode 100644
index 0000000..8ba44a8
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/httpx/_transports/__pycache__/wsgi.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/asgi.py b/.venv/lib/python3.10/site-packages/httpx/_transports/asgi.py
new file mode 100644
index 0000000..2bc4efa
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/asgi.py
@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import typing
+
+from .._models import Request, Response
+from .._types import AsyncByteStream
+from .base import AsyncBaseTransport
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    import asyncio
+
+    import trio
+
+    Event = typing.Union[asyncio.Event, trio.Event]
+
+
+_Message = typing.MutableMapping[str, typing.Any]
+_Receive = typing.Callable[[], typing.Awaitable[_Message]]
+_Send = typing.Callable[
+    [typing.MutableMapping[str, typing.Any]], typing.Awaitable[None]
+]
+_ASGIApp = typing.Callable[
+    [typing.MutableMapping[str, typing.Any], _Receive, _Send], typing.Awaitable[None]
+]
+
+__all__ = ["ASGITransport"]
+
+
+def is_running_trio() -> bool:
+    try:
+        # sniffio is a dependency of trio.
+
+        # See https://github.com/python-trio/trio/issues/2802
+        import sniffio
+
+        if sniffio.current_async_library() == "trio":
+            return True
+    except ImportError:  # pragma: nocover
+        pass
+
+    return False
+
+
+def create_event() -> Event:
+    if is_running_trio():
+        import trio
+
+        return trio.Event()
+
+    import asyncio
+
+    return asyncio.Event()
+
+
+class ASGIResponseStream(AsyncByteStream):
+    def __init__(self, body: list[bytes]) -> None:
+        self._body = body
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        yield b"".join(self._body)
+
+
+class ASGITransport(AsyncBaseTransport):
+    """
+    A custom AsyncTransport that handles sending requests directly to an ASGI app.
+
+    ```python
+    transport = httpx.ASGITransport(
+        app=app,
+        root_path="/submount",
+        client=("1.2.3.4", 123)
+    )
+    client = httpx.AsyncClient(transport=transport)
+    ```
+
+    Arguments:
+
+    * `app` - The ASGI application.
+    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
+       should be raised. Default to `True`. Can be set to `False` for use cases
+       such as testing the content of a client 500 response.
+    * `root_path` - The root path on which the ASGI application should be mounted.
+    * `client` - A two-tuple indicating the client IP and port of incoming requests.
+    ```
+    """
+
+    def __init__(
+        self,
+        app: _ASGIApp,
+        raise_app_exceptions: bool = True,
+        root_path: str = "",
+        client: tuple[str, int] = ("127.0.0.1", 123),
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.root_path = root_path
+        self.client = client
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        # ASGI scope.
+        scope = {
+            "type": "http",
+            "asgi": {"version": "3.0"},
+            "http_version": "1.1",
+            "method": request.method,
+            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
+            "scheme": request.url.scheme,
+            "path": request.url.path,
+            "raw_path": request.url.raw_path.split(b"?")[0],
+            "query_string": request.url.query,
+            "server": (request.url.host, request.url.port),
+            "client": self.client,
+            "root_path": self.root_path,
+        }
+
+        # Request.
+        request_body_chunks = request.stream.__aiter__()
+        request_complete = False
+
+        # Response.
+        status_code = None
+        response_headers = None
+        body_parts = []
+        response_started = False
+        response_complete = create_event()
+
+        # ASGI callables.
+
+        async def receive() -> dict[str, typing.Any]:
+            nonlocal request_complete
+
+            if request_complete:
+                await response_complete.wait()
+                return {"type": "http.disconnect"}
+
+            try:
+                body = await request_body_chunks.__anext__()
+            except StopAsyncIteration:
+                request_complete = True
+                return {"type": "http.request", "body": b"", "more_body": False}
+            return {"type": "http.request", "body": body, "more_body": True}
+
+        async def send(message: typing.MutableMapping[str, typing.Any]) -> None:
+            nonlocal status_code, response_headers, response_started
+
+            if message["type"] == "http.response.start":
+                assert not response_started
+
+                status_code = message["status"]
+                response_headers = message.get("headers", [])
+                response_started = True
+
+            elif message["type"] == "http.response.body":
+                assert not response_complete.is_set()
+                body = message.get("body", b"")
+                more_body = message.get("more_body", False)
+
+                if body and request.method != "HEAD":
+                    body_parts.append(body)
+
+                if not more_body:
+                    response_complete.set()
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception:  # noqa: PIE-786
+            if self.raise_app_exceptions:
+                raise
+
+            response_complete.set()
+            if status_code is None:
+                status_code = 500
+            if response_headers is None:
+                response_headers = {}
+
+        assert response_complete.is_set()
+        assert status_code is not None
+        assert response_headers is not None
+
+        stream = ASGIResponseStream(body_parts)
+
+        return Response(status_code, headers=response_headers, stream=stream)
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/base.py b/.venv/lib/python3.10/site-packages/httpx/_transports/base.py
new file mode 100644
index 0000000..66fd99d
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/base.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import typing
+from types import TracebackType
+
+from .._models import Request, Response
+
+T = typing.TypeVar("T", bound="BaseTransport")
+A = typing.TypeVar("A", bound="AsyncBaseTransport")
+
+__all__ = ["AsyncBaseTransport", "BaseTransport"]
+
+
+class BaseTransport:
+    def __enter__(self: T) -> T:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send a single HTTP request and return a response.
+
+        Developers shouldn't typically ever need to call into this API directly,
+        since the Client class provides all the higher level user-facing API
+        niceties.
+
+        In order to properly release any network resources, the response
+        stream should *either* be consumed immediately, with a call to
+        `response.stream.read()`, or else the `handle_request` call should
+        be followed with a try/finally block to ensuring the stream is
+        always closed.
+
+        Example usage:
+
+            with httpx.HTTPTransport() as transport:
+                req = httpx.Request(
+                    method=b"GET",
+                    url=(b"https", b"www.example.com", 443, b"/"),
+                    headers=[(b"Host", b"www.example.com")],
+                )
+                resp = transport.handle_request(req)
+                body = resp.stream.read()
+                print(resp.status_code, resp.headers, body)
+
+
+        Takes a `Request` instance as the only argument.
+
+        Returns a `Response` instance.
+        """
+        raise NotImplementedError(
+            "The 'handle_request' method must be implemented."
+        )  # pragma: no cover
+
+    def close(self) -> None:
+        pass
+
+
+class AsyncBaseTransport:
+    async def __aenter__(self: A) -> A:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        raise NotImplementedError(
+            "The 'handle_async_request' method must be implemented."
+        )  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/default.py b/.venv/lib/python3.10/site-packages/httpx/_transports/default.py
new file mode 100644
index 0000000..d5aa05f
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/default.py
@@ -0,0 +1,406 @@
+"""
+Custom transports, with nicely configured defaults.
+
+The following additional keyword arguments are currently supported by httpcore...
+
+* uds: str
+* local_address: str
+* retries: int
+
+Example usages...
+
+# Disable HTTP/2 on a single specific domain.
+mounts = {
+    "all://": httpx.HTTPTransport(http2=True),
+    "all://*example.org": httpx.HTTPTransport()
+}
+
+# Using advanced httpcore configuration, with connection retries.
+transport = httpx.HTTPTransport(retries=1)
+client = httpx.Client(transport=transport)
+
+# Using advanced httpcore configuration, with unix domain sockets.
+transport = httpx.HTTPTransport(uds="socket.uds")
+client = httpx.Client(transport=transport)
+"""
+
+from __future__ import annotations
+
+import contextlib
+import typing
+from types import TracebackType
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+    import httpx  # pragma: no cover
+
+from .._config import DEFAULT_LIMITS, Limits, Proxy, create_ssl_context
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    TimeoutException,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from .._models import Request, Response
+from .._types import AsyncByteStream, CertTypes, ProxyTypes, SyncByteStream
+from .._urls import URL
+from .base import AsyncBaseTransport, BaseTransport
+
+T = typing.TypeVar("T", bound="HTTPTransport")
+A = typing.TypeVar("A", bound="AsyncHTTPTransport")
+
+SOCKET_OPTION = typing.Union[
+    typing.Tuple[int, int, int],
+    typing.Tuple[int, int, typing.Union[bytes, bytearray]],
+    typing.Tuple[int, int, None, int],
+]
+
+__all__ = ["AsyncHTTPTransport", "HTTPTransport"]
+
+HTTPCORE_EXC_MAP: dict[type[Exception], type[httpx.HTTPError]] = {}
+
+
+def _load_httpcore_exceptions() -> dict[type[Exception], type[httpx.HTTPError]]:
+    import httpcore
+
+    return {
+        httpcore.TimeoutException: TimeoutException,
+        httpcore.ConnectTimeout: ConnectTimeout,
+        httpcore.ReadTimeout: ReadTimeout,
+        httpcore.WriteTimeout: WriteTimeout,
+        httpcore.PoolTimeout: PoolTimeout,
+        httpcore.NetworkError: NetworkError,
+        httpcore.ConnectError: ConnectError,
+        httpcore.ReadError: ReadError,
+        httpcore.WriteError: WriteError,
+        httpcore.ProxyError: ProxyError,
+        httpcore.UnsupportedProtocol: UnsupportedProtocol,
+        httpcore.ProtocolError: ProtocolError,
+        httpcore.LocalProtocolError: LocalProtocolError,
+        httpcore.RemoteProtocolError: RemoteProtocolError,
+    }
+
+
+@contextlib.contextmanager
+def map_httpcore_exceptions() -> typing.Iterator[None]:
+    global HTTPCORE_EXC_MAP
+    if len(HTTPCORE_EXC_MAP) == 0:
+        HTTPCORE_EXC_MAP = _load_httpcore_exceptions()
+    try:
+        yield
+    except Exception as exc:
+        mapped_exc = None
+
+        for from_exc, to_exc in HTTPCORE_EXC_MAP.items():
+            if not isinstance(exc, from_exc):
+                continue
+            # We want to map to the most specific exception we can find.
+            # Eg if `exc` is an `httpcore.ReadTimeout`, we want to map to
+            # `httpx.ReadTimeout`, not just `httpx.TimeoutException`.
+            if mapped_exc is None or issubclass(to_exc, mapped_exc):
+                mapped_exc = to_exc
+
+        if mapped_exc is None:  # pragma: no cover
+            raise
+
+        message = str(exc)
+        raise mapped_exc(message) from exc
+
+
+class ResponseStream(SyncByteStream):
+    def __init__(self, httpcore_stream: typing.Iterable[bytes]) -> None:
+        self._httpcore_stream = httpcore_stream
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        with map_httpcore_exceptions():
+            for part in self._httpcore_stream:
+                yield part
+
+    def close(self) -> None:
+        if hasattr(self._httpcore_stream, "close"):
+            self._httpcore_stream.close()
+
+
+class HTTPTransport(BaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        import httpcore
+
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore.ConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore.HTTPProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                ssl_context=ssl_context,
+                proxy_ssl_context=proxy.ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("socks5", "socks5h"):
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.SOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                "Proxy protocol must be either 'http', 'https', 'socks5', or 'socks5h',"
+                f" but got {proxy.url.scheme!r}."
+            )
+
+    def __enter__(self: T) -> T:  # Use generics for subclass support.
+        self._pool.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            self._pool.__exit__(exc_type, exc_value, traceback)
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, SyncByteStream)
+        import httpcore
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = self._pool.handle_request(req)
+
+        assert isinstance(resp.stream, typing.Iterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=ResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    def close(self) -> None:
+        self._pool.close()
+
+
+class AsyncResponseStream(AsyncByteStream):
+    def __init__(self, httpcore_stream: typing.AsyncIterable[bytes]) -> None:
+        self._httpcore_stream = httpcore_stream
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        with map_httpcore_exceptions():
+            async for part in self._httpcore_stream:
+                yield part
+
+    async def aclose(self) -> None:
+        if hasattr(self._httpcore_stream, "aclose"):
+            await self._httpcore_stream.aclose()
+
+
+class AsyncHTTPTransport(AsyncBaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        import httpcore
+
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore.AsyncConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore.AsyncHTTPProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                proxy_ssl_context=proxy.ssl_context,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("socks5", "socks5h"):
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.AsyncSOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                "Proxy protocol must be either 'http', 'https', 'socks5', or 'socks5h',"
+                " but got {proxy.url.scheme!r}."
+            )
+
+    async def __aenter__(self: A) -> A:  # Use generics for subclass support.
+        await self._pool.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            await self._pool.__aexit__(exc_type, exc_value, traceback)
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+        import httpcore
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = await self._pool.handle_async_request(req)
+
+        assert isinstance(resp.stream, typing.AsyncIterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=AsyncResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    async def aclose(self) -> None:
+        await self._pool.aclose()
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/mock.py b/.venv/lib/python3.10/site-packages/httpx/_transports/mock.py
new file mode 100644
index 0000000..8c418f5
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/mock.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import typing
+
+from .._models import Request, Response
+from .base import AsyncBaseTransport, BaseTransport
+
+SyncHandler = typing.Callable[[Request], Response]
+AsyncHandler = typing.Callable[[Request], typing.Coroutine[None, None, Response]]
+
+
+__all__ = ["MockTransport"]
+
+
+class MockTransport(AsyncBaseTransport, BaseTransport):
+    def __init__(self, handler: SyncHandler | AsyncHandler) -> None:
+        self.handler = handler
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        request.read()
+        response = self.handler(request)
+        if not isinstance(response, Response):  # pragma: no cover
+            raise TypeError("Cannot use an async handler in a sync Client")
+        return response
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        await request.aread()
+        response = self.handler(request)
+
+        # Allow handler to *optionally* be an `async` function.
+        # If it is, then the `response` variable need to be awaited to actually
+        # return the result.
+
+        if not isinstance(response, Response):
+            response = await response
+
+        return response
diff --git a/.venv/lib/python3.10/site-packages/httpx/_transports/wsgi.py b/.venv/lib/python3.10/site-packages/httpx/_transports/wsgi.py
new file mode 100644
index 0000000..8592ffe
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_transports/wsgi.py
@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import io
+import itertools
+import sys
+import typing
+
+from .._models import Request, Response
+from .._types import SyncByteStream
+from .base import BaseTransport
+
+if typing.TYPE_CHECKING:
+    from _typeshed import OptExcInfo  # pragma: no cover
+    from _typeshed.wsgi import WSGIApplication  # pragma: no cover
+
+_T = typing.TypeVar("_T")
+
+
+__all__ = ["WSGITransport"]
+
+
+def _skip_leading_empty_chunks(body: typing.Iterable[_T]) -> typing.Iterable[_T]:
+    body = iter(body)
+    for chunk in body:
+        if chunk:
+            return itertools.chain([chunk], body)
+    return []
+
+
+class WSGIByteStream(SyncByteStream):
+    def __init__(self, result: typing.Iterable[bytes]) -> None:
+        self._close = getattr(result, "close", None)
+        self._result = _skip_leading_empty_chunks(result)
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        for part in self._result:
+            yield part
+
+    def close(self) -> None:
+        if self._close is not None:
+            self._close()
+
+
+class WSGITransport(BaseTransport):
+    """
+    A custom transport that handles sending requests directly to an WSGI app.
+    The simplest way to use this functionality is to use the `app` argument.
+
+    ```
+    client = httpx.Client(app=app)
+    ```
+
+    Alternatively, you can setup the transport instance explicitly.
+    This allows you to include any additional configuration arguments specific
+    to the WSGITransport class:
+
+    ```
+    transport = httpx.WSGITransport(
+        app=app,
+        script_name="/submount",
+        remote_addr="1.2.3.4"
+    )
+    client = httpx.Client(transport=transport)
+    ```
+
+    Arguments:
+
+    * `app` - The WSGI application.
+    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
+       should be raised. Default to `True`. Can be set to `False` for use cases
+       such as testing the content of a client 500 response.
+    * `script_name` - The root path on which the WSGI application should be mounted.
+    * `remote_addr` - A string indicating the client IP of incoming requests.
+    ```
+    """
+
+    def __init__(
+        self,
+        app: WSGIApplication,
+        raise_app_exceptions: bool = True,
+        script_name: str = "",
+        remote_addr: str = "127.0.0.1",
+        wsgi_errors: typing.TextIO | None = None,
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.script_name = script_name
+        self.remote_addr = remote_addr
+        self.wsgi_errors = wsgi_errors
+
+    def handle_request(self, request: Request) -> Response:
+        request.read()
+        wsgi_input = io.BytesIO(request.content)
+
+        port = request.url.port or {"http": 80, "https": 443}[request.url.scheme]
+        environ = {
+            "wsgi.version": (1, 0),
+            "wsgi.url_scheme": request.url.scheme,
+            "wsgi.input": wsgi_input,
+            "wsgi.errors": self.wsgi_errors or sys.stderr,
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": False,
+            "wsgi.run_once": False,
+            "REQUEST_METHOD": request.method,
+            "SCRIPT_NAME": self.script_name,
+            "PATH_INFO": request.url.path,
+            "QUERY_STRING": request.url.query.decode("ascii"),
+            "SERVER_NAME": request.url.host,
+            "SERVER_PORT": str(port),
+            "SERVER_PROTOCOL": "HTTP/1.1",
+            "REMOTE_ADDR": self.remote_addr,
+        }
+        for header_key, header_value in request.headers.raw:
+            key = header_key.decode("ascii").upper().replace("-", "_")
+            if key not in ("CONTENT_TYPE", "CONTENT_LENGTH"):
+                key = "HTTP_" + key
+            environ[key] = header_value.decode("ascii")
+
+        seen_status = None
+        seen_response_headers = None
+        seen_exc_info = None
+
+        def start_response(
+            status: str,
+            response_headers: list[tuple[str, str]],
+            exc_info: OptExcInfo | None = None,
+        ) -> typing.Callable[[bytes], typing.Any]:
+            nonlocal seen_status, seen_response_headers, seen_exc_info
+            seen_status = status
+            seen_response_headers = response_headers
+            seen_exc_info = exc_info
+            return lambda _: None
+
+        result = self.app(environ, start_response)
+
+        stream = WSGIByteStream(result)
+
+        assert seen_status is not None
+        assert seen_response_headers is not None
+        if seen_exc_info and seen_exc_info[0] and self.raise_app_exceptions:
+            raise seen_exc_info[1]
+
+        status_code = int(seen_status.split()[0])
+        headers = [
+            (key.encode("ascii"), value.encode("ascii"))
+            for key, value in seen_response_headers
+        ]
+
+        return Response(status_code, headers=headers, stream=stream)
diff --git a/.venv/lib/python3.10/site-packages/httpx/_types.py b/.venv/lib/python3.10/site-packages/httpx/_types.py
new file mode 100644
index 0000000..704dfdf
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_types.py
@@ -0,0 +1,114 @@
+"""
+Type definitions for type checking purposes.
+"""
+
+from http.cookiejar import CookieJar
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ._auth import Auth  # noqa: F401
+    from ._config import Proxy, Timeout  # noqa: F401
+    from ._models import Cookies, Headers, Request  # noqa: F401
+    from ._urls import URL, QueryParams  # noqa: F401
+
+
+PrimitiveData = Optional[Union[str, int, float, bool]]
+
+URLTypes = Union["URL", str]
+
+QueryParamTypes = Union[
+    "QueryParams",
+    Mapping[str, Union[PrimitiveData, Sequence[PrimitiveData]]],
+    List[Tuple[str, PrimitiveData]],
+    Tuple[Tuple[str, PrimitiveData], ...],
+    str,
+    bytes,
+]
+
+HeaderTypes = Union[
+    "Headers",
+    Mapping[str, str],
+    Mapping[bytes, bytes],
+    Sequence[Tuple[str, str]],
+    Sequence[Tuple[bytes, bytes]],
+]
+
+CookieTypes = Union["Cookies", CookieJar, Dict[str, str], List[Tuple[str, str]]]
+
+TimeoutTypes = Union[
+    Optional[float],
+    Tuple[Optional[float], Optional[float], Optional[float], Optional[float]],
+    "Timeout",
+]
+ProxyTypes = Union["URL", str, "Proxy"]
+CertTypes = Union[str, Tuple[str, str], Tuple[str, str, str]]
+
+AuthTypes = Union[
+    Tuple[Union[str, bytes], Union[str, bytes]],
+    Callable[["Request"], "Request"],
+    "Auth",
+]
+
+RequestContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+ResponseContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+ResponseExtensions = Mapping[str, Any]
+
+RequestData = Mapping[str, Any]
+
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = Union[Mapping[str, FileTypes], Sequence[Tuple[str, FileTypes]]]
+
+RequestExtensions = Mapping[str, Any]
+
+__all__ = ["AsyncByteStream", "SyncByteStream"]
+
+
+class SyncByteStream:
+    def __iter__(self) -> Iterator[bytes]:
+        raise NotImplementedError(
+            "The '__iter__' method must be implemented."
+        )  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    def close(self) -> None:
+        """
+        Subclasses can override this method to release any network resources
+        after a request/response cycle is complete.
+        """
+
+
+class AsyncByteStream:
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise NotImplementedError(
+            "The '__aiter__' method must be implemented."
+        )  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/.venv/lib/python3.10/site-packages/httpx/_urlparse.py b/.venv/lib/python3.10/site-packages/httpx/_urlparse.py
new file mode 100644
index 0000000..bf190fd
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_urlparse.py
@@ -0,0 +1,527 @@
+"""
+An implementation of `urlparse` that provides URL validation and normalization
+as described by RFC3986.
+
+We rely on this implementation rather than the one in Python's stdlib, because:
+
+* It provides more complete URL validation.
+* It properly differentiates between an empty querystring and an absent querystring,
+  to distinguish URLs with a trailing '?'.
+* It handles scheme, hostname, port, and path normalization.
+* It supports IDNA hostnames, normalizing them to their encoded form.
+* The API supports passing individual components, as well as the complete URL string.
+
+Previously we relied on the excellent `rfc3986` package to handle URL parsing and
+validation, but this module provides a simpler alternative, with less indirection
+required.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+import typing
+
+import idna
+
+from ._exceptions import InvalidURL
+
+MAX_URL_LENGTH = 65536
+
+# https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.3
+UNRESERVED_CHARACTERS = (
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+)
+SUB_DELIMS = "!$&'()*+,;="
+
+PERCENT_ENCODED_REGEX = re.compile("%[A-Fa-f0-9]{2}")
+
+# https://url.spec.whatwg.org/#percent-encoded-bytes
+
+# The fragment percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`).
+FRAG_SAFE = "".join(
+    [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x3C, 0x3E, 0x60)]
+)
+
+# The query percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+0023 (#), U+003C (<), and U+003E (>).
+QUERY_SAFE = "".join(
+    [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E)]
+)
+
+# The path percent-encode set is the query percent-encode set
+# and U+003F (?), U+0060 (`), U+007B ({), and U+007D (}).
+PATH_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + (0x3F, 0x60, 0x7B, 0x7D)
+    ]
+)
+
+# The userinfo percent-encode set is the path percent-encode set
+# and U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@),
+# U+005B ([) to U+005E (^), inclusive, and U+007C (|).
+USERNAME_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+PASSWORD_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+# Note... The terminology 'userinfo' percent-encode set in the WHATWG document
+# is used for the username and password quoting. For the joint userinfo component
+# we remove U+003A (:) from the safe set.
+USERINFO_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+
+
+# {scheme}:      (optional)
+# //{authority}  (optional)
+# {path}
+# ?{query}       (optional)
+# #{fragment}    (optional)
+URL_REGEX = re.compile(
+    (
+        r"(?:(?P{scheme}):)?"
+        r"(?://(?P{authority}))?"
+        r"(?P{path})"
+        r"(?:\?(?P{query}))?"
+        r"(?:#(?P{fragment}))?"
+    ).format(
+        scheme="([a-zA-Z][a-zA-Z0-9+.-]*)?",
+        authority="[^/?#]*",
+        path="[^?#]*",
+        query="[^#]*",
+        fragment=".*",
+    )
+)
+
+# {userinfo}@    (optional)
+# {host}
+# :{port}        (optional)
+AUTHORITY_REGEX = re.compile(
+    (
+        r"(?:(?P{userinfo})@)?" r"(?P{host})" r":?(?P{port})?"
+    ).format(
+        userinfo=".*",  # Any character sequence.
+        host="(\\[.*\\]|[^:@]*)",  # Either any character sequence excluding ':' or '@',
+        # or an IPv6 address enclosed within square brackets.
+        port=".*",  # Any character sequence.
+    )
+)
+
+
+# If we call urlparse with an individual component, then we need to regex
+# validate that component individually.
+# Note that we're duplicating the same strings as above. Shock! Horror!!
+COMPONENT_REGEX = {
+    "scheme": re.compile("([a-zA-Z][a-zA-Z0-9+.-]*)?"),
+    "authority": re.compile("[^/?#]*"),
+    "path": re.compile("[^?#]*"),
+    "query": re.compile("[^#]*"),
+    "fragment": re.compile(".*"),
+    "userinfo": re.compile("[^@]*"),
+    "host": re.compile("(\\[.*\\]|[^:]*)"),
+    "port": re.compile(".*"),
+}
+
+
+# We use these simple regexs as a first pass before handing off to
+# the stdlib 'ipaddress' module for IP address validation.
+IPv4_STYLE_HOSTNAME = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$")
+IPv6_STYLE_HOSTNAME = re.compile(r"^\[.*\]$")
+
+
+class ParseResult(typing.NamedTuple):
+    scheme: str
+    userinfo: str
+    host: str
+    port: int | None
+    path: str
+    query: str | None
+    fragment: str | None
+
+    @property
+    def authority(self) -> str:
+        return "".join(
+            [
+                f"{self.userinfo}@" if self.userinfo else "",
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    @property
+    def netloc(self) -> str:
+        return "".join(
+            [
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    def copy_with(self, **kwargs: str | None) -> ParseResult:
+        if not kwargs:
+            return self
+
+        defaults = {
+            "scheme": self.scheme,
+            "authority": self.authority,
+            "path": self.path,
+            "query": self.query,
+            "fragment": self.fragment,
+        }
+        defaults.update(kwargs)
+        return urlparse("", **defaults)
+
+    def __str__(self) -> str:
+        authority = self.authority
+        return "".join(
+            [
+                f"{self.scheme}:" if self.scheme else "",
+                f"//{authority}" if authority else "",
+                self.path,
+                f"?{self.query}" if self.query is not None else "",
+                f"#{self.fragment}" if self.fragment is not None else "",
+            ]
+        )
+
+
+def urlparse(url: str = "", **kwargs: str | None) -> ParseResult:
+    # Initial basic checks on allowable URLs.
+    # ---------------------------------------
+
+    # Hard limit the maximum allowable URL length.
+    if len(url) > MAX_URL_LENGTH:
+        raise InvalidURL("URL too long")
+
+    # If a URL includes any ASCII control characters including \t, \r, \n,
+    # then treat it as invalid.
+    if any(char.isascii() and not char.isprintable() for char in url):
+        char = next(char for char in url if char.isascii() and not char.isprintable())
+        idx = url.find(char)
+        error = (
+            f"Invalid non-printable ASCII character in URL, {char!r} at position {idx}."
+        )
+        raise InvalidURL(error)
+
+    # Some keyword arguments require special handling.
+    # ------------------------------------------------
+
+    # Coerce "port" to a string, if it is provided as an integer.
+    if "port" in kwargs:
+        port = kwargs["port"]
+        kwargs["port"] = str(port) if isinstance(port, int) else port
+
+    # Replace "netloc" with "host and "port".
+    if "netloc" in kwargs:
+        netloc = kwargs.pop("netloc") or ""
+        kwargs["host"], _, kwargs["port"] = netloc.partition(":")
+
+    # Replace "username" and/or "password" with "userinfo".
+    if "username" in kwargs or "password" in kwargs:
+        username = quote(kwargs.pop("username", "") or "", safe=USERNAME_SAFE)
+        password = quote(kwargs.pop("password", "") or "", safe=PASSWORD_SAFE)
+        kwargs["userinfo"] = f"{username}:{password}" if password else username
+
+    # Replace "raw_path" with "path" and "query".
+    if "raw_path" in kwargs:
+        raw_path = kwargs.pop("raw_path") or ""
+        kwargs["path"], seperator, kwargs["query"] = raw_path.partition("?")
+        if not seperator:
+            kwargs["query"] = None
+
+    # Ensure that IPv6 "host" addresses are always escaped with "[...]".
+    if "host" in kwargs:
+        host = kwargs.get("host") or ""
+        if ":" in host and not (host.startswith("[") and host.endswith("]")):
+            kwargs["host"] = f"[{host}]"
+
+    # If any keyword arguments are provided, ensure they are valid.
+    # -------------------------------------------------------------
+
+    for key, value in kwargs.items():
+        if value is not None:
+            if len(value) > MAX_URL_LENGTH:
+                raise InvalidURL(f"URL component '{key}' too long")
+
+            # If a component includes any ASCII control characters including \t, \r, \n,
+            # then treat it as invalid.
+            if any(char.isascii() and not char.isprintable() for char in value):
+                char = next(
+                    char for char in value if char.isascii() and not char.isprintable()
+                )
+                idx = value.find(char)
+                error = (
+                    f"Invalid non-printable ASCII character in URL {key} component, "
+                    f"{char!r} at position {idx}."
+                )
+                raise InvalidURL(error)
+
+            # Ensure that keyword arguments match as a valid regex.
+            if not COMPONENT_REGEX[key].fullmatch(value):
+                raise InvalidURL(f"Invalid URL component '{key}'")
+
+    # The URL_REGEX will always match, but may have empty components.
+    url_match = URL_REGEX.match(url)
+    assert url_match is not None
+    url_dict = url_match.groupdict()
+
+    # * 'scheme', 'authority', and 'path' may be empty strings.
+    # * 'query' may be 'None', indicating no trailing "?" portion.
+    #   Any string including the empty string, indicates a trailing "?".
+    # * 'fragment' may be 'None', indicating no trailing "#" portion.
+    #   Any string including the empty string, indicates a trailing "#".
+    scheme = kwargs.get("scheme", url_dict["scheme"]) or ""
+    authority = kwargs.get("authority", url_dict["authority"]) or ""
+    path = kwargs.get("path", url_dict["path"]) or ""
+    query = kwargs.get("query", url_dict["query"])
+    frag = kwargs.get("fragment", url_dict["fragment"])
+
+    # The AUTHORITY_REGEX will always match, but may have empty components.
+    authority_match = AUTHORITY_REGEX.match(authority)
+    assert authority_match is not None
+    authority_dict = authority_match.groupdict()
+
+    # * 'userinfo' and 'host' may be empty strings.
+    # * 'port' may be 'None'.
+    userinfo = kwargs.get("userinfo", authority_dict["userinfo"]) or ""
+    host = kwargs.get("host", authority_dict["host"]) or ""
+    port = kwargs.get("port", authority_dict["port"])
+
+    # Normalize and validate each component.
+    # We end up with a parsed representation of the URL,
+    # with components that are plain ASCII bytestrings.
+    parsed_scheme: str = scheme.lower()
+    parsed_userinfo: str = quote(userinfo, safe=USERINFO_SAFE)
+    parsed_host: str = encode_host(host)
+    parsed_port: int | None = normalize_port(port, scheme)
+
+    has_scheme = parsed_scheme != ""
+    has_authority = (
+        parsed_userinfo != "" or parsed_host != "" or parsed_port is not None
+    )
+    validate_path(path, has_scheme=has_scheme, has_authority=has_authority)
+    if has_scheme or has_authority:
+        path = normalize_path(path)
+
+    parsed_path: str = quote(path, safe=PATH_SAFE)
+    parsed_query: str | None = None if query is None else quote(query, safe=QUERY_SAFE)
+    parsed_frag: str | None = None if frag is None else quote(frag, safe=FRAG_SAFE)
+
+    # The parsed ASCII bytestrings are our canonical form.
+    # All properties of the URL are derived from these.
+    return ParseResult(
+        parsed_scheme,
+        parsed_userinfo,
+        parsed_host,
+        parsed_port,
+        parsed_path,
+        parsed_query,
+        parsed_frag,
+    )
+
+
+def encode_host(host: str) -> str:
+    if not host:
+        return ""
+
+    elif IPv4_STYLE_HOSTNAME.match(host):
+        # Validate IPv4 hostnames like #.#.#.#
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+        try:
+            ipaddress.IPv4Address(host)
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv4 address: {host!r}")
+        return host
+
+    elif IPv6_STYLE_HOSTNAME.match(host):
+        # Validate IPv6 hostnames like [...]
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # "A host identified by an Internet Protocol literal address, version 6
+        # [RFC3513] or later, is distinguished by enclosing the IP literal
+        # within square brackets ("[" and "]").  This is the only place where
+        # square bracket characters are allowed in the URI syntax."
+        try:
+            ipaddress.IPv6Address(host[1:-1])
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv6 address: {host!r}")
+        return host[1:-1]
+
+    elif host.isascii():
+        # Regular ASCII hostnames
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # reg-name    = *( unreserved / pct-encoded / sub-delims )
+        WHATWG_SAFE = '"`{}%|\\'
+        return quote(host.lower(), safe=SUB_DELIMS + WHATWG_SAFE)
+
+    # IDNA hostnames
+    try:
+        return idna.encode(host.lower()).decode("ascii")
+    except idna.IDNAError:
+        raise InvalidURL(f"Invalid IDNA hostname: {host!r}")
+
+
+def normalize_port(port: str | int | None, scheme: str) -> int | None:
+    # From https://tools.ietf.org/html/rfc3986#section-3.2.3
+    #
+    # "A scheme may define a default port.  For example, the "http" scheme
+    # defines a default port of "80", corresponding to its reserved TCP
+    # port number.  The type of port designated by the port number (e.g.,
+    # TCP, UDP, SCTP) is defined by the URI scheme.  URI producers and
+    # normalizers should omit the port component and its ":" delimiter if
+    # port is empty or if its value would be the same as that of the
+    # scheme's default."
+    if port is None or port == "":
+        return None
+
+    try:
+        port_as_int = int(port)
+    except ValueError:
+        raise InvalidURL(f"Invalid port: {port!r}")
+
+    # See https://url.spec.whatwg.org/#url-miscellaneous
+    default_port = {"ftp": 21, "http": 80, "https": 443, "ws": 80, "wss": 443}.get(
+        scheme
+    )
+    if port_as_int == default_port:
+        return None
+    return port_as_int
+
+
+def validate_path(path: str, has_scheme: bool, has_authority: bool) -> None:
+    """
+    Path validation rules that depend on if the URL contains
+    a scheme or authority component.
+
+    See https://datatracker.ietf.org/doc/html/rfc3986.html#section-3.3
+    """
+    if has_authority:
+        # If a URI contains an authority component, then the path component
+        # must either be empty or begin with a slash ("/") character."
+        if path and not path.startswith("/"):
+            raise InvalidURL("For absolute URLs, path must be empty or begin with '/'")
+
+    if not has_scheme and not has_authority:
+        # If a URI does not contain an authority component, then the path cannot begin
+        # with two slash characters ("//").
+        if path.startswith("//"):
+            raise InvalidURL("Relative URLs cannot have a path starting with '//'")
+
+        # In addition, a URI reference (Section 4.1) may be a relative-path reference,
+        # in which case the first path segment cannot contain a colon (":") character.
+        if path.startswith(":"):
+            raise InvalidURL("Relative URLs cannot have a path starting with ':'")
+
+
+def normalize_path(path: str) -> str:
+    """
+    Drop "." and ".." segments from a URL path.
+
+    For example:
+
+        normalize_path("/path/./to/somewhere/..") == "/path/to"
+    """
+    # Fast return when no '.' characters in the path.
+    if "." not in path:
+        return path
+
+    components = path.split("/")
+
+    # Fast return when no '.' or '..' components in the path.
+    if "." not in components and ".." not in components:
+        return path
+
+    # https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    output: list[str] = []
+    for component in components:
+        if component == ".":
+            pass
+        elif component == "..":
+            if output and output != [""]:
+                output.pop()
+        else:
+            output.append(component)
+    return "/".join(output)
+
+
+def PERCENT(string: str) -> str:
+    return "".join([f"%{byte:02X}" for byte in string.encode("utf-8")])
+
+
+def percent_encoded(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string.
+    """
+    NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe
+
+    # Fast path for strings that don't need escaping.
+    if not string.rstrip(NON_ESCAPED_CHARS):
+        return string
+
+    return "".join(
+        [char if char in NON_ESCAPED_CHARS else PERCENT(char) for char in string]
+    )
+
+
+def quote(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string, omitting existing '%xx' escape sequences.
+
+    See: https://www.rfc-editor.org/rfc/rfc3986#section-2.1
+
+    * `string`: The string to be percent-escaped.
+    * `safe`: A string containing characters that may be treated as safe, and do not
+        need to be escaped. Unreserved characters are always treated as safe.
+        See: https://www.rfc-editor.org/rfc/rfc3986#section-2.3
+    """
+    parts = []
+    current_position = 0
+    for match in re.finditer(PERCENT_ENCODED_REGEX, string):
+        start_position, end_position = match.start(), match.end()
+        matched_text = match.group(0)
+        # Add any text up to the '%xx' escape sequence.
+        if start_position != current_position:
+            leading_text = string[current_position:start_position]
+            parts.append(percent_encoded(leading_text, safe=safe))
+
+        # Add the '%xx' escape sequence.
+        parts.append(matched_text)
+        current_position = end_position
+
+    # Add any text after the final '%xx' escape sequence.
+    if current_position != len(string):
+        trailing_text = string[current_position:]
+        parts.append(percent_encoded(trailing_text, safe=safe))
+
+    return "".join(parts)
diff --git a/.venv/lib/python3.10/site-packages/httpx/_urls.py b/.venv/lib/python3.10/site-packages/httpx/_urls.py
new file mode 100644
index 0000000..147a8fa
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_urls.py
@@ -0,0 +1,641 @@
+from __future__ import annotations
+
+import typing
+from urllib.parse import parse_qs, unquote, urlencode
+
+import idna
+
+from ._types import QueryParamTypes
+from ._urlparse import urlparse
+from ._utils import primitive_value_to_str
+
+__all__ = ["URL", "QueryParams"]
+
+
+class URL:
+    """
+    url = httpx.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
+
+    assert url.scheme == "https"
+    assert url.username == "jo@email.com"
+    assert url.password == "a secret"
+    assert url.userinfo == b"jo%40email.com:a%20secret"
+    assert url.host == "müller.de"
+    assert url.raw_host == b"xn--mller-kva.de"
+    assert url.port == 1234
+    assert url.netloc == b"xn--mller-kva.de:1234"
+    assert url.path == "/pa th"
+    assert url.query == b"?search=ab"
+    assert url.raw_path == b"/pa%20th?search=ab"
+    assert url.fragment == "anchorlink"
+
+    The components of a URL are broken down like this:
+
+       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
+    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
+               [       userinfo        ] [   netloc   ][    raw_path    ]
+
+    Note that:
+
+    * `url.scheme` is normalized to always be lowercased.
+
+    * `url.host` is normalized to always be lowercased. Internationalized domain
+      names are represented in unicode, without IDNA encoding applied. For instance:
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.host == "中国.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.host == "中国.icom.museum"
+
+    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+    * `url.port` is either None or an integer. URLs that include the default port for
+      "http", "https", "ws", "wss", and "ftp" schemes have their port
+      normalized to `None`.
+
+      assert httpx.URL("http://example.com") == httpx.URL("http://example.com:80")
+      assert httpx.URL("http://example.com").port is None
+      assert httpx.URL("http://example.com:80").port is None
+
+    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work
+      with `url.username` and `url.password` instead, which handle the URL escaping.
+
+    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
+      This portion is used as the target when constructing HTTP requests. Usually you'll
+      want to work with `url.path` instead.
+
+    * `url.query` is raw bytes, without URL escaping. A URL query string portion can
+      only be properly URL escaped when decoding the parameter names and values
+      themselves.
+    """
+
+    def __init__(self, url: URL | str = "", **kwargs: typing.Any) -> None:
+        if kwargs:
+            allowed = {
+                "scheme": str,
+                "username": str,
+                "password": str,
+                "userinfo": bytes,
+                "host": str,
+                "port": int,
+                "netloc": bytes,
+                "path": str,
+                "query": bytes,
+                "raw_path": bytes,
+                "fragment": str,
+                "params": object,
+            }
+
+            # Perform type checking for all supported keyword arguments.
+            for key, value in kwargs.items():
+                if key not in allowed:
+                    message = f"{key!r} is an invalid keyword argument for URL()"
+                    raise TypeError(message)
+                if value is not None and not isinstance(value, allowed[key]):
+                    expected = allowed[key].__name__
+                    seen = type(value).__name__
+                    message = f"Argument {key!r} must be {expected} but got {seen}"
+                    raise TypeError(message)
+                if isinstance(value, bytes):
+                    kwargs[key] = value.decode("ascii")
+
+            if "params" in kwargs:
+                # Replace any "params" keyword with the raw "query" instead.
+                #
+                # Ensure that empty params use `kwargs["query"] = None` rather
+                # than `kwargs["query"] = ""`, so that generated URLs do not
+                # include an empty trailing "?".
+                params = kwargs.pop("params")
+                kwargs["query"] = None if not params else str(QueryParams(params))
+
+        if isinstance(url, str):
+            self._uri_reference = urlparse(url, **kwargs)
+        elif isinstance(url, URL):
+            self._uri_reference = url._uri_reference.copy_with(**kwargs)
+        else:
+            raise TypeError(
+                "Invalid type for url.  Expected str or httpx.URL,"
+                f" got {type(url)}: {url!r}"
+            )
+
+    @property
+    def scheme(self) -> str:
+        """
+        The URL scheme, such as "http", "https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme
+
+    @property
+    def raw_scheme(self) -> bytes:
+        """
+        The raw bytes representation of the URL scheme, such as b"http", b"https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme.encode("ascii")
+
+    @property
+    def userinfo(self) -> bytes:
+        """
+        The URL userinfo as a raw bytestring.
+        For example: b"jo%40email.com:a%20secret".
+        """
+        return self._uri_reference.userinfo.encode("ascii")
+
+    @property
+    def username(self) -> str:
+        """
+        The URL username as a string, with URL decoding applied.
+        For example: "jo@email.com"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[0])
+
+    @property
+    def password(self) -> str:
+        """
+        The URL password as a string, with URL decoding applied.
+        For example: "a secret"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[2])
+
+    @property
+    def host(self) -> str:
+        """
+        The URL host as a string.
+        Always normalized to lowercase, with IDNA hosts decoded into unicode.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.host == "www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.host == "::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host
+
+        if host.startswith("xn--"):
+            host = idna.decode(host)
+
+        return host
+
+    @property
+    def raw_host(self) -> bytes:
+        """
+        The raw bytes representation of the URL host.
+        Always normalized to lowercase, and IDNA encoded.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.raw_host == b"www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.raw_host == b"::ffff:192.168.0.1"
+        """
+        return self._uri_reference.host.encode("ascii")
+
+    @property
+    def port(self) -> int | None:
+        """
+        The URL port as an integer.
+
+        Note that the URL class performs port normalization as per the WHATWG spec.
+        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
+        treated as `None`.
+
+        For example:
+
+        assert httpx.URL("http://www.example.com") == httpx.URL("http://www.example.com:80")
+        assert httpx.URL("http://www.example.com:80").port is None
+        """
+        return self._uri_reference.port
+
+    @property
+    def netloc(self) -> bytes:
+        """
+        Either `` or `:` as bytes.
+        Always normalized to lowercase, and IDNA encoded.
+
+        This property may be used for generating the value of a request
+        "Host" header.
+        """
+        return self._uri_reference.netloc.encode("ascii")
+
+    @property
+    def path(self) -> str:
+        """
+        The URL path as a string. Excluding the query string, and URL decoded.
+
+        For example:
+
+        url = httpx.URL("https://example.com/pa%20th")
+        assert url.path == "/pa th"
+        """
+        path = self._uri_reference.path or "/"
+        return unquote(path)
+
+    @property
+    def query(self) -> bytes:
+        """
+        The URL query string, as raw bytes, excluding the leading b"?".
+
+        This is necessarily a bytewise interface, because we cannot
+        perform URL decoding of this representation until we've parsed
+        the keys and values into a QueryParams instance.
+
+        For example:
+
+        url = httpx.URL("https://example.com/?filter=some%20search%20terms")
+        assert url.query == b"filter=some%20search%20terms"
+        """
+        query = self._uri_reference.query or ""
+        return query.encode("ascii")
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        The URL query parameters, neatly parsed and packaged into an immutable
+        multidict representation.
+        """
+        return QueryParams(self._uri_reference.query)
+
+    @property
+    def raw_path(self) -> bytes:
+        """
+        The complete URL path and query string as raw bytes.
+        Used as the target when constructing HTTP requests.
+
+        For example:
+
+        GET /users?search=some%20text HTTP/1.1
+        Host: www.example.org
+        Connection: close
+        """
+        path = self._uri_reference.path or "/"
+        if self._uri_reference.query is not None:
+            path += "?" + self._uri_reference.query
+        return path.encode("ascii")
+
+    @property
+    def fragment(self) -> str:
+        """
+        The URL fragments, as used in HTML anchors.
+        As a string, without the leading '#'.
+        """
+        return unquote(self._uri_reference.fragment or "")
+
+    @property
+    def is_absolute_url(self) -> bool:
+        """
+        Return `True` for absolute URLs such as 'http://example.com/path',
+        and `False` for relative URLs such as '/path'.
+        """
+        # We don't use `.is_absolute` from `rfc3986` because it treats
+        # URLs with a fragment portion as not absolute.
+        # What we actually care about is if the URL provides
+        # a scheme and hostname to which connections should be made.
+        return bool(self._uri_reference.scheme and self._uri_reference.host)
+
+    @property
+    def is_relative_url(self) -> bool:
+        """
+        Return `False` for absolute URLs such as 'http://example.com/path',
+        and `True` for relative URLs such as '/path'.
+        """
+        return not self.is_absolute_url
+
+    def copy_with(self, **kwargs: typing.Any) -> URL:
+        """
+        Copy this URL, returning a new URL with some components altered.
+        Accepts the same set of parameters as the components that are made
+        available via properties on the `URL` class.
+
+        For example:
+
+        url = httpx.URL("https://www.example.com").copy_with(
+            username="jo@gmail.com", password="a secret"
+        )
+        assert url == "https://jo%40email.com:a%20secret@www.example.com"
+        """
+        return URL(self, **kwargs)
+
+    def copy_set_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.set(key, value))
+
+    def copy_add_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.add(key, value))
+
+    def copy_remove_param(self, key: str) -> URL:
+        return self.copy_with(params=self.params.remove(key))
+
+    def copy_merge_params(self, params: QueryParamTypes) -> URL:
+        return self.copy_with(params=self.params.merge(params))
+
+    def join(self, url: URL | str) -> URL:
+        """
+        Return an absolute URL, using this URL as the base.
+
+        Eg.
+
+        url = httpx.URL("https://www.example.com/test")
+        url = url.join("/new/path")
+        assert url == "https://www.example.com/new/path"
+        """
+        from urllib.parse import urljoin
+
+        return URL(urljoin(str(self), str(URL(url))))
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
+
+    def __str__(self) -> str:
+        return str(self._uri_reference)
+
+    def __repr__(self) -> str:
+        scheme, userinfo, host, port, path, query, fragment = self._uri_reference
+
+        if ":" in userinfo:
+            # Mask any password component.
+            userinfo = f'{userinfo.split(":")[0]}:[secure]'
+
+        authority = "".join(
+            [
+                f"{userinfo}@" if userinfo else "",
+                f"[{host}]" if ":" in host else host,
+                f":{port}" if port is not None else "",
+            ]
+        )
+        url = "".join(
+            [
+                f"{self.scheme}:" if scheme else "",
+                f"//{authority}" if authority else "",
+                path,
+                f"?{query}" if query is not None else "",
+                f"#{fragment}" if fragment is not None else "",
+            ]
+        )
+
+        return f"{self.__class__.__name__}({url!r})"
+
+    @property
+    def raw(self) -> tuple[bytes, bytes, int, bytes]:  # pragma: nocover
+        import collections
+        import warnings
+
+        warnings.warn("URL.raw is deprecated.")
+        RawURL = collections.namedtuple(
+            "RawURL", ["raw_scheme", "raw_host", "port", "raw_path"]
+        )
+        return RawURL(
+            raw_scheme=self.raw_scheme,
+            raw_host=self.raw_host,
+            port=self.port,
+            raw_path=self.raw_path,
+        )
+
+
+class QueryParams(typing.Mapping[str, str]):
+    """
+    URL query parameters, as a multi-dict.
+    """
+
+    def __init__(self, *args: QueryParamTypes | None, **kwargs: typing.Any) -> None:
+        assert len(args) < 2, "Too many arguments."
+        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
+
+        value = args[0] if args else kwargs
+
+        if value is None or isinstance(value, (str, bytes)):
+            value = value.decode("ascii") if isinstance(value, bytes) else value
+            self._dict = parse_qs(value, keep_blank_values=True)
+        elif isinstance(value, QueryParams):
+            self._dict = {k: list(v) for k, v in value._dict.items()}
+        else:
+            dict_value: dict[typing.Any, list[typing.Any]] = {}
+            if isinstance(value, (list, tuple)):
+                # Convert list inputs like:
+                #     [("a", "123"), ("a", "456"), ("b", "789")]
+                # To a dict representation, like:
+                #     {"a": ["123", "456"], "b": ["789"]}
+                for item in value:
+                    dict_value.setdefault(item[0], []).append(item[1])
+            else:
+                # Convert dict inputs like:
+                #    {"a": "123", "b": ["456", "789"]}
+                # To dict inputs where values are always lists, like:
+                #    {"a": ["123"], "b": ["456", "789"]}
+                dict_value = {
+                    k: list(v) if isinstance(v, (list, tuple)) else [v]
+                    for k, v in value.items()
+                }
+
+            # Ensure that keys and values are neatly coerced to strings.
+            # We coerce values `True` and `False` to JSON-like "true" and "false"
+            # representations, and coerce `None` values to the empty string.
+            self._dict = {
+                str(k): [primitive_value_to_str(item) for item in v]
+                for k, v in dict_value.items()
+            }
+
+    def keys(self) -> typing.KeysView[str]:
+        """
+        Return all the keys in the query params.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.keys()) == ["a", "b"]
+        """
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        """
+        Return all the values in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.values()) == ["123", "789"]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return all items in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.items()) == [("a", "123"), ("b", "789")]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return all items in the query params. Allow duplicate keys to occur.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
+        """
+        multi_items: list[tuple[str, str]] = []
+        for k, v in self._dict.items():
+            multi_items.extend([(k, i) for i in v])
+        return multi_items
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        """
+        Get a value from the query param for a given key. If the key occurs
+        more than once, then only the first value is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get("a") == "123"
+        """
+        if key in self._dict:
+            return self._dict[str(key)][0]
+        return default
+
+    def get_list(self, key: str) -> list[str]:
+        """
+        Get all values from the query param for a given key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get_list("a") == ["123", "456"]
+        """
+        return list(self._dict.get(str(key), []))
+
+    def set(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.set("a", "456")
+        assert q == httpx.QueryParams("a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = [primitive_value_to_str(value)]
+        return q
+
+    def add(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting or appending the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.add("a", "456")
+        assert q == httpx.QueryParams("a=123&a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
+        return q
+
+    def remove(self, key: str) -> QueryParams:
+        """
+        Return a new QueryParams instance, removing the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.remove("a")
+        assert q == httpx.QueryParams("")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict.pop(str(key), None)
+        return q
+
+    def merge(self, params: QueryParamTypes | None = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, updated with.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"b": "456"})
+        assert q == httpx.QueryParams("a=123&b=456")
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"a": "456", "b": "789"})
+        assert q == httpx.QueryParams("a=456&b=789")
+        """
+        q = QueryParams(params)
+        q._dict = {**self._dict, **q._dict}
+        return q
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key][0]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        return bool(self._dict)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self.multi_items()) == sorted(other.multi_items())
+
+    def __str__(self) -> str:
+        return urlencode(self.multi_items())
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+    def update(self, params: QueryParamTypes | None = None) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.merge(...)` to create an updated copy."
+        )
+
+    def __setitem__(self, key: str, value: str) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.set(key, value)` to create an updated copy."
+        )
diff --git a/.venv/lib/python3.10/site-packages/httpx/_utils.py b/.venv/lib/python3.10/site-packages/httpx/_utils.py
new file mode 100644
index 0000000..7fe827d
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/httpx/_utils.py
@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import ipaddress
+import os
+import re
+import typing
+from urllib.request import getproxies
+
+from ._types import PrimitiveData
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from ._urls import URL
+
+
+def primitive_value_to_str(value: PrimitiveData) -> str:
+    """
+    Coerce a primitive data type into a string value.
+
+    Note that we prefer JSON-style 'true'/'false' for boolean values here.
+    """
+    if value is True:
+        return "true"
+    elif value is False:
+        return "false"
+    elif value is None:
+        return ""
+    return str(value)
+
+
+def get_environment_proxies() -> dict[str, str | None]:
+    """Gets proxy information from the environment"""
+
+    # urllib.request.getproxies() falls back on System
+    # Registry and Config for proxies on Windows and macOS.
+    # We don't want to propagate non-HTTP proxies into
+    # our configuration such as 'TRAVIS_APT_PROXY'.
+    proxy_info = getproxies()
+    mounts: dict[str, str | None] = {}
+
+    for scheme in ("http", "https", "all"):
+        if proxy_info.get(scheme):
+            hostname = proxy_info[scheme]
+            mounts[f"{scheme}://"] = (
+                hostname if "://" in hostname else f"http://{hostname}"
+            )
+
+    no_proxy_hosts = [host.strip() for host in proxy_info.get("no", "").split(",")]
+    for hostname in no_proxy_hosts:
+        # See https://curl.haxx.se/libcurl/c/CURLOPT_NOPROXY.html for details
+        # on how names in `NO_PROXY` are handled.
+        if hostname == "*":
+            # If NO_PROXY=* is used or if "*" occurs as any one of the comma
+            # separated hostnames, then we should just bypass any information
+            # from HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and always ignore
+            # proxies.
+            return {}
+        elif hostname:
+            # NO_PROXY=.google.com is marked as "all://*.google.com,
+            #   which disables "www.google.com" but not "google.com"
+            # NO_PROXY=google.com is marked as "all://*google.com,
+            #   which disables "www.google.com" and "google.com".
+            #   (But not "wwwgoogle.com")
+            # NO_PROXY can include domains, IPv6, IPv4 addresses and "localhost"
+            #   NO_PROXY=example.com,::1,localhost,192.168.0.0/16
+            if "://" in hostname:
+                mounts[hostname] = None
+            elif is_ipv4_hostname(hostname):
+                mounts[f"all://{hostname}"] = None
+            elif is_ipv6_hostname(hostname):
+                mounts[f"all://[{hostname}]"] = None
+            elif hostname.lower() == "localhost":
+                mounts[f"all://{hostname}"] = None
+            else:
+                mounts[f"all://*{hostname}"] = None
+
+    return mounts
+
+
+def to_bytes(value: str | bytes, encoding: str = "utf-8") -> bytes:
+    return value.encode(encoding) if isinstance(value, str) else value
+
+
+def to_str(value: str | bytes, encoding: str = "utf-8") -> str:
+    return value if isinstance(value, str) else value.decode(encoding)
+
+
+def to_bytes_or_str(value: str, match_type_of: typing.AnyStr) -> typing.AnyStr:
+    return value if isinstance(match_type_of, str) else value.encode()
+
+
+def unquote(value: str) -> str:
+    return value[1:-1] if value[0] == value[-1] == '"' else value
+
+
+def peek_filelike_length(stream: typing.Any) -> int | None:
+    """
+    Given a file-like stream object, return its length in number of bytes
+    without reading it into memory.
+    """
+    try:
+        # Is it an actual file?
+        fd = stream.fileno()
+        # Yup, seems to be an actual file.
+        length = os.fstat(fd).st_size
+    except (AttributeError, OSError):
+        # No... Maybe it's something that supports random access, like `io.BytesIO`?
+        try:
+            # Assuming so, go to end of stream to figure out its length,
+            # then put it back in place.
+            offset = stream.tell()
+            length = stream.seek(0, os.SEEK_END)
+            stream.seek(offset)
+        except (AttributeError, OSError):
+            # Not even that? Sorry, we're doomed...
+            return None
+
+    return length
+
+
+class URLPattern:
+    """
+    A utility class currently used for making lookups against proxy keys...
+
+    # Wildcard matching...
+    >>> pattern = URLPattern("all://")
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+
+    # Witch scheme matching...
+    >>> pattern = URLPattern("https://")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+
+    # With domain matching...
+    >>> pattern = URLPattern("https://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # Wildcard scheme, with domain matching...
+    >>> pattern = URLPattern("all://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # With port matching...
+    >>> pattern = URLPattern("https://example.com:1234")
+    >>> pattern.matches(httpx.URL("https://example.com:1234"))
+    True
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    False
+    """
+
+    def __init__(self, pattern: str) -> None:
+        from ._urls import URL
+
+        if pattern and ":" not in pattern:
+            raise ValueError(
+                f"Proxy keys should use proper URL forms rather "
+                f"than plain scheme strings. "
+                f'Instead of "{pattern}", use "{pattern}://"'
+            )
+
+        url = URL(pattern)
+        self.pattern = pattern
+        self.scheme = "" if url.scheme == "all" else url.scheme
+        self.host = "" if url.host == "*" else url.host
+        self.port = url.port
+        if not url.host or url.host == "*":
+            self.host_regex: typing.Pattern[str] | None = None
+        elif url.host.startswith("*."):
+            # *.example.com should match "www.example.com", but not "example.com"
+            domain = re.escape(url.host[2:])
+            self.host_regex = re.compile(f"^.+\\.{domain}$")
+        elif url.host.startswith("*"):
+            # *example.com should match "www.example.com" and "example.com"
+            domain = re.escape(url.host[1:])
+            self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
+        else:
+            # example.com should match "example.com" but not "www.example.com"
+            domain = re.escape(url.host)
+            self.host_regex = re.compile(f"^{domain}$")
+
+    def matches(self, other: URL) -> bool:
+        if self.scheme and self.scheme != other.scheme:
+            return False
+        if (
+            self.host
+            and self.host_regex is not None
+            and not self.host_regex.match(other.host)
+        ):
+            return False
+        if self.port is not None and self.port != other.port:
+            return False
+        return True
+
+    @property
+    def priority(self) -> tuple[int, int, int]:
+        """
+        The priority allows URLPattern instances to be sortable, so that
+        we can match from most specific to least specific.
+        """
+        # URLs with a port should take priority over URLs without a port.
+        port_priority = 0 if self.port is not None else 1
+        # Longer hostnames should match first.
+        host_priority = -len(self.host)
+        # Longer schemes should match first.
+        scheme_priority = -len(self.scheme)
+        return (port_priority, host_priority, scheme_priority)
+
+    def __hash__(self) -> int:
+        return hash(self.pattern)
+
+    def __lt__(self, other: URLPattern) -> bool:
+        return self.priority < other.priority
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, URLPattern) and self.pattern == other.pattern
+
+
+def is_ipv4_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv4Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
+
+
+def is_ipv6_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv6Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
diff --git a/.venv/lib/python3.10/site-packages/httpx/py.typed b/.venv/lib/python3.10/site-packages/httpx/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/METADATA b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/METADATA
new file mode 100644
index 0000000..7a4a4b7
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/METADATA
@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: idna
+Version: 3.11
+Summary: Internationalized Domain Names in Applications (IDNA)
+Author-email: Kim Davies 
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+License-File: LICENSE.md
+Requires-Dist: ruff >= 0.6.2 ; extra == "all"
+Requires-Dist: mypy >= 1.11.2 ; extra == "all"
+Requires-Dist: pytest >= 8.3.2 ; extra == "all"
+Requires-Dist: flake8 >= 7.1.1 ; extra == "all"
+Project-URL: Changelog, https://github.com/kjd/idna/blob/master/HISTORY.rst
+Project-URL: Issue tracker, https://github.com/kjd/idna/issues
+Project-URL: Source, https://github.com/kjd/idna
+Provides-Extra: all
+
+Internationalized Domain Names in Applications (IDNA)
+=====================================================
+
+Support for `Internationalized Domain Names in
+Applications (IDNA) `_
+and `Unicode IDNA Compatibility Processing
+`_.
+
+The latest versions of these standards supplied here provide
+more comprehensive language coverage and reduce the potential of
+allowing domains with known security vulnerabilities. This library
+is a suitable replacement for the “encodings.idna”
+module that comes with the Python standard library, but which
+only supports an older superseded IDNA specification from 2003.
+
+Basic functions are simply executed:
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+
+Installation
+------------
+
+This package is available for installation from PyPI via the
+typical mechanisms, such as:
+
+.. code-block:: bash
+
+    $ python3 -m pip install idna
+
+
+Usage
+-----
+
+For typical usage, the ``encode`` and ``decode`` functions will take a
+domain name argument and perform a conversion to ASCII compatible encoding
+(known as A-labels), or to Unicode strings (known as U-labels)
+respectively.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+Conversions can be applied at a per-label basis using the ``ulabel`` or
+``alabel`` functions if necessary:
+
+.. code-block:: pycon
+
+    >>> idna.alabel('测试')
+    b'xn--0zwm56d'
+
+
+Compatibility Mapping (UTS #46)
++++++++++++++++++++++++++++++++
+
+This library provides support for `Unicode IDNA Compatibility
+Processing `_ which normalizes input from
+different potential ways a user may input a domain prior to performing the IDNA
+conversion operations. This functionality, known as a 
+`mapping `_, is considered by the
+specification to be a local user-interface issue distinct from IDNA
+conversion functionality.
+
+For example, “Königsgäßchen” is not a permissible label as *LATIN
+CAPITAL LETTER K* is not allowed (nor are capital letters in general).
+UTS 46 will convert this into lower case prior to applying the IDNA
+conversion.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('Königsgäßchen')
+    ...
+    idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
+    >>> idna.encode('Königsgäßchen', uts46=True)
+    b'xn--knigsgchen-b4a3dun'
+    >>> print(idna.decode('xn--knigsgchen-b4a3dun'))
+    königsgäßchen
+
+
+Exceptions
+----------
+
+All errors raised during the conversion following the specification
+should raise an exception derived from the ``idna.IDNAError`` base
+class.
+
+More specific exceptions that may be generated as ``idna.IDNABidiError``
+when the error reflects an illegal combination of left-to-right and
+right-to-left characters in a label; ``idna.InvalidCodepoint`` when
+a specific codepoint is an illegal character in an IDN label (i.e.
+INVALID); and ``idna.InvalidCodepointContext`` when the codepoint is
+illegal based on its position in the string (i.e. it is CONTEXTO or CONTEXTJ
+but the contextual requirements are not satisfied.)
+
+Building and Diagnostics
+------------------------
+
+The IDNA and UTS 46 functionality relies upon pre-calculated lookup
+tables for performance. These tables are derived from computing against
+eligibility criteria in the respective standards using the command-line
+script ``tools/idna-data``.
+
+This tool will fetch relevant codepoint data from the Unicode repository
+and perform the required calculations to identify eligibility. There are
+three main modes:
+
+* ``idna-data make-libdata``. Generates ``idnadata.py`` and
+  ``uts46data.py``, the pre-calculated lookup tables used for IDNA and
+  UTS 46 conversions. Implementers who wish to track this library against
+  a different Unicode version may use this tool to manually generate a
+  different version of the ``idnadata.py`` and ``uts46data.py`` files.
+
+* ``idna-data make-table``. Generate a table of the IDNA disposition
+  (e.g. PVALID, CONTEXTJ, CONTEXTO) in the format found in Appendix
+  B.1 of RFC 5892 and the pre-computed tables published by `IANA
+  `_.
+
+* ``idna-data U+0061``. Prints debugging output on the various
+  properties associated with an individual Unicode codepoint (in this
+  case, U+0061), that are used to assess the IDNA and UTS 46 status of a
+  codepoint. This is helpful in debugging or analysis.
+
+The tool accepts a number of arguments, described using ``idna-data
+-h``. Most notably, the ``--version`` argument allows the specification
+of the version of Unicode to be used in computing the table data. For
+example, ``idna-data --version 9.0.0 make-libdata`` will generate
+library data against Unicode 9.0.0.
+
+
+Additional Notes
+----------------
+
+* **Packages**. The latest tagged release version is published in the
+  `Python Package Index `_.
+
+* **Version support**. This library supports Python 3.8 and higher.
+  As this library serves as a low-level toolkit for a variety of
+  applications, many of which strive for broad compatibility with older
+  Python versions, there is no rush to remove older interpreter support.
+  Support for older versions are likely to be removed from new releases
+  as automated tests can no longer easily be run, i.e. once the Python
+  version is officially end-of-life.
+
+* **Testing**. The library has a test suite based on each rule of the
+  IDNA specification, as well as tests that are provided as part of the
+  Unicode Technical Standard 46, `Unicode IDNA Compatibility Processing
+  `_.
+
+* **Emoji**. It is an occasional request to support emoji domains in
+  this library. Encoding of symbols like emoji is expressly prohibited by
+  the technical standard IDNA 2008 and emoji domains are broadly phased
+  out across the domain industry due to associated security risks. For
+  now, applications that need to support these non-compliant labels
+  may wish to consider trying the encode/decode operation in this library
+  first, and then falling back to using `encodings.idna`. See `the Github
+  project `_ for more discussion.
+
+* **Transitional processing**. Unicode 16.0.0 removed transitional
+  processing so the `transitional` argument for the encode() method
+  no longer has any effect and will be removed at a later date.
+
diff --git a/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/RECORD b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/RECORD
new file mode 100644
index 0000000..8995942
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/RECORD
@@ -0,0 +1,22 @@
+idna-3.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+idna-3.11.dist-info/METADATA,sha256=fCwSww9SuiN8TIHllFSASUQCW55hAs8dzKnr9RaEEbA,8378
+idna-3.11.dist-info/RECORD,,
+idna-3.11.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+idna-3.11.dist-info/licenses/LICENSE.md,sha256=t6M2q_OwThgOwGXN0W5wXQeeHMehT5EKpukYfza5zYc,1541
+idna/__init__.py,sha256=MPqNDLZbXqGaNdXxAFhiqFPKEQXju2jNQhCey6-5eJM,868
+idna/__pycache__/__init__.cpython-310.pyc,,
+idna/__pycache__/codec.cpython-310.pyc,,
+idna/__pycache__/compat.cpython-310.pyc,,
+idna/__pycache__/core.cpython-310.pyc,,
+idna/__pycache__/idnadata.cpython-310.pyc,,
+idna/__pycache__/intranges.cpython-310.pyc,,
+idna/__pycache__/package_data.cpython-310.pyc,,
+idna/__pycache__/uts46data.cpython-310.pyc,,
+idna/codec.py,sha256=M2SGWN7cs_6B32QmKTyTN6xQGZeYQgQ2wiX3_DR6loE,3438
+idna/compat.py,sha256=RzLy6QQCdl9784aFhb2EX9EKGCJjg0P3PilGdeXXcx8,316
+idna/core.py,sha256=P26_XVycuMTZ1R2mNK1ZREVzM5mvTzdabBXfyZVU1Lc,13246
+idna/idnadata.py,sha256=SG8jhaGE53iiD6B49pt2pwTv_UvClciWE-N54oR2p4U,79623
+idna/intranges.py,sha256=amUtkdhYcQG8Zr-CoMM_kVRacxkivC1WgxN1b63KKdU,1898
+idna/package_data.py,sha256=_CUavOxobnbyNG2FLyHoN8QHP3QM9W1tKuw7eq9QwBk,21
+idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idna/uts46data.py,sha256=H9J35VkD0F9L9mKOqjeNGd2A-Va6FlPoz6Jz4K7h-ps,243725
diff --git a/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/WHEEL
new file mode 100644
index 0000000..d8b9936
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/licenses/LICENSE.md b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/licenses/LICENSE.md
new file mode 100644
index 0000000..256ba90
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna-3.11.dist-info/licenses/LICENSE.md
@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+Copyright (c) 2013-2025, Kim Davies and 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 the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.venv/lib/python3.10/site-packages/idna/__init__.py b/.venv/lib/python3.10/site-packages/idna/__init__.py
new file mode 100644
index 0000000..cfdc030
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/__init__.py
@@ -0,0 +1,45 @@
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+from .package_data import __version__
+
+__all__ = [
+    "__version__",
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..73f4b7d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/__init__.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/codec.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/codec.cpython-310.pyc
new file mode 100644
index 0000000..406fe80
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/codec.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/compat.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/compat.cpython-310.pyc
new file mode 100644
index 0000000..48b282e
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/compat.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/core.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/core.cpython-310.pyc
new file mode 100644
index 0000000..83bb604
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/core.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/idnadata.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/idnadata.cpython-310.pyc
new file mode 100644
index 0000000..11f4be7
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/idnadata.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/intranges.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/intranges.cpython-310.pyc
new file mode 100644
index 0000000..63adf11
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/intranges.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/package_data.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/package_data.cpython-310.pyc
new file mode 100644
index 0000000..8e21706
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/package_data.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/__pycache__/uts46data.cpython-310.pyc b/.venv/lib/python3.10/site-packages/idna/__pycache__/uts46data.cpython-310.pyc
new file mode 100644
index 0000000..1875a11
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/idna/__pycache__/uts46data.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/idna/codec.py b/.venv/lib/python3.10/site-packages/idna/codec.py
new file mode 100644
index 0000000..cbc2e4f
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/codec.py
@@ -0,0 +1,122 @@
+import codecs
+import re
+from typing import Any, Optional, Tuple
+
+from .core import IDNAError, alabel, decode, encode, ulabel
+
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
+
+
+class Codec(codecs.Codec):
+    def encode(self, data: str, errors: str = "strict") -> Tuple[bytes, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
+
+        if not data:
+            return b"", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data: bytes, errors: str = "strict") -> Tuple[str, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
+
+        if not data:
+            return "", 0
+
+        return decode(data), len(data)
+
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
+
+        if not data:
+            return b"", 0
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = b""
+        if labels:
+            if not labels[-1]:
+                trailing_dot = b"."
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = b"."
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result_bytes = b".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return result_bytes, size
+
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
+
+        if not data:
+            return ("", 0)
+
+        if not isinstance(data, str):
+            data = str(data, "ascii")
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ""
+        if labels:
+            if not labels[-1]:
+                trailing_dot = "."
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = "."
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result_str = ".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result_str, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+def search_function(name: str) -> Optional[codecs.CodecInfo]:
+    if name != "idna2008":
+        return None
+    return codecs.CodecInfo(
+        name=name,
+        encode=Codec().encode,
+        decode=Codec().decode,  # type: ignore
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
+
+
+codecs.register(search_function)
diff --git a/.venv/lib/python3.10/site-packages/idna/compat.py b/.venv/lib/python3.10/site-packages/idna/compat.py
new file mode 100644
index 0000000..1df9f2a
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/compat.py
@@ -0,0 +1,15 @@
+from typing import Any, Union
+
+from .core import decode, encode
+
+
+def ToASCII(label: str) -> bytes:
+    return encode(label)
+
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
+    return decode(label)
+
+
+def nameprep(s: Any) -> None:
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")
diff --git a/.venv/lib/python3.10/site-packages/idna/core.py b/.venv/lib/python3.10/site-packages/idna/core.py
new file mode 100644
index 0000000..8177bf7
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/core.py
@@ -0,0 +1,437 @@
+import bisect
+import re
+import unicodedata
+from typing import Optional, Union
+
+from . import idnadata
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b"xn--"
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
+
+
+class IDNAError(UnicodeError):
+    """Base exception for all IDNA-encoding related problems"""
+
+    pass
+
+
+class IDNABidiError(IDNAError):
+    """Exception when bidirectional requirements are not satisfied"""
+
+    pass
+
+
+class InvalidCodepoint(IDNAError):
+    """Exception when a disallowed or unallocated codepoint is used"""
+
+    pass
+
+
+class InvalidCodepointContext(IDNAError):
+    """Exception when the codepoint is not valid in the context it is used"""
+
+    pass
+
+
+def _combining_class(cp: int) -> int:
+    v = unicodedata.combining(chr(cp))
+    if v == 0:
+        if not unicodedata.name(chr(cp)):
+            raise ValueError("Unknown character in unicodedata")
+    return v
+
+
+def _is_script(cp: str, script: str) -> bool:
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+
+def _punycode(s: str) -> bytes:
+    return s.encode("punycode")
+
+
+def _unot(s: int) -> str:
+    return "U+{:04X}".format(s)
+
+
+def valid_label_length(label: Union[bytes, str]) -> bool:
+    if len(label) > 63:
+        return False
+    return True
+
+
+def valid_string_length(label: Union[bytes, str], trailing_dot: bool) -> bool:
+    if len(label) > (254 if trailing_dot else 253):
+        return False
+    return True
+
+
+def check_bidi(label: str, check_ltr: bool = False) -> bool:
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for idx, cp in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == "":
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError("Unknown directionality in label {} at position {}".format(repr(label), idx))
+        if direction in ["R", "AL", "AN"]:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in ["R", "AL"]:
+        rtl = True
+    elif direction == "L":
+        rtl = False
+    else:
+        raise IDNABidiError("First codepoint in label {} must be directionality L, R or AL".format(repr(label)))
+
+    valid_ending = False
+    number_type: Optional[str] = None
+    for idx, cp in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if direction not in [
+                "R",
+                "AL",
+                "AN",
+                "EN",
+                "ES",
+                "CS",
+                "ET",
+                "ON",
+                "BN",
+                "NSM",
+            ]:
+                raise IDNABidiError("Invalid direction for codepoint at position {} in a right-to-left label".format(idx))
+            # Bidi rule 3
+            if direction in ["R", "AL", "EN", "AN"]:
+                valid_ending = True
+            elif direction != "NSM":
+                valid_ending = False
+            # Bidi rule 4
+            if direction in ["AN", "EN"]:
+                if not number_type:
+                    number_type = direction
+                else:
+                    if number_type != direction:
+                        raise IDNABidiError("Can not mix numeral types in a right-to-left label")
+        else:
+            # Bidi rule 5
+            if direction not in ["L", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"]:
+                raise IDNABidiError("Invalid direction for codepoint at position {} in a left-to-right label".format(idx))
+            # Bidi rule 6
+            if direction in ["L", "EN"]:
+                valid_ending = True
+            elif direction != "NSM":
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError("Label ends with illegal codepoint directionality")
+
+    return True
+
+
+def check_initial_combiner(label: str) -> bool:
+    if unicodedata.category(label[0])[0] == "M":
+        raise IDNAError("Label begins with an illegal combining character")
+    return True
+
+
+def check_hyphen_ok(label: str) -> bool:
+    if label[2:4] == "--":
+        raise IDNAError("Label has disallowed hyphens in 3rd and 4th position")
+    if label[0] == "-" or label[-1] == "-":
+        raise IDNAError("Label must not start or end with a hyphen")
+    return True
+
+
+def check_nfc(label: str) -> None:
+    if unicodedata.normalize("NFC", label) != label:
+        raise IDNAError("Label must be in Normalization Form C")
+
+
+def valid_contextj(label: str, pos: int) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200C:
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+
+        ok = False
+        for i in range(pos - 1, -1, -1):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord("T"):
+                continue
+            elif joining_type in [ord("L"), ord("D")]:
+                ok = True
+                break
+            else:
+                break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos + 1, len(label)):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord("T"):
+                continue
+            elif joining_type in [ord("R"), ord("D")]:
+                ok = True
+                break
+            else:
+                break
+        return ok
+
+    if cp_value == 0x200D:
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+        return False
+
+    else:
+        return False
+
+
+def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00B7:
+        if 0 < pos < len(label) - 1:
+            if ord(label[pos - 1]) == 0x006C and ord(label[pos + 1]) == 0x006C:
+                return True
+        return False
+
+    elif cp_value == 0x0375:
+        if pos < len(label) - 1 and len(label) > 1:
+            return _is_script(label[pos + 1], "Greek")
+        return False
+
+    elif cp_value == 0x05F3 or cp_value == 0x05F4:
+        if pos > 0:
+            return _is_script(label[pos - 1], "Hebrew")
+        return False
+
+    elif cp_value == 0x30FB:
+        for cp in label:
+            if cp == "\u30fb":
+                continue
+            if _is_script(cp, "Hiragana") or _is_script(cp, "Katakana") or _is_script(cp, "Han"):
+                return True
+        return False
+
+    elif 0x660 <= cp_value <= 0x669:
+        for cp in label:
+            if 0x6F0 <= ord(cp) <= 0x06F9:
+                return False
+        return True
+
+    elif 0x6F0 <= cp_value <= 0x6F9:
+        for cp in label:
+            if 0x660 <= ord(cp) <= 0x0669:
+                return False
+        return True
+
+    return False
+
+
+def check_label(label: Union[str, bytes, bytearray]) -> None:
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode("utf-8")
+    if len(label) == 0:
+        raise IDNAError("Empty Label")
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for pos, cp in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes["PVALID"]):
+            continue
+        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTJ"]):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext(
+                        "Joiner {} not allowed at position {} in {}".format(_unot(cp_value), pos + 1, repr(label))
+                    )
+            except ValueError:
+                raise IDNAError(
+                    "Unknown codepoint adjacent to joiner {} at position {} in {}".format(
+                        _unot(cp_value), pos + 1, repr(label)
+                    )
+                )
+        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTO"]):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext(
+                    "Codepoint {} not allowed at position {} in {}".format(_unot(cp_value), pos + 1, repr(label))
+                )
+        else:
+            raise InvalidCodepoint(
+                "Codepoint {} at position {} of {} not allowed".format(_unot(cp_value), pos + 1, repr(label))
+            )
+
+    check_bidi(label)
+
+
+def alabel(label: str) -> bytes:
+    try:
+        label_bytes = label.encode("ascii")
+        ulabel(label_bytes)
+        if not valid_label_length(label_bytes):
+            raise IDNAError("Label too long")
+        return label_bytes
+    except UnicodeEncodeError:
+        pass
+
+    check_label(label)
+    label_bytes = _alabel_prefix + _punycode(label)
+
+    if not valid_label_length(label_bytes):
+        raise IDNAError("Label too long")
+
+    return label_bytes
+
+
+def ulabel(label: Union[str, bytes, bytearray]) -> str:
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label_bytes = label.encode("ascii")
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+    else:
+        label_bytes = bytes(label)
+
+    label_bytes = label_bytes.lower()
+    if label_bytes.startswith(_alabel_prefix):
+        label_bytes = label_bytes[len(_alabel_prefix) :]
+        if not label_bytes:
+            raise IDNAError("Malformed A-label, no Punycode eligible content found")
+        if label_bytes.decode("ascii")[-1] == "-":
+            raise IDNAError("A-label must not end with a hyphen")
+    else:
+        check_label(label_bytes)
+        return label_bytes.decode("ascii")
+
+    try:
+        label = label_bytes.decode("punycode")
+    except UnicodeError:
+        raise IDNAError("Invalid A-label")
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
+    """Re-map the characters in the string according to UTS46 processing."""
+    from .uts46data import uts46data
+
+    output = ""
+
+    for pos, char in enumerate(domain):
+        code_point = ord(char)
+        try:
+            uts46row = uts46data[code_point if code_point < 256 else bisect.bisect_left(uts46data, (code_point, "Z")) - 1]
+            status = uts46row[1]
+            replacement: Optional[str] = None
+            if len(uts46row) == 3:
+                replacement = uts46row[2]
+            if (
+                status == "V"
+                or (status == "D" and not transitional)
+                or (status == "3" and not std3_rules and replacement is None)
+            ):
+                output += char
+            elif replacement is not None and (
+                status == "M" or (status == "3" and not std3_rules) or (status == "D" and transitional)
+            ):
+                output += replacement
+            elif status != "I":
+                raise IndexError()
+        except IndexError:
+            raise InvalidCodepoint(
+                "Codepoint {} not allowed at position {} in {}".format(_unot(code_point), pos + 1, repr(domain))
+            )
+
+    return unicodedata.normalize("NFC", output)
+
+
+def encode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+    transitional: bool = False,
+) -> bytes:
+    if not isinstance(s, str):
+        try:
+            s = str(s, "ascii")
+        except UnicodeDecodeError:
+            raise IDNAError("should pass a unicode string to the function rather than a byte string.")
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+    trailing_dot = False
+    result = []
+    if strict:
+        labels = s.split(".")
+    else:
+        labels = _unicode_dots_re.split(s)
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
+    if labels[-1] == "":
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError("Empty label")
+    if trailing_dot:
+        result.append(b"")
+    s = b".".join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError("Domain too long")
+    return s
+
+
+def decode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+) -> str:
+    try:
+        if not isinstance(s, str):
+            s = str(s, "ascii")
+    except UnicodeDecodeError:
+        raise IDNAError("Invalid ASCII in A-label")
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    trailing_dot = False
+    result = []
+    if not strict:
+        labels = _unicode_dots_re.split(s)
+    else:
+        labels = s.split(".")
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError("Empty label")
+    if trailing_dot:
+        result.append("")
+    return ".".join(result)
diff --git a/.venv/lib/python3.10/site-packages/idna/idnadata.py b/.venv/lib/python3.10/site-packages/idna/idnadata.py
new file mode 100644
index 0000000..ded47ca
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/idnadata.py
@@ -0,0 +1,4309 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = "16.0.0"
+
+scripts = {
+    "Greek": (
+        0x37000000374,
+        0x37500000378,
+        0x37A0000037E,
+        0x37F00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038B,
+        0x38C0000038D,
+        0x38E000003A2,
+        0x3A3000003E2,
+        0x3F000000400,
+        0x1D2600001D2B,
+        0x1D5D00001D62,
+        0x1D6600001D6B,
+        0x1DBF00001DC0,
+        0x1F0000001F16,
+        0x1F1800001F1E,
+        0x1F2000001F46,
+        0x1F4800001F4E,
+        0x1F5000001F58,
+        0x1F5900001F5A,
+        0x1F5B00001F5C,
+        0x1F5D00001F5E,
+        0x1F5F00001F7E,
+        0x1F8000001FB5,
+        0x1FB600001FC5,
+        0x1FC600001FD4,
+        0x1FD600001FDC,
+        0x1FDD00001FF0,
+        0x1FF200001FF5,
+        0x1FF600001FFF,
+        0x212600002127,
+        0xAB650000AB66,
+        0x101400001018F,
+        0x101A0000101A1,
+        0x1D2000001D246,
+    ),
+    "Han": (
+        0x2E8000002E9A,
+        0x2E9B00002EF4,
+        0x2F0000002FD6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302A,
+        0x30380000303C,
+        0x340000004DC0,
+        0x4E000000A000,
+        0xF9000000FA6E,
+        0xFA700000FADA,
+        0x16FE200016FE4,
+        0x16FF000016FF2,
+        0x200000002A6E0,
+        0x2A7000002B73A,
+        0x2B7400002B81E,
+        0x2B8200002CEA2,
+        0x2CEB00002EBE1,
+        0x2EBF00002EE5E,
+        0x2F8000002FA1E,
+        0x300000003134B,
+        0x31350000323B0,
+    ),
+    "Hebrew": (
+        0x591000005C8,
+        0x5D0000005EB,
+        0x5EF000005F5,
+        0xFB1D0000FB37,
+        0xFB380000FB3D,
+        0xFB3E0000FB3F,
+        0xFB400000FB42,
+        0xFB430000FB45,
+        0xFB460000FB50,
+    ),
+    "Hiragana": (
+        0x304100003097,
+        0x309D000030A0,
+        0x1B0010001B120,
+        0x1B1320001B133,
+        0x1B1500001B153,
+        0x1F2000001F201,
+    ),
+    "Katakana": (
+        0x30A1000030FB,
+        0x30FD00003100,
+        0x31F000003200,
+        0x32D0000032FF,
+        0x330000003358,
+        0xFF660000FF70,
+        0xFF710000FF9E,
+        0x1AFF00001AFF4,
+        0x1AFF50001AFFC,
+        0x1AFFD0001AFFF,
+        0x1B0000001B001,
+        0x1B1200001B123,
+        0x1B1550001B156,
+        0x1B1640001B168,
+    ),
+}
+joining_types = {
+    0xAD: 84,
+    0x300: 84,
+    0x301: 84,
+    0x302: 84,
+    0x303: 84,
+    0x304: 84,
+    0x305: 84,
+    0x306: 84,
+    0x307: 84,
+    0x308: 84,
+    0x309: 84,
+    0x30A: 84,
+    0x30B: 84,
+    0x30C: 84,
+    0x30D: 84,
+    0x30E: 84,
+    0x30F: 84,
+    0x310: 84,
+    0x311: 84,
+    0x312: 84,
+    0x313: 84,
+    0x314: 84,
+    0x315: 84,
+    0x316: 84,
+    0x317: 84,
+    0x318: 84,
+    0x319: 84,
+    0x31A: 84,
+    0x31B: 84,
+    0x31C: 84,
+    0x31D: 84,
+    0x31E: 84,
+    0x31F: 84,
+    0x320: 84,
+    0x321: 84,
+    0x322: 84,
+    0x323: 84,
+    0x324: 84,
+    0x325: 84,
+    0x326: 84,
+    0x327: 84,
+    0x328: 84,
+    0x329: 84,
+    0x32A: 84,
+    0x32B: 84,
+    0x32C: 84,
+    0x32D: 84,
+    0x32E: 84,
+    0x32F: 84,
+    0x330: 84,
+    0x331: 84,
+    0x332: 84,
+    0x333: 84,
+    0x334: 84,
+    0x335: 84,
+    0x336: 84,
+    0x337: 84,
+    0x338: 84,
+    0x339: 84,
+    0x33A: 84,
+    0x33B: 84,
+    0x33C: 84,
+    0x33D: 84,
+    0x33E: 84,
+    0x33F: 84,
+    0x340: 84,
+    0x341: 84,
+    0x342: 84,
+    0x343: 84,
+    0x344: 84,
+    0x345: 84,
+    0x346: 84,
+    0x347: 84,
+    0x348: 84,
+    0x349: 84,
+    0x34A: 84,
+    0x34B: 84,
+    0x34C: 84,
+    0x34D: 84,
+    0x34E: 84,
+    0x34F: 84,
+    0x350: 84,
+    0x351: 84,
+    0x352: 84,
+    0x353: 84,
+    0x354: 84,
+    0x355: 84,
+    0x356: 84,
+    0x357: 84,
+    0x358: 84,
+    0x359: 84,
+    0x35A: 84,
+    0x35B: 84,
+    0x35C: 84,
+    0x35D: 84,
+    0x35E: 84,
+    0x35F: 84,
+    0x360: 84,
+    0x361: 84,
+    0x362: 84,
+    0x363: 84,
+    0x364: 84,
+    0x365: 84,
+    0x366: 84,
+    0x367: 84,
+    0x368: 84,
+    0x369: 84,
+    0x36A: 84,
+    0x36B: 84,
+    0x36C: 84,
+    0x36D: 84,
+    0x36E: 84,
+    0x36F: 84,
+    0x483: 84,
+    0x484: 84,
+    0x485: 84,
+    0x486: 84,
+    0x487: 84,
+    0x488: 84,
+    0x489: 84,
+    0x591: 84,
+    0x592: 84,
+    0x593: 84,
+    0x594: 84,
+    0x595: 84,
+    0x596: 84,
+    0x597: 84,
+    0x598: 84,
+    0x599: 84,
+    0x59A: 84,
+    0x59B: 84,
+    0x59C: 84,
+    0x59D: 84,
+    0x59E: 84,
+    0x59F: 84,
+    0x5A0: 84,
+    0x5A1: 84,
+    0x5A2: 84,
+    0x5A3: 84,
+    0x5A4: 84,
+    0x5A5: 84,
+    0x5A6: 84,
+    0x5A7: 84,
+    0x5A8: 84,
+    0x5A9: 84,
+    0x5AA: 84,
+    0x5AB: 84,
+    0x5AC: 84,
+    0x5AD: 84,
+    0x5AE: 84,
+    0x5AF: 84,
+    0x5B0: 84,
+    0x5B1: 84,
+    0x5B2: 84,
+    0x5B3: 84,
+    0x5B4: 84,
+    0x5B5: 84,
+    0x5B6: 84,
+    0x5B7: 84,
+    0x5B8: 84,
+    0x5B9: 84,
+    0x5BA: 84,
+    0x5BB: 84,
+    0x5BC: 84,
+    0x5BD: 84,
+    0x5BF: 84,
+    0x5C1: 84,
+    0x5C2: 84,
+    0x5C4: 84,
+    0x5C5: 84,
+    0x5C7: 84,
+    0x610: 84,
+    0x611: 84,
+    0x612: 84,
+    0x613: 84,
+    0x614: 84,
+    0x615: 84,
+    0x616: 84,
+    0x617: 84,
+    0x618: 84,
+    0x619: 84,
+    0x61A: 84,
+    0x61C: 84,
+    0x620: 68,
+    0x622: 82,
+    0x623: 82,
+    0x624: 82,
+    0x625: 82,
+    0x626: 68,
+    0x627: 82,
+    0x628: 68,
+    0x629: 82,
+    0x62A: 68,
+    0x62B: 68,
+    0x62C: 68,
+    0x62D: 68,
+    0x62E: 68,
+    0x62F: 82,
+    0x630: 82,
+    0x631: 82,
+    0x632: 82,
+    0x633: 68,
+    0x634: 68,
+    0x635: 68,
+    0x636: 68,
+    0x637: 68,
+    0x638: 68,
+    0x639: 68,
+    0x63A: 68,
+    0x63B: 68,
+    0x63C: 68,
+    0x63D: 68,
+    0x63E: 68,
+    0x63F: 68,
+    0x640: 67,
+    0x641: 68,
+    0x642: 68,
+    0x643: 68,
+    0x644: 68,
+    0x645: 68,
+    0x646: 68,
+    0x647: 68,
+    0x648: 82,
+    0x649: 68,
+    0x64A: 68,
+    0x64B: 84,
+    0x64C: 84,
+    0x64D: 84,
+    0x64E: 84,
+    0x64F: 84,
+    0x650: 84,
+    0x651: 84,
+    0x652: 84,
+    0x653: 84,
+    0x654: 84,
+    0x655: 84,
+    0x656: 84,
+    0x657: 84,
+    0x658: 84,
+    0x659: 84,
+    0x65A: 84,
+    0x65B: 84,
+    0x65C: 84,
+    0x65D: 84,
+    0x65E: 84,
+    0x65F: 84,
+    0x66E: 68,
+    0x66F: 68,
+    0x670: 84,
+    0x671: 82,
+    0x672: 82,
+    0x673: 82,
+    0x675: 82,
+    0x676: 82,
+    0x677: 82,
+    0x678: 68,
+    0x679: 68,
+    0x67A: 68,
+    0x67B: 68,
+    0x67C: 68,
+    0x67D: 68,
+    0x67E: 68,
+    0x67F: 68,
+    0x680: 68,
+    0x681: 68,
+    0x682: 68,
+    0x683: 68,
+    0x684: 68,
+    0x685: 68,
+    0x686: 68,
+    0x687: 68,
+    0x688: 82,
+    0x689: 82,
+    0x68A: 82,
+    0x68B: 82,
+    0x68C: 82,
+    0x68D: 82,
+    0x68E: 82,
+    0x68F: 82,
+    0x690: 82,
+    0x691: 82,
+    0x692: 82,
+    0x693: 82,
+    0x694: 82,
+    0x695: 82,
+    0x696: 82,
+    0x697: 82,
+    0x698: 82,
+    0x699: 82,
+    0x69A: 68,
+    0x69B: 68,
+    0x69C: 68,
+    0x69D: 68,
+    0x69E: 68,
+    0x69F: 68,
+    0x6A0: 68,
+    0x6A1: 68,
+    0x6A2: 68,
+    0x6A3: 68,
+    0x6A4: 68,
+    0x6A5: 68,
+    0x6A6: 68,
+    0x6A7: 68,
+    0x6A8: 68,
+    0x6A9: 68,
+    0x6AA: 68,
+    0x6AB: 68,
+    0x6AC: 68,
+    0x6AD: 68,
+    0x6AE: 68,
+    0x6AF: 68,
+    0x6B0: 68,
+    0x6B1: 68,
+    0x6B2: 68,
+    0x6B3: 68,
+    0x6B4: 68,
+    0x6B5: 68,
+    0x6B6: 68,
+    0x6B7: 68,
+    0x6B8: 68,
+    0x6B9: 68,
+    0x6BA: 68,
+    0x6BB: 68,
+    0x6BC: 68,
+    0x6BD: 68,
+    0x6BE: 68,
+    0x6BF: 68,
+    0x6C0: 82,
+    0x6C1: 68,
+    0x6C2: 68,
+    0x6C3: 82,
+    0x6C4: 82,
+    0x6C5: 82,
+    0x6C6: 82,
+    0x6C7: 82,
+    0x6C8: 82,
+    0x6C9: 82,
+    0x6CA: 82,
+    0x6CB: 82,
+    0x6CC: 68,
+    0x6CD: 82,
+    0x6CE: 68,
+    0x6CF: 82,
+    0x6D0: 68,
+    0x6D1: 68,
+    0x6D2: 82,
+    0x6D3: 82,
+    0x6D5: 82,
+    0x6D6: 84,
+    0x6D7: 84,
+    0x6D8: 84,
+    0x6D9: 84,
+    0x6DA: 84,
+    0x6DB: 84,
+    0x6DC: 84,
+    0x6DF: 84,
+    0x6E0: 84,
+    0x6E1: 84,
+    0x6E2: 84,
+    0x6E3: 84,
+    0x6E4: 84,
+    0x6E7: 84,
+    0x6E8: 84,
+    0x6EA: 84,
+    0x6EB: 84,
+    0x6EC: 84,
+    0x6ED: 84,
+    0x6EE: 82,
+    0x6EF: 82,
+    0x6FA: 68,
+    0x6FB: 68,
+    0x6FC: 68,
+    0x6FF: 68,
+    0x70F: 84,
+    0x710: 82,
+    0x711: 84,
+    0x712: 68,
+    0x713: 68,
+    0x714: 68,
+    0x715: 82,
+    0x716: 82,
+    0x717: 82,
+    0x718: 82,
+    0x719: 82,
+    0x71A: 68,
+    0x71B: 68,
+    0x71C: 68,
+    0x71D: 68,
+    0x71E: 82,
+    0x71F: 68,
+    0x720: 68,
+    0x721: 68,
+    0x722: 68,
+    0x723: 68,
+    0x724: 68,
+    0x725: 68,
+    0x726: 68,
+    0x727: 68,
+    0x728: 82,
+    0x729: 68,
+    0x72A: 82,
+    0x72B: 68,
+    0x72C: 82,
+    0x72D: 68,
+    0x72E: 68,
+    0x72F: 82,
+    0x730: 84,
+    0x731: 84,
+    0x732: 84,
+    0x733: 84,
+    0x734: 84,
+    0x735: 84,
+    0x736: 84,
+    0x737: 84,
+    0x738: 84,
+    0x739: 84,
+    0x73A: 84,
+    0x73B: 84,
+    0x73C: 84,
+    0x73D: 84,
+    0x73E: 84,
+    0x73F: 84,
+    0x740: 84,
+    0x741: 84,
+    0x742: 84,
+    0x743: 84,
+    0x744: 84,
+    0x745: 84,
+    0x746: 84,
+    0x747: 84,
+    0x748: 84,
+    0x749: 84,
+    0x74A: 84,
+    0x74D: 82,
+    0x74E: 68,
+    0x74F: 68,
+    0x750: 68,
+    0x751: 68,
+    0x752: 68,
+    0x753: 68,
+    0x754: 68,
+    0x755: 68,
+    0x756: 68,
+    0x757: 68,
+    0x758: 68,
+    0x759: 82,
+    0x75A: 82,
+    0x75B: 82,
+    0x75C: 68,
+    0x75D: 68,
+    0x75E: 68,
+    0x75F: 68,
+    0x760: 68,
+    0x761: 68,
+    0x762: 68,
+    0x763: 68,
+    0x764: 68,
+    0x765: 68,
+    0x766: 68,
+    0x767: 68,
+    0x768: 68,
+    0x769: 68,
+    0x76A: 68,
+    0x76B: 82,
+    0x76C: 82,
+    0x76D: 68,
+    0x76E: 68,
+    0x76F: 68,
+    0x770: 68,
+    0x771: 82,
+    0x772: 68,
+    0x773: 82,
+    0x774: 82,
+    0x775: 68,
+    0x776: 68,
+    0x777: 68,
+    0x778: 82,
+    0x779: 82,
+    0x77A: 68,
+    0x77B: 68,
+    0x77C: 68,
+    0x77D: 68,
+    0x77E: 68,
+    0x77F: 68,
+    0x7A6: 84,
+    0x7A7: 84,
+    0x7A8: 84,
+    0x7A9: 84,
+    0x7AA: 84,
+    0x7AB: 84,
+    0x7AC: 84,
+    0x7AD: 84,
+    0x7AE: 84,
+    0x7AF: 84,
+    0x7B0: 84,
+    0x7CA: 68,
+    0x7CB: 68,
+    0x7CC: 68,
+    0x7CD: 68,
+    0x7CE: 68,
+    0x7CF: 68,
+    0x7D0: 68,
+    0x7D1: 68,
+    0x7D2: 68,
+    0x7D3: 68,
+    0x7D4: 68,
+    0x7D5: 68,
+    0x7D6: 68,
+    0x7D7: 68,
+    0x7D8: 68,
+    0x7D9: 68,
+    0x7DA: 68,
+    0x7DB: 68,
+    0x7DC: 68,
+    0x7DD: 68,
+    0x7DE: 68,
+    0x7DF: 68,
+    0x7E0: 68,
+    0x7E1: 68,
+    0x7E2: 68,
+    0x7E3: 68,
+    0x7E4: 68,
+    0x7E5: 68,
+    0x7E6: 68,
+    0x7E7: 68,
+    0x7E8: 68,
+    0x7E9: 68,
+    0x7EA: 68,
+    0x7EB: 84,
+    0x7EC: 84,
+    0x7ED: 84,
+    0x7EE: 84,
+    0x7EF: 84,
+    0x7F0: 84,
+    0x7F1: 84,
+    0x7F2: 84,
+    0x7F3: 84,
+    0x7FA: 67,
+    0x7FD: 84,
+    0x816: 84,
+    0x817: 84,
+    0x818: 84,
+    0x819: 84,
+    0x81B: 84,
+    0x81C: 84,
+    0x81D: 84,
+    0x81E: 84,
+    0x81F: 84,
+    0x820: 84,
+    0x821: 84,
+    0x822: 84,
+    0x823: 84,
+    0x825: 84,
+    0x826: 84,
+    0x827: 84,
+    0x829: 84,
+    0x82A: 84,
+    0x82B: 84,
+    0x82C: 84,
+    0x82D: 84,
+    0x840: 82,
+    0x841: 68,
+    0x842: 68,
+    0x843: 68,
+    0x844: 68,
+    0x845: 68,
+    0x846: 82,
+    0x847: 82,
+    0x848: 68,
+    0x849: 82,
+    0x84A: 68,
+    0x84B: 68,
+    0x84C: 68,
+    0x84D: 68,
+    0x84E: 68,
+    0x84F: 68,
+    0x850: 68,
+    0x851: 68,
+    0x852: 68,
+    0x853: 68,
+    0x854: 82,
+    0x855: 68,
+    0x856: 82,
+    0x857: 82,
+    0x858: 82,
+    0x859: 84,
+    0x85A: 84,
+    0x85B: 84,
+    0x860: 68,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86A: 82,
+    0x870: 82,
+    0x871: 82,
+    0x872: 82,
+    0x873: 82,
+    0x874: 82,
+    0x875: 82,
+    0x876: 82,
+    0x877: 82,
+    0x878: 82,
+    0x879: 82,
+    0x87A: 82,
+    0x87B: 82,
+    0x87C: 82,
+    0x87D: 82,
+    0x87E: 82,
+    0x87F: 82,
+    0x880: 82,
+    0x881: 82,
+    0x882: 82,
+    0x883: 67,
+    0x884: 67,
+    0x885: 67,
+    0x886: 68,
+    0x889: 68,
+    0x88A: 68,
+    0x88B: 68,
+    0x88C: 68,
+    0x88D: 68,
+    0x88E: 82,
+    0x897: 84,
+    0x898: 84,
+    0x899: 84,
+    0x89A: 84,
+    0x89B: 84,
+    0x89C: 84,
+    0x89D: 84,
+    0x89E: 84,
+    0x89F: 84,
+    0x8A0: 68,
+    0x8A1: 68,
+    0x8A2: 68,
+    0x8A3: 68,
+    0x8A4: 68,
+    0x8A5: 68,
+    0x8A6: 68,
+    0x8A7: 68,
+    0x8A8: 68,
+    0x8A9: 68,
+    0x8AA: 82,
+    0x8AB: 82,
+    0x8AC: 82,
+    0x8AE: 82,
+    0x8AF: 68,
+    0x8B0: 68,
+    0x8B1: 82,
+    0x8B2: 82,
+    0x8B3: 68,
+    0x8B4: 68,
+    0x8B5: 68,
+    0x8B6: 68,
+    0x8B7: 68,
+    0x8B8: 68,
+    0x8B9: 82,
+    0x8BA: 68,
+    0x8BB: 68,
+    0x8BC: 68,
+    0x8BD: 68,
+    0x8BE: 68,
+    0x8BF: 68,
+    0x8C0: 68,
+    0x8C1: 68,
+    0x8C2: 68,
+    0x8C3: 68,
+    0x8C4: 68,
+    0x8C5: 68,
+    0x8C6: 68,
+    0x8C7: 68,
+    0x8C8: 68,
+    0x8CA: 84,
+    0x8CB: 84,
+    0x8CC: 84,
+    0x8CD: 84,
+    0x8CE: 84,
+    0x8CF: 84,
+    0x8D0: 84,
+    0x8D1: 84,
+    0x8D2: 84,
+    0x8D3: 84,
+    0x8D4: 84,
+    0x8D5: 84,
+    0x8D6: 84,
+    0x8D7: 84,
+    0x8D8: 84,
+    0x8D9: 84,
+    0x8DA: 84,
+    0x8DB: 84,
+    0x8DC: 84,
+    0x8DD: 84,
+    0x8DE: 84,
+    0x8DF: 84,
+    0x8E0: 84,
+    0x8E1: 84,
+    0x8E3: 84,
+    0x8E4: 84,
+    0x8E5: 84,
+    0x8E6: 84,
+    0x8E7: 84,
+    0x8E8: 84,
+    0x8E9: 84,
+    0x8EA: 84,
+    0x8EB: 84,
+    0x8EC: 84,
+    0x8ED: 84,
+    0x8EE: 84,
+    0x8EF: 84,
+    0x8F0: 84,
+    0x8F1: 84,
+    0x8F2: 84,
+    0x8F3: 84,
+    0x8F4: 84,
+    0x8F5: 84,
+    0x8F6: 84,
+    0x8F7: 84,
+    0x8F8: 84,
+    0x8F9: 84,
+    0x8FA: 84,
+    0x8FB: 84,
+    0x8FC: 84,
+    0x8FD: 84,
+    0x8FE: 84,
+    0x8FF: 84,
+    0x900: 84,
+    0x901: 84,
+    0x902: 84,
+    0x93A: 84,
+    0x93C: 84,
+    0x941: 84,
+    0x942: 84,
+    0x943: 84,
+    0x944: 84,
+    0x945: 84,
+    0x946: 84,
+    0x947: 84,
+    0x948: 84,
+    0x94D: 84,
+    0x951: 84,
+    0x952: 84,
+    0x953: 84,
+    0x954: 84,
+    0x955: 84,
+    0x956: 84,
+    0x957: 84,
+    0x962: 84,
+    0x963: 84,
+    0x981: 84,
+    0x9BC: 84,
+    0x9C1: 84,
+    0x9C2: 84,
+    0x9C3: 84,
+    0x9C4: 84,
+    0x9CD: 84,
+    0x9E2: 84,
+    0x9E3: 84,
+    0x9FE: 84,
+    0xA01: 84,
+    0xA02: 84,
+    0xA3C: 84,
+    0xA41: 84,
+    0xA42: 84,
+    0xA47: 84,
+    0xA48: 84,
+    0xA4B: 84,
+    0xA4C: 84,
+    0xA4D: 84,
+    0xA51: 84,
+    0xA70: 84,
+    0xA71: 84,
+    0xA75: 84,
+    0xA81: 84,
+    0xA82: 84,
+    0xABC: 84,
+    0xAC1: 84,
+    0xAC2: 84,
+    0xAC3: 84,
+    0xAC4: 84,
+    0xAC5: 84,
+    0xAC7: 84,
+    0xAC8: 84,
+    0xACD: 84,
+    0xAE2: 84,
+    0xAE3: 84,
+    0xAFA: 84,
+    0xAFB: 84,
+    0xAFC: 84,
+    0xAFD: 84,
+    0xAFE: 84,
+    0xAFF: 84,
+    0xB01: 84,
+    0xB3C: 84,
+    0xB3F: 84,
+    0xB41: 84,
+    0xB42: 84,
+    0xB43: 84,
+    0xB44: 84,
+    0xB4D: 84,
+    0xB55: 84,
+    0xB56: 84,
+    0xB62: 84,
+    0xB63: 84,
+    0xB82: 84,
+    0xBC0: 84,
+    0xBCD: 84,
+    0xC00: 84,
+    0xC04: 84,
+    0xC3C: 84,
+    0xC3E: 84,
+    0xC3F: 84,
+    0xC40: 84,
+    0xC46: 84,
+    0xC47: 84,
+    0xC48: 84,
+    0xC4A: 84,
+    0xC4B: 84,
+    0xC4C: 84,
+    0xC4D: 84,
+    0xC55: 84,
+    0xC56: 84,
+    0xC62: 84,
+    0xC63: 84,
+    0xC81: 84,
+    0xCBC: 84,
+    0xCBF: 84,
+    0xCC6: 84,
+    0xCCC: 84,
+    0xCCD: 84,
+    0xCE2: 84,
+    0xCE3: 84,
+    0xD00: 84,
+    0xD01: 84,
+    0xD3B: 84,
+    0xD3C: 84,
+    0xD41: 84,
+    0xD42: 84,
+    0xD43: 84,
+    0xD44: 84,
+    0xD4D: 84,
+    0xD62: 84,
+    0xD63: 84,
+    0xD81: 84,
+    0xDCA: 84,
+    0xDD2: 84,
+    0xDD3: 84,
+    0xDD4: 84,
+    0xDD6: 84,
+    0xE31: 84,
+    0xE34: 84,
+    0xE35: 84,
+    0xE36: 84,
+    0xE37: 84,
+    0xE38: 84,
+    0xE39: 84,
+    0xE3A: 84,
+    0xE47: 84,
+    0xE48: 84,
+    0xE49: 84,
+    0xE4A: 84,
+    0xE4B: 84,
+    0xE4C: 84,
+    0xE4D: 84,
+    0xE4E: 84,
+    0xEB1: 84,
+    0xEB4: 84,
+    0xEB5: 84,
+    0xEB6: 84,
+    0xEB7: 84,
+    0xEB8: 84,
+    0xEB9: 84,
+    0xEBA: 84,
+    0xEBB: 84,
+    0xEBC: 84,
+    0xEC8: 84,
+    0xEC9: 84,
+    0xECA: 84,
+    0xECB: 84,
+    0xECC: 84,
+    0xECD: 84,
+    0xECE: 84,
+    0xF18: 84,
+    0xF19: 84,
+    0xF35: 84,
+    0xF37: 84,
+    0xF39: 84,
+    0xF71: 84,
+    0xF72: 84,
+    0xF73: 84,
+    0xF74: 84,
+    0xF75: 84,
+    0xF76: 84,
+    0xF77: 84,
+    0xF78: 84,
+    0xF79: 84,
+    0xF7A: 84,
+    0xF7B: 84,
+    0xF7C: 84,
+    0xF7D: 84,
+    0xF7E: 84,
+    0xF80: 84,
+    0xF81: 84,
+    0xF82: 84,
+    0xF83: 84,
+    0xF84: 84,
+    0xF86: 84,
+    0xF87: 84,
+    0xF8D: 84,
+    0xF8E: 84,
+    0xF8F: 84,
+    0xF90: 84,
+    0xF91: 84,
+    0xF92: 84,
+    0xF93: 84,
+    0xF94: 84,
+    0xF95: 84,
+    0xF96: 84,
+    0xF97: 84,
+    0xF99: 84,
+    0xF9A: 84,
+    0xF9B: 84,
+    0xF9C: 84,
+    0xF9D: 84,
+    0xF9E: 84,
+    0xF9F: 84,
+    0xFA0: 84,
+    0xFA1: 84,
+    0xFA2: 84,
+    0xFA3: 84,
+    0xFA4: 84,
+    0xFA5: 84,
+    0xFA6: 84,
+    0xFA7: 84,
+    0xFA8: 84,
+    0xFA9: 84,
+    0xFAA: 84,
+    0xFAB: 84,
+    0xFAC: 84,
+    0xFAD: 84,
+    0xFAE: 84,
+    0xFAF: 84,
+    0xFB0: 84,
+    0xFB1: 84,
+    0xFB2: 84,
+    0xFB3: 84,
+    0xFB4: 84,
+    0xFB5: 84,
+    0xFB6: 84,
+    0xFB7: 84,
+    0xFB8: 84,
+    0xFB9: 84,
+    0xFBA: 84,
+    0xFBB: 84,
+    0xFBC: 84,
+    0xFC6: 84,
+    0x102D: 84,
+    0x102E: 84,
+    0x102F: 84,
+    0x1030: 84,
+    0x1032: 84,
+    0x1033: 84,
+    0x1034: 84,
+    0x1035: 84,
+    0x1036: 84,
+    0x1037: 84,
+    0x1039: 84,
+    0x103A: 84,
+    0x103D: 84,
+    0x103E: 84,
+    0x1058: 84,
+    0x1059: 84,
+    0x105E: 84,
+    0x105F: 84,
+    0x1060: 84,
+    0x1071: 84,
+    0x1072: 84,
+    0x1073: 84,
+    0x1074: 84,
+    0x1082: 84,
+    0x1085: 84,
+    0x1086: 84,
+    0x108D: 84,
+    0x109D: 84,
+    0x135D: 84,
+    0x135E: 84,
+    0x135F: 84,
+    0x1712: 84,
+    0x1713: 84,
+    0x1714: 84,
+    0x1732: 84,
+    0x1733: 84,
+    0x1752: 84,
+    0x1753: 84,
+    0x1772: 84,
+    0x1773: 84,
+    0x17B4: 84,
+    0x17B5: 84,
+    0x17B7: 84,
+    0x17B8: 84,
+    0x17B9: 84,
+    0x17BA: 84,
+    0x17BB: 84,
+    0x17BC: 84,
+    0x17BD: 84,
+    0x17C6: 84,
+    0x17C9: 84,
+    0x17CA: 84,
+    0x17CB: 84,
+    0x17CC: 84,
+    0x17CD: 84,
+    0x17CE: 84,
+    0x17CF: 84,
+    0x17D0: 84,
+    0x17D1: 84,
+    0x17D2: 84,
+    0x17D3: 84,
+    0x17DD: 84,
+    0x1807: 68,
+    0x180A: 67,
+    0x180B: 84,
+    0x180C: 84,
+    0x180D: 84,
+    0x180F: 84,
+    0x1820: 68,
+    0x1821: 68,
+    0x1822: 68,
+    0x1823: 68,
+    0x1824: 68,
+    0x1825: 68,
+    0x1826: 68,
+    0x1827: 68,
+    0x1828: 68,
+    0x1829: 68,
+    0x182A: 68,
+    0x182B: 68,
+    0x182C: 68,
+    0x182D: 68,
+    0x182E: 68,
+    0x182F: 68,
+    0x1830: 68,
+    0x1831: 68,
+    0x1832: 68,
+    0x1833: 68,
+    0x1834: 68,
+    0x1835: 68,
+    0x1836: 68,
+    0x1837: 68,
+    0x1838: 68,
+    0x1839: 68,
+    0x183A: 68,
+    0x183B: 68,
+    0x183C: 68,
+    0x183D: 68,
+    0x183E: 68,
+    0x183F: 68,
+    0x1840: 68,
+    0x1841: 68,
+    0x1842: 68,
+    0x1843: 68,
+    0x1844: 68,
+    0x1845: 68,
+    0x1846: 68,
+    0x1847: 68,
+    0x1848: 68,
+    0x1849: 68,
+    0x184A: 68,
+    0x184B: 68,
+    0x184C: 68,
+    0x184D: 68,
+    0x184E: 68,
+    0x184F: 68,
+    0x1850: 68,
+    0x1851: 68,
+    0x1852: 68,
+    0x1853: 68,
+    0x1854: 68,
+    0x1855: 68,
+    0x1856: 68,
+    0x1857: 68,
+    0x1858: 68,
+    0x1859: 68,
+    0x185A: 68,
+    0x185B: 68,
+    0x185C: 68,
+    0x185D: 68,
+    0x185E: 68,
+    0x185F: 68,
+    0x1860: 68,
+    0x1861: 68,
+    0x1862: 68,
+    0x1863: 68,
+    0x1864: 68,
+    0x1865: 68,
+    0x1866: 68,
+    0x1867: 68,
+    0x1868: 68,
+    0x1869: 68,
+    0x186A: 68,
+    0x186B: 68,
+    0x186C: 68,
+    0x186D: 68,
+    0x186E: 68,
+    0x186F: 68,
+    0x1870: 68,
+    0x1871: 68,
+    0x1872: 68,
+    0x1873: 68,
+    0x1874: 68,
+    0x1875: 68,
+    0x1876: 68,
+    0x1877: 68,
+    0x1878: 68,
+    0x1885: 84,
+    0x1886: 84,
+    0x1887: 68,
+    0x1888: 68,
+    0x1889: 68,
+    0x188A: 68,
+    0x188B: 68,
+    0x188C: 68,
+    0x188D: 68,
+    0x188E: 68,
+    0x188F: 68,
+    0x1890: 68,
+    0x1891: 68,
+    0x1892: 68,
+    0x1893: 68,
+    0x1894: 68,
+    0x1895: 68,
+    0x1896: 68,
+    0x1897: 68,
+    0x1898: 68,
+    0x1899: 68,
+    0x189A: 68,
+    0x189B: 68,
+    0x189C: 68,
+    0x189D: 68,
+    0x189E: 68,
+    0x189F: 68,
+    0x18A0: 68,
+    0x18A1: 68,
+    0x18A2: 68,
+    0x18A3: 68,
+    0x18A4: 68,
+    0x18A5: 68,
+    0x18A6: 68,
+    0x18A7: 68,
+    0x18A8: 68,
+    0x18A9: 84,
+    0x18AA: 68,
+    0x1920: 84,
+    0x1921: 84,
+    0x1922: 84,
+    0x1927: 84,
+    0x1928: 84,
+    0x1932: 84,
+    0x1939: 84,
+    0x193A: 84,
+    0x193B: 84,
+    0x1A17: 84,
+    0x1A18: 84,
+    0x1A1B: 84,
+    0x1A56: 84,
+    0x1A58: 84,
+    0x1A59: 84,
+    0x1A5A: 84,
+    0x1A5B: 84,
+    0x1A5C: 84,
+    0x1A5D: 84,
+    0x1A5E: 84,
+    0x1A60: 84,
+    0x1A62: 84,
+    0x1A65: 84,
+    0x1A66: 84,
+    0x1A67: 84,
+    0x1A68: 84,
+    0x1A69: 84,
+    0x1A6A: 84,
+    0x1A6B: 84,
+    0x1A6C: 84,
+    0x1A73: 84,
+    0x1A74: 84,
+    0x1A75: 84,
+    0x1A76: 84,
+    0x1A77: 84,
+    0x1A78: 84,
+    0x1A79: 84,
+    0x1A7A: 84,
+    0x1A7B: 84,
+    0x1A7C: 84,
+    0x1A7F: 84,
+    0x1AB0: 84,
+    0x1AB1: 84,
+    0x1AB2: 84,
+    0x1AB3: 84,
+    0x1AB4: 84,
+    0x1AB5: 84,
+    0x1AB6: 84,
+    0x1AB7: 84,
+    0x1AB8: 84,
+    0x1AB9: 84,
+    0x1ABA: 84,
+    0x1ABB: 84,
+    0x1ABC: 84,
+    0x1ABD: 84,
+    0x1ABE: 84,
+    0x1ABF: 84,
+    0x1AC0: 84,
+    0x1AC1: 84,
+    0x1AC2: 84,
+    0x1AC3: 84,
+    0x1AC4: 84,
+    0x1AC5: 84,
+    0x1AC6: 84,
+    0x1AC7: 84,
+    0x1AC8: 84,
+    0x1AC9: 84,
+    0x1ACA: 84,
+    0x1ACB: 84,
+    0x1ACC: 84,
+    0x1ACD: 84,
+    0x1ACE: 84,
+    0x1B00: 84,
+    0x1B01: 84,
+    0x1B02: 84,
+    0x1B03: 84,
+    0x1B34: 84,
+    0x1B36: 84,
+    0x1B37: 84,
+    0x1B38: 84,
+    0x1B39: 84,
+    0x1B3A: 84,
+    0x1B3C: 84,
+    0x1B42: 84,
+    0x1B6B: 84,
+    0x1B6C: 84,
+    0x1B6D: 84,
+    0x1B6E: 84,
+    0x1B6F: 84,
+    0x1B70: 84,
+    0x1B71: 84,
+    0x1B72: 84,
+    0x1B73: 84,
+    0x1B80: 84,
+    0x1B81: 84,
+    0x1BA2: 84,
+    0x1BA3: 84,
+    0x1BA4: 84,
+    0x1BA5: 84,
+    0x1BA8: 84,
+    0x1BA9: 84,
+    0x1BAB: 84,
+    0x1BAC: 84,
+    0x1BAD: 84,
+    0x1BE6: 84,
+    0x1BE8: 84,
+    0x1BE9: 84,
+    0x1BED: 84,
+    0x1BEF: 84,
+    0x1BF0: 84,
+    0x1BF1: 84,
+    0x1C2C: 84,
+    0x1C2D: 84,
+    0x1C2E: 84,
+    0x1C2F: 84,
+    0x1C30: 84,
+    0x1C31: 84,
+    0x1C32: 84,
+    0x1C33: 84,
+    0x1C36: 84,
+    0x1C37: 84,
+    0x1CD0: 84,
+    0x1CD1: 84,
+    0x1CD2: 84,
+    0x1CD4: 84,
+    0x1CD5: 84,
+    0x1CD6: 84,
+    0x1CD7: 84,
+    0x1CD8: 84,
+    0x1CD9: 84,
+    0x1CDA: 84,
+    0x1CDB: 84,
+    0x1CDC: 84,
+    0x1CDD: 84,
+    0x1CDE: 84,
+    0x1CDF: 84,
+    0x1CE0: 84,
+    0x1CE2: 84,
+    0x1CE3: 84,
+    0x1CE4: 84,
+    0x1CE5: 84,
+    0x1CE6: 84,
+    0x1CE7: 84,
+    0x1CE8: 84,
+    0x1CED: 84,
+    0x1CF4: 84,
+    0x1CF8: 84,
+    0x1CF9: 84,
+    0x1DC0: 84,
+    0x1DC1: 84,
+    0x1DC2: 84,
+    0x1DC3: 84,
+    0x1DC4: 84,
+    0x1DC5: 84,
+    0x1DC6: 84,
+    0x1DC7: 84,
+    0x1DC8: 84,
+    0x1DC9: 84,
+    0x1DCA: 84,
+    0x1DCB: 84,
+    0x1DCC: 84,
+    0x1DCD: 84,
+    0x1DCE: 84,
+    0x1DCF: 84,
+    0x1DD0: 84,
+    0x1DD1: 84,
+    0x1DD2: 84,
+    0x1DD3: 84,
+    0x1DD4: 84,
+    0x1DD5: 84,
+    0x1DD6: 84,
+    0x1DD7: 84,
+    0x1DD8: 84,
+    0x1DD9: 84,
+    0x1DDA: 84,
+    0x1DDB: 84,
+    0x1DDC: 84,
+    0x1DDD: 84,
+    0x1DDE: 84,
+    0x1DDF: 84,
+    0x1DE0: 84,
+    0x1DE1: 84,
+    0x1DE2: 84,
+    0x1DE3: 84,
+    0x1DE4: 84,
+    0x1DE5: 84,
+    0x1DE6: 84,
+    0x1DE7: 84,
+    0x1DE8: 84,
+    0x1DE9: 84,
+    0x1DEA: 84,
+    0x1DEB: 84,
+    0x1DEC: 84,
+    0x1DED: 84,
+    0x1DEE: 84,
+    0x1DEF: 84,
+    0x1DF0: 84,
+    0x1DF1: 84,
+    0x1DF2: 84,
+    0x1DF3: 84,
+    0x1DF4: 84,
+    0x1DF5: 84,
+    0x1DF6: 84,
+    0x1DF7: 84,
+    0x1DF8: 84,
+    0x1DF9: 84,
+    0x1DFA: 84,
+    0x1DFB: 84,
+    0x1DFC: 84,
+    0x1DFD: 84,
+    0x1DFE: 84,
+    0x1DFF: 84,
+    0x200B: 84,
+    0x200D: 67,
+    0x200E: 84,
+    0x200F: 84,
+    0x202A: 84,
+    0x202B: 84,
+    0x202C: 84,
+    0x202D: 84,
+    0x202E: 84,
+    0x2060: 84,
+    0x2061: 84,
+    0x2062: 84,
+    0x2063: 84,
+    0x2064: 84,
+    0x206A: 84,
+    0x206B: 84,
+    0x206C: 84,
+    0x206D: 84,
+    0x206E: 84,
+    0x206F: 84,
+    0x20D0: 84,
+    0x20D1: 84,
+    0x20D2: 84,
+    0x20D3: 84,
+    0x20D4: 84,
+    0x20D5: 84,
+    0x20D6: 84,
+    0x20D7: 84,
+    0x20D8: 84,
+    0x20D9: 84,
+    0x20DA: 84,
+    0x20DB: 84,
+    0x20DC: 84,
+    0x20DD: 84,
+    0x20DE: 84,
+    0x20DF: 84,
+    0x20E0: 84,
+    0x20E1: 84,
+    0x20E2: 84,
+    0x20E3: 84,
+    0x20E4: 84,
+    0x20E5: 84,
+    0x20E6: 84,
+    0x20E7: 84,
+    0x20E8: 84,
+    0x20E9: 84,
+    0x20EA: 84,
+    0x20EB: 84,
+    0x20EC: 84,
+    0x20ED: 84,
+    0x20EE: 84,
+    0x20EF: 84,
+    0x20F0: 84,
+    0x2CEF: 84,
+    0x2CF0: 84,
+    0x2CF1: 84,
+    0x2D7F: 84,
+    0x2DE0: 84,
+    0x2DE1: 84,
+    0x2DE2: 84,
+    0x2DE3: 84,
+    0x2DE4: 84,
+    0x2DE5: 84,
+    0x2DE6: 84,
+    0x2DE7: 84,
+    0x2DE8: 84,
+    0x2DE9: 84,
+    0x2DEA: 84,
+    0x2DEB: 84,
+    0x2DEC: 84,
+    0x2DED: 84,
+    0x2DEE: 84,
+    0x2DEF: 84,
+    0x2DF0: 84,
+    0x2DF1: 84,
+    0x2DF2: 84,
+    0x2DF3: 84,
+    0x2DF4: 84,
+    0x2DF5: 84,
+    0x2DF6: 84,
+    0x2DF7: 84,
+    0x2DF8: 84,
+    0x2DF9: 84,
+    0x2DFA: 84,
+    0x2DFB: 84,
+    0x2DFC: 84,
+    0x2DFD: 84,
+    0x2DFE: 84,
+    0x2DFF: 84,
+    0x302A: 84,
+    0x302B: 84,
+    0x302C: 84,
+    0x302D: 84,
+    0x3099: 84,
+    0x309A: 84,
+    0xA66F: 84,
+    0xA670: 84,
+    0xA671: 84,
+    0xA672: 84,
+    0xA674: 84,
+    0xA675: 84,
+    0xA676: 84,
+    0xA677: 84,
+    0xA678: 84,
+    0xA679: 84,
+    0xA67A: 84,
+    0xA67B: 84,
+    0xA67C: 84,
+    0xA67D: 84,
+    0xA69E: 84,
+    0xA69F: 84,
+    0xA6F0: 84,
+    0xA6F1: 84,
+    0xA802: 84,
+    0xA806: 84,
+    0xA80B: 84,
+    0xA825: 84,
+    0xA826: 84,
+    0xA82C: 84,
+    0xA840: 68,
+    0xA841: 68,
+    0xA842: 68,
+    0xA843: 68,
+    0xA844: 68,
+    0xA845: 68,
+    0xA846: 68,
+    0xA847: 68,
+    0xA848: 68,
+    0xA849: 68,
+    0xA84A: 68,
+    0xA84B: 68,
+    0xA84C: 68,
+    0xA84D: 68,
+    0xA84E: 68,
+    0xA84F: 68,
+    0xA850: 68,
+    0xA851: 68,
+    0xA852: 68,
+    0xA853: 68,
+    0xA854: 68,
+    0xA855: 68,
+    0xA856: 68,
+    0xA857: 68,
+    0xA858: 68,
+    0xA859: 68,
+    0xA85A: 68,
+    0xA85B: 68,
+    0xA85C: 68,
+    0xA85D: 68,
+    0xA85E: 68,
+    0xA85F: 68,
+    0xA860: 68,
+    0xA861: 68,
+    0xA862: 68,
+    0xA863: 68,
+    0xA864: 68,
+    0xA865: 68,
+    0xA866: 68,
+    0xA867: 68,
+    0xA868: 68,
+    0xA869: 68,
+    0xA86A: 68,
+    0xA86B: 68,
+    0xA86C: 68,
+    0xA86D: 68,
+    0xA86E: 68,
+    0xA86F: 68,
+    0xA870: 68,
+    0xA871: 68,
+    0xA872: 76,
+    0xA8C4: 84,
+    0xA8C5: 84,
+    0xA8E0: 84,
+    0xA8E1: 84,
+    0xA8E2: 84,
+    0xA8E3: 84,
+    0xA8E4: 84,
+    0xA8E5: 84,
+    0xA8E6: 84,
+    0xA8E7: 84,
+    0xA8E8: 84,
+    0xA8E9: 84,
+    0xA8EA: 84,
+    0xA8EB: 84,
+    0xA8EC: 84,
+    0xA8ED: 84,
+    0xA8EE: 84,
+    0xA8EF: 84,
+    0xA8F0: 84,
+    0xA8F1: 84,
+    0xA8FF: 84,
+    0xA926: 84,
+    0xA927: 84,
+    0xA928: 84,
+    0xA929: 84,
+    0xA92A: 84,
+    0xA92B: 84,
+    0xA92C: 84,
+    0xA92D: 84,
+    0xA947: 84,
+    0xA948: 84,
+    0xA949: 84,
+    0xA94A: 84,
+    0xA94B: 84,
+    0xA94C: 84,
+    0xA94D: 84,
+    0xA94E: 84,
+    0xA94F: 84,
+    0xA950: 84,
+    0xA951: 84,
+    0xA980: 84,
+    0xA981: 84,
+    0xA982: 84,
+    0xA9B3: 84,
+    0xA9B6: 84,
+    0xA9B7: 84,
+    0xA9B8: 84,
+    0xA9B9: 84,
+    0xA9BC: 84,
+    0xA9BD: 84,
+    0xA9E5: 84,
+    0xAA29: 84,
+    0xAA2A: 84,
+    0xAA2B: 84,
+    0xAA2C: 84,
+    0xAA2D: 84,
+    0xAA2E: 84,
+    0xAA31: 84,
+    0xAA32: 84,
+    0xAA35: 84,
+    0xAA36: 84,
+    0xAA43: 84,
+    0xAA4C: 84,
+    0xAA7C: 84,
+    0xAAB0: 84,
+    0xAAB2: 84,
+    0xAAB3: 84,
+    0xAAB4: 84,
+    0xAAB7: 84,
+    0xAAB8: 84,
+    0xAABE: 84,
+    0xAABF: 84,
+    0xAAC1: 84,
+    0xAAEC: 84,
+    0xAAED: 84,
+    0xAAF6: 84,
+    0xABE5: 84,
+    0xABE8: 84,
+    0xABED: 84,
+    0xFB1E: 84,
+    0xFE00: 84,
+    0xFE01: 84,
+    0xFE02: 84,
+    0xFE03: 84,
+    0xFE04: 84,
+    0xFE05: 84,
+    0xFE06: 84,
+    0xFE07: 84,
+    0xFE08: 84,
+    0xFE09: 84,
+    0xFE0A: 84,
+    0xFE0B: 84,
+    0xFE0C: 84,
+    0xFE0D: 84,
+    0xFE0E: 84,
+    0xFE0F: 84,
+    0xFE20: 84,
+    0xFE21: 84,
+    0xFE22: 84,
+    0xFE23: 84,
+    0xFE24: 84,
+    0xFE25: 84,
+    0xFE26: 84,
+    0xFE27: 84,
+    0xFE28: 84,
+    0xFE29: 84,
+    0xFE2A: 84,
+    0xFE2B: 84,
+    0xFE2C: 84,
+    0xFE2D: 84,
+    0xFE2E: 84,
+    0xFE2F: 84,
+    0xFEFF: 84,
+    0xFFF9: 84,
+    0xFFFA: 84,
+    0xFFFB: 84,
+    0x101FD: 84,
+    0x102E0: 84,
+    0x10376: 84,
+    0x10377: 84,
+    0x10378: 84,
+    0x10379: 84,
+    0x1037A: 84,
+    0x10A01: 84,
+    0x10A02: 84,
+    0x10A03: 84,
+    0x10A05: 84,
+    0x10A06: 84,
+    0x10A0C: 84,
+    0x10A0D: 84,
+    0x10A0E: 84,
+    0x10A0F: 84,
+    0x10A38: 84,
+    0x10A39: 84,
+    0x10A3A: 84,
+    0x10A3F: 84,
+    0x10AC0: 68,
+    0x10AC1: 68,
+    0x10AC2: 68,
+    0x10AC3: 68,
+    0x10AC4: 68,
+    0x10AC5: 82,
+    0x10AC7: 82,
+    0x10AC9: 82,
+    0x10ACA: 82,
+    0x10ACD: 76,
+    0x10ACE: 82,
+    0x10ACF: 82,
+    0x10AD0: 82,
+    0x10AD1: 82,
+    0x10AD2: 82,
+    0x10AD3: 68,
+    0x10AD4: 68,
+    0x10AD5: 68,
+    0x10AD6: 68,
+    0x10AD7: 76,
+    0x10AD8: 68,
+    0x10AD9: 68,
+    0x10ADA: 68,
+    0x10ADB: 68,
+    0x10ADC: 68,
+    0x10ADD: 82,
+    0x10ADE: 68,
+    0x10ADF: 68,
+    0x10AE0: 68,
+    0x10AE1: 82,
+    0x10AE4: 82,
+    0x10AE5: 84,
+    0x10AE6: 84,
+    0x10AEB: 68,
+    0x10AEC: 68,
+    0x10AED: 68,
+    0x10AEE: 68,
+    0x10AEF: 82,
+    0x10B80: 68,
+    0x10B81: 82,
+    0x10B82: 68,
+    0x10B83: 82,
+    0x10B84: 82,
+    0x10B85: 82,
+    0x10B86: 68,
+    0x10B87: 68,
+    0x10B88: 68,
+    0x10B89: 82,
+    0x10B8A: 68,
+    0x10B8B: 68,
+    0x10B8C: 82,
+    0x10B8D: 68,
+    0x10B8E: 82,
+    0x10B8F: 82,
+    0x10B90: 68,
+    0x10B91: 82,
+    0x10BA9: 82,
+    0x10BAA: 82,
+    0x10BAB: 82,
+    0x10BAC: 82,
+    0x10BAD: 68,
+    0x10BAE: 68,
+    0x10D00: 76,
+    0x10D01: 68,
+    0x10D02: 68,
+    0x10D03: 68,
+    0x10D04: 68,
+    0x10D05: 68,
+    0x10D06: 68,
+    0x10D07: 68,
+    0x10D08: 68,
+    0x10D09: 68,
+    0x10D0A: 68,
+    0x10D0B: 68,
+    0x10D0C: 68,
+    0x10D0D: 68,
+    0x10D0E: 68,
+    0x10D0F: 68,
+    0x10D10: 68,
+    0x10D11: 68,
+    0x10D12: 68,
+    0x10D13: 68,
+    0x10D14: 68,
+    0x10D15: 68,
+    0x10D16: 68,
+    0x10D17: 68,
+    0x10D18: 68,
+    0x10D19: 68,
+    0x10D1A: 68,
+    0x10D1B: 68,
+    0x10D1C: 68,
+    0x10D1D: 68,
+    0x10D1E: 68,
+    0x10D1F: 68,
+    0x10D20: 68,
+    0x10D21: 68,
+    0x10D22: 82,
+    0x10D23: 68,
+    0x10D24: 84,
+    0x10D25: 84,
+    0x10D26: 84,
+    0x10D27: 84,
+    0x10D69: 84,
+    0x10D6A: 84,
+    0x10D6B: 84,
+    0x10D6C: 84,
+    0x10D6D: 84,
+    0x10EAB: 84,
+    0x10EAC: 84,
+    0x10EC2: 82,
+    0x10EC3: 68,
+    0x10EC4: 68,
+    0x10EFC: 84,
+    0x10EFD: 84,
+    0x10EFE: 84,
+    0x10EFF: 84,
+    0x10F30: 68,
+    0x10F31: 68,
+    0x10F32: 68,
+    0x10F33: 82,
+    0x10F34: 68,
+    0x10F35: 68,
+    0x10F36: 68,
+    0x10F37: 68,
+    0x10F38: 68,
+    0x10F39: 68,
+    0x10F3A: 68,
+    0x10F3B: 68,
+    0x10F3C: 68,
+    0x10F3D: 68,
+    0x10F3E: 68,
+    0x10F3F: 68,
+    0x10F40: 68,
+    0x10F41: 68,
+    0x10F42: 68,
+    0x10F43: 68,
+    0x10F44: 68,
+    0x10F46: 84,
+    0x10F47: 84,
+    0x10F48: 84,
+    0x10F49: 84,
+    0x10F4A: 84,
+    0x10F4B: 84,
+    0x10F4C: 84,
+    0x10F4D: 84,
+    0x10F4E: 84,
+    0x10F4F: 84,
+    0x10F50: 84,
+    0x10F51: 68,
+    0x10F52: 68,
+    0x10F53: 68,
+    0x10F54: 82,
+    0x10F70: 68,
+    0x10F71: 68,
+    0x10F72: 68,
+    0x10F73: 68,
+    0x10F74: 82,
+    0x10F75: 82,
+    0x10F76: 68,
+    0x10F77: 68,
+    0x10F78: 68,
+    0x10F79: 68,
+    0x10F7A: 68,
+    0x10F7B: 68,
+    0x10F7C: 68,
+    0x10F7D: 68,
+    0x10F7E: 68,
+    0x10F7F: 68,
+    0x10F80: 68,
+    0x10F81: 68,
+    0x10F82: 84,
+    0x10F83: 84,
+    0x10F84: 84,
+    0x10F85: 84,
+    0x10FB0: 68,
+    0x10FB2: 68,
+    0x10FB3: 68,
+    0x10FB4: 82,
+    0x10FB5: 82,
+    0x10FB6: 82,
+    0x10FB8: 68,
+    0x10FB9: 82,
+    0x10FBA: 82,
+    0x10FBB: 68,
+    0x10FBC: 68,
+    0x10FBD: 82,
+    0x10FBE: 68,
+    0x10FBF: 68,
+    0x10FC1: 68,
+    0x10FC2: 82,
+    0x10FC3: 82,
+    0x10FC4: 68,
+    0x10FC9: 82,
+    0x10FCA: 68,
+    0x10FCB: 76,
+    0x11001: 84,
+    0x11038: 84,
+    0x11039: 84,
+    0x1103A: 84,
+    0x1103B: 84,
+    0x1103C: 84,
+    0x1103D: 84,
+    0x1103E: 84,
+    0x1103F: 84,
+    0x11040: 84,
+    0x11041: 84,
+    0x11042: 84,
+    0x11043: 84,
+    0x11044: 84,
+    0x11045: 84,
+    0x11046: 84,
+    0x11070: 84,
+    0x11073: 84,
+    0x11074: 84,
+    0x1107F: 84,
+    0x11080: 84,
+    0x11081: 84,
+    0x110B3: 84,
+    0x110B4: 84,
+    0x110B5: 84,
+    0x110B6: 84,
+    0x110B9: 84,
+    0x110BA: 84,
+    0x110C2: 84,
+    0x11100: 84,
+    0x11101: 84,
+    0x11102: 84,
+    0x11127: 84,
+    0x11128: 84,
+    0x11129: 84,
+    0x1112A: 84,
+    0x1112B: 84,
+    0x1112D: 84,
+    0x1112E: 84,
+    0x1112F: 84,
+    0x11130: 84,
+    0x11131: 84,
+    0x11132: 84,
+    0x11133: 84,
+    0x11134: 84,
+    0x11173: 84,
+    0x11180: 84,
+    0x11181: 84,
+    0x111B6: 84,
+    0x111B7: 84,
+    0x111B8: 84,
+    0x111B9: 84,
+    0x111BA: 84,
+    0x111BB: 84,
+    0x111BC: 84,
+    0x111BD: 84,
+    0x111BE: 84,
+    0x111C9: 84,
+    0x111CA: 84,
+    0x111CB: 84,
+    0x111CC: 84,
+    0x111CF: 84,
+    0x1122F: 84,
+    0x11230: 84,
+    0x11231: 84,
+    0x11234: 84,
+    0x11236: 84,
+    0x11237: 84,
+    0x1123E: 84,
+    0x11241: 84,
+    0x112DF: 84,
+    0x112E3: 84,
+    0x112E4: 84,
+    0x112E5: 84,
+    0x112E6: 84,
+    0x112E7: 84,
+    0x112E8: 84,
+    0x112E9: 84,
+    0x112EA: 84,
+    0x11300: 84,
+    0x11301: 84,
+    0x1133B: 84,
+    0x1133C: 84,
+    0x11340: 84,
+    0x11366: 84,
+    0x11367: 84,
+    0x11368: 84,
+    0x11369: 84,
+    0x1136A: 84,
+    0x1136B: 84,
+    0x1136C: 84,
+    0x11370: 84,
+    0x11371: 84,
+    0x11372: 84,
+    0x11373: 84,
+    0x11374: 84,
+    0x113BB: 84,
+    0x113BC: 84,
+    0x113BD: 84,
+    0x113BE: 84,
+    0x113BF: 84,
+    0x113C0: 84,
+    0x113CE: 84,
+    0x113D0: 84,
+    0x113D2: 84,
+    0x113E1: 84,
+    0x113E2: 84,
+    0x11438: 84,
+    0x11439: 84,
+    0x1143A: 84,
+    0x1143B: 84,
+    0x1143C: 84,
+    0x1143D: 84,
+    0x1143E: 84,
+    0x1143F: 84,
+    0x11442: 84,
+    0x11443: 84,
+    0x11444: 84,
+    0x11446: 84,
+    0x1145E: 84,
+    0x114B3: 84,
+    0x114B4: 84,
+    0x114B5: 84,
+    0x114B6: 84,
+    0x114B7: 84,
+    0x114B8: 84,
+    0x114BA: 84,
+    0x114BF: 84,
+    0x114C0: 84,
+    0x114C2: 84,
+    0x114C3: 84,
+    0x115B2: 84,
+    0x115B3: 84,
+    0x115B4: 84,
+    0x115B5: 84,
+    0x115BC: 84,
+    0x115BD: 84,
+    0x115BF: 84,
+    0x115C0: 84,
+    0x115DC: 84,
+    0x115DD: 84,
+    0x11633: 84,
+    0x11634: 84,
+    0x11635: 84,
+    0x11636: 84,
+    0x11637: 84,
+    0x11638: 84,
+    0x11639: 84,
+    0x1163A: 84,
+    0x1163D: 84,
+    0x1163F: 84,
+    0x11640: 84,
+    0x116AB: 84,
+    0x116AD: 84,
+    0x116B0: 84,
+    0x116B1: 84,
+    0x116B2: 84,
+    0x116B3: 84,
+    0x116B4: 84,
+    0x116B5: 84,
+    0x116B7: 84,
+    0x1171D: 84,
+    0x1171F: 84,
+    0x11722: 84,
+    0x11723: 84,
+    0x11724: 84,
+    0x11725: 84,
+    0x11727: 84,
+    0x11728: 84,
+    0x11729: 84,
+    0x1172A: 84,
+    0x1172B: 84,
+    0x1182F: 84,
+    0x11830: 84,
+    0x11831: 84,
+    0x11832: 84,
+    0x11833: 84,
+    0x11834: 84,
+    0x11835: 84,
+    0x11836: 84,
+    0x11837: 84,
+    0x11839: 84,
+    0x1183A: 84,
+    0x1193B: 84,
+    0x1193C: 84,
+    0x1193E: 84,
+    0x11943: 84,
+    0x119D4: 84,
+    0x119D5: 84,
+    0x119D6: 84,
+    0x119D7: 84,
+    0x119DA: 84,
+    0x119DB: 84,
+    0x119E0: 84,
+    0x11A01: 84,
+    0x11A02: 84,
+    0x11A03: 84,
+    0x11A04: 84,
+    0x11A05: 84,
+    0x11A06: 84,
+    0x11A07: 84,
+    0x11A08: 84,
+    0x11A09: 84,
+    0x11A0A: 84,
+    0x11A33: 84,
+    0x11A34: 84,
+    0x11A35: 84,
+    0x11A36: 84,
+    0x11A37: 84,
+    0x11A38: 84,
+    0x11A3B: 84,
+    0x11A3C: 84,
+    0x11A3D: 84,
+    0x11A3E: 84,
+    0x11A47: 84,
+    0x11A51: 84,
+    0x11A52: 84,
+    0x11A53: 84,
+    0x11A54: 84,
+    0x11A55: 84,
+    0x11A56: 84,
+    0x11A59: 84,
+    0x11A5A: 84,
+    0x11A5B: 84,
+    0x11A8A: 84,
+    0x11A8B: 84,
+    0x11A8C: 84,
+    0x11A8D: 84,
+    0x11A8E: 84,
+    0x11A8F: 84,
+    0x11A90: 84,
+    0x11A91: 84,
+    0x11A92: 84,
+    0x11A93: 84,
+    0x11A94: 84,
+    0x11A95: 84,
+    0x11A96: 84,
+    0x11A98: 84,
+    0x11A99: 84,
+    0x11C30: 84,
+    0x11C31: 84,
+    0x11C32: 84,
+    0x11C33: 84,
+    0x11C34: 84,
+    0x11C35: 84,
+    0x11C36: 84,
+    0x11C38: 84,
+    0x11C39: 84,
+    0x11C3A: 84,
+    0x11C3B: 84,
+    0x11C3C: 84,
+    0x11C3D: 84,
+    0x11C3F: 84,
+    0x11C92: 84,
+    0x11C93: 84,
+    0x11C94: 84,
+    0x11C95: 84,
+    0x11C96: 84,
+    0x11C97: 84,
+    0x11C98: 84,
+    0x11C99: 84,
+    0x11C9A: 84,
+    0x11C9B: 84,
+    0x11C9C: 84,
+    0x11C9D: 84,
+    0x11C9E: 84,
+    0x11C9F: 84,
+    0x11CA0: 84,
+    0x11CA1: 84,
+    0x11CA2: 84,
+    0x11CA3: 84,
+    0x11CA4: 84,
+    0x11CA5: 84,
+    0x11CA6: 84,
+    0x11CA7: 84,
+    0x11CAA: 84,
+    0x11CAB: 84,
+    0x11CAC: 84,
+    0x11CAD: 84,
+    0x11CAE: 84,
+    0x11CAF: 84,
+    0x11CB0: 84,
+    0x11CB2: 84,
+    0x11CB3: 84,
+    0x11CB5: 84,
+    0x11CB6: 84,
+    0x11D31: 84,
+    0x11D32: 84,
+    0x11D33: 84,
+    0x11D34: 84,
+    0x11D35: 84,
+    0x11D36: 84,
+    0x11D3A: 84,
+    0x11D3C: 84,
+    0x11D3D: 84,
+    0x11D3F: 84,
+    0x11D40: 84,
+    0x11D41: 84,
+    0x11D42: 84,
+    0x11D43: 84,
+    0x11D44: 84,
+    0x11D45: 84,
+    0x11D47: 84,
+    0x11D90: 84,
+    0x11D91: 84,
+    0x11D95: 84,
+    0x11D97: 84,
+    0x11EF3: 84,
+    0x11EF4: 84,
+    0x11F00: 84,
+    0x11F01: 84,
+    0x11F36: 84,
+    0x11F37: 84,
+    0x11F38: 84,
+    0x11F39: 84,
+    0x11F3A: 84,
+    0x11F40: 84,
+    0x11F42: 84,
+    0x11F5A: 84,
+    0x13430: 84,
+    0x13431: 84,
+    0x13432: 84,
+    0x13433: 84,
+    0x13434: 84,
+    0x13435: 84,
+    0x13436: 84,
+    0x13437: 84,
+    0x13438: 84,
+    0x13439: 84,
+    0x1343A: 84,
+    0x1343B: 84,
+    0x1343C: 84,
+    0x1343D: 84,
+    0x1343E: 84,
+    0x1343F: 84,
+    0x13440: 84,
+    0x13447: 84,
+    0x13448: 84,
+    0x13449: 84,
+    0x1344A: 84,
+    0x1344B: 84,
+    0x1344C: 84,
+    0x1344D: 84,
+    0x1344E: 84,
+    0x1344F: 84,
+    0x13450: 84,
+    0x13451: 84,
+    0x13452: 84,
+    0x13453: 84,
+    0x13454: 84,
+    0x13455: 84,
+    0x1611E: 84,
+    0x1611F: 84,
+    0x16120: 84,
+    0x16121: 84,
+    0x16122: 84,
+    0x16123: 84,
+    0x16124: 84,
+    0x16125: 84,
+    0x16126: 84,
+    0x16127: 84,
+    0x16128: 84,
+    0x16129: 84,
+    0x1612D: 84,
+    0x1612E: 84,
+    0x1612F: 84,
+    0x16AF0: 84,
+    0x16AF1: 84,
+    0x16AF2: 84,
+    0x16AF3: 84,
+    0x16AF4: 84,
+    0x16B30: 84,
+    0x16B31: 84,
+    0x16B32: 84,
+    0x16B33: 84,
+    0x16B34: 84,
+    0x16B35: 84,
+    0x16B36: 84,
+    0x16F4F: 84,
+    0x16F8F: 84,
+    0x16F90: 84,
+    0x16F91: 84,
+    0x16F92: 84,
+    0x16FE4: 84,
+    0x1BC9D: 84,
+    0x1BC9E: 84,
+    0x1BCA0: 84,
+    0x1BCA1: 84,
+    0x1BCA2: 84,
+    0x1BCA3: 84,
+    0x1CF00: 84,
+    0x1CF01: 84,
+    0x1CF02: 84,
+    0x1CF03: 84,
+    0x1CF04: 84,
+    0x1CF05: 84,
+    0x1CF06: 84,
+    0x1CF07: 84,
+    0x1CF08: 84,
+    0x1CF09: 84,
+    0x1CF0A: 84,
+    0x1CF0B: 84,
+    0x1CF0C: 84,
+    0x1CF0D: 84,
+    0x1CF0E: 84,
+    0x1CF0F: 84,
+    0x1CF10: 84,
+    0x1CF11: 84,
+    0x1CF12: 84,
+    0x1CF13: 84,
+    0x1CF14: 84,
+    0x1CF15: 84,
+    0x1CF16: 84,
+    0x1CF17: 84,
+    0x1CF18: 84,
+    0x1CF19: 84,
+    0x1CF1A: 84,
+    0x1CF1B: 84,
+    0x1CF1C: 84,
+    0x1CF1D: 84,
+    0x1CF1E: 84,
+    0x1CF1F: 84,
+    0x1CF20: 84,
+    0x1CF21: 84,
+    0x1CF22: 84,
+    0x1CF23: 84,
+    0x1CF24: 84,
+    0x1CF25: 84,
+    0x1CF26: 84,
+    0x1CF27: 84,
+    0x1CF28: 84,
+    0x1CF29: 84,
+    0x1CF2A: 84,
+    0x1CF2B: 84,
+    0x1CF2C: 84,
+    0x1CF2D: 84,
+    0x1CF30: 84,
+    0x1CF31: 84,
+    0x1CF32: 84,
+    0x1CF33: 84,
+    0x1CF34: 84,
+    0x1CF35: 84,
+    0x1CF36: 84,
+    0x1CF37: 84,
+    0x1CF38: 84,
+    0x1CF39: 84,
+    0x1CF3A: 84,
+    0x1CF3B: 84,
+    0x1CF3C: 84,
+    0x1CF3D: 84,
+    0x1CF3E: 84,
+    0x1CF3F: 84,
+    0x1CF40: 84,
+    0x1CF41: 84,
+    0x1CF42: 84,
+    0x1CF43: 84,
+    0x1CF44: 84,
+    0x1CF45: 84,
+    0x1CF46: 84,
+    0x1D167: 84,
+    0x1D168: 84,
+    0x1D169: 84,
+    0x1D173: 84,
+    0x1D174: 84,
+    0x1D175: 84,
+    0x1D176: 84,
+    0x1D177: 84,
+    0x1D178: 84,
+    0x1D179: 84,
+    0x1D17A: 84,
+    0x1D17B: 84,
+    0x1D17C: 84,
+    0x1D17D: 84,
+    0x1D17E: 84,
+    0x1D17F: 84,
+    0x1D180: 84,
+    0x1D181: 84,
+    0x1D182: 84,
+    0x1D185: 84,
+    0x1D186: 84,
+    0x1D187: 84,
+    0x1D188: 84,
+    0x1D189: 84,
+    0x1D18A: 84,
+    0x1D18B: 84,
+    0x1D1AA: 84,
+    0x1D1AB: 84,
+    0x1D1AC: 84,
+    0x1D1AD: 84,
+    0x1D242: 84,
+    0x1D243: 84,
+    0x1D244: 84,
+    0x1DA00: 84,
+    0x1DA01: 84,
+    0x1DA02: 84,
+    0x1DA03: 84,
+    0x1DA04: 84,
+    0x1DA05: 84,
+    0x1DA06: 84,
+    0x1DA07: 84,
+    0x1DA08: 84,
+    0x1DA09: 84,
+    0x1DA0A: 84,
+    0x1DA0B: 84,
+    0x1DA0C: 84,
+    0x1DA0D: 84,
+    0x1DA0E: 84,
+    0x1DA0F: 84,
+    0x1DA10: 84,
+    0x1DA11: 84,
+    0x1DA12: 84,
+    0x1DA13: 84,
+    0x1DA14: 84,
+    0x1DA15: 84,
+    0x1DA16: 84,
+    0x1DA17: 84,
+    0x1DA18: 84,
+    0x1DA19: 84,
+    0x1DA1A: 84,
+    0x1DA1B: 84,
+    0x1DA1C: 84,
+    0x1DA1D: 84,
+    0x1DA1E: 84,
+    0x1DA1F: 84,
+    0x1DA20: 84,
+    0x1DA21: 84,
+    0x1DA22: 84,
+    0x1DA23: 84,
+    0x1DA24: 84,
+    0x1DA25: 84,
+    0x1DA26: 84,
+    0x1DA27: 84,
+    0x1DA28: 84,
+    0x1DA29: 84,
+    0x1DA2A: 84,
+    0x1DA2B: 84,
+    0x1DA2C: 84,
+    0x1DA2D: 84,
+    0x1DA2E: 84,
+    0x1DA2F: 84,
+    0x1DA30: 84,
+    0x1DA31: 84,
+    0x1DA32: 84,
+    0x1DA33: 84,
+    0x1DA34: 84,
+    0x1DA35: 84,
+    0x1DA36: 84,
+    0x1DA3B: 84,
+    0x1DA3C: 84,
+    0x1DA3D: 84,
+    0x1DA3E: 84,
+    0x1DA3F: 84,
+    0x1DA40: 84,
+    0x1DA41: 84,
+    0x1DA42: 84,
+    0x1DA43: 84,
+    0x1DA44: 84,
+    0x1DA45: 84,
+    0x1DA46: 84,
+    0x1DA47: 84,
+    0x1DA48: 84,
+    0x1DA49: 84,
+    0x1DA4A: 84,
+    0x1DA4B: 84,
+    0x1DA4C: 84,
+    0x1DA4D: 84,
+    0x1DA4E: 84,
+    0x1DA4F: 84,
+    0x1DA50: 84,
+    0x1DA51: 84,
+    0x1DA52: 84,
+    0x1DA53: 84,
+    0x1DA54: 84,
+    0x1DA55: 84,
+    0x1DA56: 84,
+    0x1DA57: 84,
+    0x1DA58: 84,
+    0x1DA59: 84,
+    0x1DA5A: 84,
+    0x1DA5B: 84,
+    0x1DA5C: 84,
+    0x1DA5D: 84,
+    0x1DA5E: 84,
+    0x1DA5F: 84,
+    0x1DA60: 84,
+    0x1DA61: 84,
+    0x1DA62: 84,
+    0x1DA63: 84,
+    0x1DA64: 84,
+    0x1DA65: 84,
+    0x1DA66: 84,
+    0x1DA67: 84,
+    0x1DA68: 84,
+    0x1DA69: 84,
+    0x1DA6A: 84,
+    0x1DA6B: 84,
+    0x1DA6C: 84,
+    0x1DA75: 84,
+    0x1DA84: 84,
+    0x1DA9B: 84,
+    0x1DA9C: 84,
+    0x1DA9D: 84,
+    0x1DA9E: 84,
+    0x1DA9F: 84,
+    0x1DAA1: 84,
+    0x1DAA2: 84,
+    0x1DAA3: 84,
+    0x1DAA4: 84,
+    0x1DAA5: 84,
+    0x1DAA6: 84,
+    0x1DAA7: 84,
+    0x1DAA8: 84,
+    0x1DAA9: 84,
+    0x1DAAA: 84,
+    0x1DAAB: 84,
+    0x1DAAC: 84,
+    0x1DAAD: 84,
+    0x1DAAE: 84,
+    0x1DAAF: 84,
+    0x1E000: 84,
+    0x1E001: 84,
+    0x1E002: 84,
+    0x1E003: 84,
+    0x1E004: 84,
+    0x1E005: 84,
+    0x1E006: 84,
+    0x1E008: 84,
+    0x1E009: 84,
+    0x1E00A: 84,
+    0x1E00B: 84,
+    0x1E00C: 84,
+    0x1E00D: 84,
+    0x1E00E: 84,
+    0x1E00F: 84,
+    0x1E010: 84,
+    0x1E011: 84,
+    0x1E012: 84,
+    0x1E013: 84,
+    0x1E014: 84,
+    0x1E015: 84,
+    0x1E016: 84,
+    0x1E017: 84,
+    0x1E018: 84,
+    0x1E01B: 84,
+    0x1E01C: 84,
+    0x1E01D: 84,
+    0x1E01E: 84,
+    0x1E01F: 84,
+    0x1E020: 84,
+    0x1E021: 84,
+    0x1E023: 84,
+    0x1E024: 84,
+    0x1E026: 84,
+    0x1E027: 84,
+    0x1E028: 84,
+    0x1E029: 84,
+    0x1E02A: 84,
+    0x1E08F: 84,
+    0x1E130: 84,
+    0x1E131: 84,
+    0x1E132: 84,
+    0x1E133: 84,
+    0x1E134: 84,
+    0x1E135: 84,
+    0x1E136: 84,
+    0x1E2AE: 84,
+    0x1E2EC: 84,
+    0x1E2ED: 84,
+    0x1E2EE: 84,
+    0x1E2EF: 84,
+    0x1E4EC: 84,
+    0x1E4ED: 84,
+    0x1E4EE: 84,
+    0x1E4EF: 84,
+    0x1E5EE: 84,
+    0x1E5EF: 84,
+    0x1E8D0: 84,
+    0x1E8D1: 84,
+    0x1E8D2: 84,
+    0x1E8D3: 84,
+    0x1E8D4: 84,
+    0x1E8D5: 84,
+    0x1E8D6: 84,
+    0x1E900: 68,
+    0x1E901: 68,
+    0x1E902: 68,
+    0x1E903: 68,
+    0x1E904: 68,
+    0x1E905: 68,
+    0x1E906: 68,
+    0x1E907: 68,
+    0x1E908: 68,
+    0x1E909: 68,
+    0x1E90A: 68,
+    0x1E90B: 68,
+    0x1E90C: 68,
+    0x1E90D: 68,
+    0x1E90E: 68,
+    0x1E90F: 68,
+    0x1E910: 68,
+    0x1E911: 68,
+    0x1E912: 68,
+    0x1E913: 68,
+    0x1E914: 68,
+    0x1E915: 68,
+    0x1E916: 68,
+    0x1E917: 68,
+    0x1E918: 68,
+    0x1E919: 68,
+    0x1E91A: 68,
+    0x1E91B: 68,
+    0x1E91C: 68,
+    0x1E91D: 68,
+    0x1E91E: 68,
+    0x1E91F: 68,
+    0x1E920: 68,
+    0x1E921: 68,
+    0x1E922: 68,
+    0x1E923: 68,
+    0x1E924: 68,
+    0x1E925: 68,
+    0x1E926: 68,
+    0x1E927: 68,
+    0x1E928: 68,
+    0x1E929: 68,
+    0x1E92A: 68,
+    0x1E92B: 68,
+    0x1E92C: 68,
+    0x1E92D: 68,
+    0x1E92E: 68,
+    0x1E92F: 68,
+    0x1E930: 68,
+    0x1E931: 68,
+    0x1E932: 68,
+    0x1E933: 68,
+    0x1E934: 68,
+    0x1E935: 68,
+    0x1E936: 68,
+    0x1E937: 68,
+    0x1E938: 68,
+    0x1E939: 68,
+    0x1E93A: 68,
+    0x1E93B: 68,
+    0x1E93C: 68,
+    0x1E93D: 68,
+    0x1E93E: 68,
+    0x1E93F: 68,
+    0x1E940: 68,
+    0x1E941: 68,
+    0x1E942: 68,
+    0x1E943: 68,
+    0x1E944: 84,
+    0x1E945: 84,
+    0x1E946: 84,
+    0x1E947: 84,
+    0x1E948: 84,
+    0x1E949: 84,
+    0x1E94A: 84,
+    0x1E94B: 84,
+    0xE0001: 84,
+    0xE0020: 84,
+    0xE0021: 84,
+    0xE0022: 84,
+    0xE0023: 84,
+    0xE0024: 84,
+    0xE0025: 84,
+    0xE0026: 84,
+    0xE0027: 84,
+    0xE0028: 84,
+    0xE0029: 84,
+    0xE002A: 84,
+    0xE002B: 84,
+    0xE002C: 84,
+    0xE002D: 84,
+    0xE002E: 84,
+    0xE002F: 84,
+    0xE0030: 84,
+    0xE0031: 84,
+    0xE0032: 84,
+    0xE0033: 84,
+    0xE0034: 84,
+    0xE0035: 84,
+    0xE0036: 84,
+    0xE0037: 84,
+    0xE0038: 84,
+    0xE0039: 84,
+    0xE003A: 84,
+    0xE003B: 84,
+    0xE003C: 84,
+    0xE003D: 84,
+    0xE003E: 84,
+    0xE003F: 84,
+    0xE0040: 84,
+    0xE0041: 84,
+    0xE0042: 84,
+    0xE0043: 84,
+    0xE0044: 84,
+    0xE0045: 84,
+    0xE0046: 84,
+    0xE0047: 84,
+    0xE0048: 84,
+    0xE0049: 84,
+    0xE004A: 84,
+    0xE004B: 84,
+    0xE004C: 84,
+    0xE004D: 84,
+    0xE004E: 84,
+    0xE004F: 84,
+    0xE0050: 84,
+    0xE0051: 84,
+    0xE0052: 84,
+    0xE0053: 84,
+    0xE0054: 84,
+    0xE0055: 84,
+    0xE0056: 84,
+    0xE0057: 84,
+    0xE0058: 84,
+    0xE0059: 84,
+    0xE005A: 84,
+    0xE005B: 84,
+    0xE005C: 84,
+    0xE005D: 84,
+    0xE005E: 84,
+    0xE005F: 84,
+    0xE0060: 84,
+    0xE0061: 84,
+    0xE0062: 84,
+    0xE0063: 84,
+    0xE0064: 84,
+    0xE0065: 84,
+    0xE0066: 84,
+    0xE0067: 84,
+    0xE0068: 84,
+    0xE0069: 84,
+    0xE006A: 84,
+    0xE006B: 84,
+    0xE006C: 84,
+    0xE006D: 84,
+    0xE006E: 84,
+    0xE006F: 84,
+    0xE0070: 84,
+    0xE0071: 84,
+    0xE0072: 84,
+    0xE0073: 84,
+    0xE0074: 84,
+    0xE0075: 84,
+    0xE0076: 84,
+    0xE0077: 84,
+    0xE0078: 84,
+    0xE0079: 84,
+    0xE007A: 84,
+    0xE007B: 84,
+    0xE007C: 84,
+    0xE007D: 84,
+    0xE007E: 84,
+    0xE007F: 84,
+    0xE0100: 84,
+    0xE0101: 84,
+    0xE0102: 84,
+    0xE0103: 84,
+    0xE0104: 84,
+    0xE0105: 84,
+    0xE0106: 84,
+    0xE0107: 84,
+    0xE0108: 84,
+    0xE0109: 84,
+    0xE010A: 84,
+    0xE010B: 84,
+    0xE010C: 84,
+    0xE010D: 84,
+    0xE010E: 84,
+    0xE010F: 84,
+    0xE0110: 84,
+    0xE0111: 84,
+    0xE0112: 84,
+    0xE0113: 84,
+    0xE0114: 84,
+    0xE0115: 84,
+    0xE0116: 84,
+    0xE0117: 84,
+    0xE0118: 84,
+    0xE0119: 84,
+    0xE011A: 84,
+    0xE011B: 84,
+    0xE011C: 84,
+    0xE011D: 84,
+    0xE011E: 84,
+    0xE011F: 84,
+    0xE0120: 84,
+    0xE0121: 84,
+    0xE0122: 84,
+    0xE0123: 84,
+    0xE0124: 84,
+    0xE0125: 84,
+    0xE0126: 84,
+    0xE0127: 84,
+    0xE0128: 84,
+    0xE0129: 84,
+    0xE012A: 84,
+    0xE012B: 84,
+    0xE012C: 84,
+    0xE012D: 84,
+    0xE012E: 84,
+    0xE012F: 84,
+    0xE0130: 84,
+    0xE0131: 84,
+    0xE0132: 84,
+    0xE0133: 84,
+    0xE0134: 84,
+    0xE0135: 84,
+    0xE0136: 84,
+    0xE0137: 84,
+    0xE0138: 84,
+    0xE0139: 84,
+    0xE013A: 84,
+    0xE013B: 84,
+    0xE013C: 84,
+    0xE013D: 84,
+    0xE013E: 84,
+    0xE013F: 84,
+    0xE0140: 84,
+    0xE0141: 84,
+    0xE0142: 84,
+    0xE0143: 84,
+    0xE0144: 84,
+    0xE0145: 84,
+    0xE0146: 84,
+    0xE0147: 84,
+    0xE0148: 84,
+    0xE0149: 84,
+    0xE014A: 84,
+    0xE014B: 84,
+    0xE014C: 84,
+    0xE014D: 84,
+    0xE014E: 84,
+    0xE014F: 84,
+    0xE0150: 84,
+    0xE0151: 84,
+    0xE0152: 84,
+    0xE0153: 84,
+    0xE0154: 84,
+    0xE0155: 84,
+    0xE0156: 84,
+    0xE0157: 84,
+    0xE0158: 84,
+    0xE0159: 84,
+    0xE015A: 84,
+    0xE015B: 84,
+    0xE015C: 84,
+    0xE015D: 84,
+    0xE015E: 84,
+    0xE015F: 84,
+    0xE0160: 84,
+    0xE0161: 84,
+    0xE0162: 84,
+    0xE0163: 84,
+    0xE0164: 84,
+    0xE0165: 84,
+    0xE0166: 84,
+    0xE0167: 84,
+    0xE0168: 84,
+    0xE0169: 84,
+    0xE016A: 84,
+    0xE016B: 84,
+    0xE016C: 84,
+    0xE016D: 84,
+    0xE016E: 84,
+    0xE016F: 84,
+    0xE0170: 84,
+    0xE0171: 84,
+    0xE0172: 84,
+    0xE0173: 84,
+    0xE0174: 84,
+    0xE0175: 84,
+    0xE0176: 84,
+    0xE0177: 84,
+    0xE0178: 84,
+    0xE0179: 84,
+    0xE017A: 84,
+    0xE017B: 84,
+    0xE017C: 84,
+    0xE017D: 84,
+    0xE017E: 84,
+    0xE017F: 84,
+    0xE0180: 84,
+    0xE0181: 84,
+    0xE0182: 84,
+    0xE0183: 84,
+    0xE0184: 84,
+    0xE0185: 84,
+    0xE0186: 84,
+    0xE0187: 84,
+    0xE0188: 84,
+    0xE0189: 84,
+    0xE018A: 84,
+    0xE018B: 84,
+    0xE018C: 84,
+    0xE018D: 84,
+    0xE018E: 84,
+    0xE018F: 84,
+    0xE0190: 84,
+    0xE0191: 84,
+    0xE0192: 84,
+    0xE0193: 84,
+    0xE0194: 84,
+    0xE0195: 84,
+    0xE0196: 84,
+    0xE0197: 84,
+    0xE0198: 84,
+    0xE0199: 84,
+    0xE019A: 84,
+    0xE019B: 84,
+    0xE019C: 84,
+    0xE019D: 84,
+    0xE019E: 84,
+    0xE019F: 84,
+    0xE01A0: 84,
+    0xE01A1: 84,
+    0xE01A2: 84,
+    0xE01A3: 84,
+    0xE01A4: 84,
+    0xE01A5: 84,
+    0xE01A6: 84,
+    0xE01A7: 84,
+    0xE01A8: 84,
+    0xE01A9: 84,
+    0xE01AA: 84,
+    0xE01AB: 84,
+    0xE01AC: 84,
+    0xE01AD: 84,
+    0xE01AE: 84,
+    0xE01AF: 84,
+    0xE01B0: 84,
+    0xE01B1: 84,
+    0xE01B2: 84,
+    0xE01B3: 84,
+    0xE01B4: 84,
+    0xE01B5: 84,
+    0xE01B6: 84,
+    0xE01B7: 84,
+    0xE01B8: 84,
+    0xE01B9: 84,
+    0xE01BA: 84,
+    0xE01BB: 84,
+    0xE01BC: 84,
+    0xE01BD: 84,
+    0xE01BE: 84,
+    0xE01BF: 84,
+    0xE01C0: 84,
+    0xE01C1: 84,
+    0xE01C2: 84,
+    0xE01C3: 84,
+    0xE01C4: 84,
+    0xE01C5: 84,
+    0xE01C6: 84,
+    0xE01C7: 84,
+    0xE01C8: 84,
+    0xE01C9: 84,
+    0xE01CA: 84,
+    0xE01CB: 84,
+    0xE01CC: 84,
+    0xE01CD: 84,
+    0xE01CE: 84,
+    0xE01CF: 84,
+    0xE01D0: 84,
+    0xE01D1: 84,
+    0xE01D2: 84,
+    0xE01D3: 84,
+    0xE01D4: 84,
+    0xE01D5: 84,
+    0xE01D6: 84,
+    0xE01D7: 84,
+    0xE01D8: 84,
+    0xE01D9: 84,
+    0xE01DA: 84,
+    0xE01DB: 84,
+    0xE01DC: 84,
+    0xE01DD: 84,
+    0xE01DE: 84,
+    0xE01DF: 84,
+    0xE01E0: 84,
+    0xE01E1: 84,
+    0xE01E2: 84,
+    0xE01E3: 84,
+    0xE01E4: 84,
+    0xE01E5: 84,
+    0xE01E6: 84,
+    0xE01E7: 84,
+    0xE01E8: 84,
+    0xE01E9: 84,
+    0xE01EA: 84,
+    0xE01EB: 84,
+    0xE01EC: 84,
+    0xE01ED: 84,
+    0xE01EE: 84,
+    0xE01EF: 84,
+}
+codepoint_classes = {
+    "PVALID": (
+        0x2D0000002E,
+        0x300000003A,
+        0x610000007B,
+        0xDF000000F7,
+        0xF800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010A,
+        0x10B0000010C,
+        0x10D0000010E,
+        0x10F00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011A,
+        0x11B0000011C,
+        0x11D0000011E,
+        0x11F00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012A,
+        0x12B0000012C,
+        0x12D0000012E,
+        0x12F00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13A0000013B,
+        0x13C0000013D,
+        0x13E0000013F,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14B0000014C,
+        0x14D0000014E,
+        0x14F00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015A,
+        0x15B0000015C,
+        0x15D0000015E,
+        0x15F00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016A,
+        0x16B0000016C,
+        0x16D0000016E,
+        0x16F00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17A0000017B,
+        0x17C0000017D,
+        0x17E0000017F,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18C0000018E,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019C,
+        0x19E0000019F,
+        0x1A1000001A2,
+        0x1A3000001A4,
+        0x1A5000001A6,
+        0x1A8000001A9,
+        0x1AA000001AC,
+        0x1AD000001AE,
+        0x1B0000001B1,
+        0x1B4000001B5,
+        0x1B6000001B7,
+        0x1B9000001BC,
+        0x1BD000001C4,
+        0x1CE000001CF,
+        0x1D0000001D1,
+        0x1D2000001D3,
+        0x1D4000001D5,
+        0x1D6000001D7,
+        0x1D8000001D9,
+        0x1DA000001DB,
+        0x1DC000001DE,
+        0x1DF000001E0,
+        0x1E1000001E2,
+        0x1E3000001E4,
+        0x1E5000001E6,
+        0x1E7000001E8,
+        0x1E9000001EA,
+        0x1EB000001EC,
+        0x1ED000001EE,
+        0x1EF000001F1,
+        0x1F5000001F6,
+        0x1F9000001FA,
+        0x1FB000001FC,
+        0x1FD000001FE,
+        0x1FF00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020A,
+        0x20B0000020C,
+        0x20D0000020E,
+        0x20F00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021A,
+        0x21B0000021C,
+        0x21D0000021E,
+        0x21F00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022A,
+        0x22B0000022C,
+        0x22D0000022E,
+        0x22F00000230,
+        0x23100000232,
+        0x2330000023A,
+        0x23C0000023D,
+        0x23F00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024A,
+        0x24B0000024C,
+        0x24D0000024E,
+        0x24F000002B0,
+        0x2B9000002C2,
+        0x2C6000002D2,
+        0x2EC000002ED,
+        0x2EE000002EF,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034F,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37B0000037E,
+        0x39000000391,
+        0x3AC000003CF,
+        0x3D7000003D8,
+        0x3D9000003DA,
+        0x3DB000003DC,
+        0x3DD000003DE,
+        0x3DF000003E0,
+        0x3E1000003E2,
+        0x3E3000003E4,
+        0x3E5000003E6,
+        0x3E7000003E8,
+        0x3E9000003EA,
+        0x3EB000003EC,
+        0x3ED000003EE,
+        0x3EF000003F0,
+        0x3F3000003F4,
+        0x3F8000003F9,
+        0x3FB000003FD,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046A,
+        0x46B0000046C,
+        0x46D0000046E,
+        0x46F00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047A,
+        0x47B0000047C,
+        0x47D0000047E,
+        0x47F00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48B0000048C,
+        0x48D0000048E,
+        0x48F00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049A,
+        0x49B0000049C,
+        0x49D0000049E,
+        0x49F000004A0,
+        0x4A1000004A2,
+        0x4A3000004A4,
+        0x4A5000004A6,
+        0x4A7000004A8,
+        0x4A9000004AA,
+        0x4AB000004AC,
+        0x4AD000004AE,
+        0x4AF000004B0,
+        0x4B1000004B2,
+        0x4B3000004B4,
+        0x4B5000004B6,
+        0x4B7000004B8,
+        0x4B9000004BA,
+        0x4BB000004BC,
+        0x4BD000004BE,
+        0x4BF000004C0,
+        0x4C2000004C3,
+        0x4C4000004C5,
+        0x4C6000004C7,
+        0x4C8000004C9,
+        0x4CA000004CB,
+        0x4CC000004CD,
+        0x4CE000004D0,
+        0x4D1000004D2,
+        0x4D3000004D4,
+        0x4D5000004D6,
+        0x4D7000004D8,
+        0x4D9000004DA,
+        0x4DB000004DC,
+        0x4DD000004DE,
+        0x4DF000004E0,
+        0x4E1000004E2,
+        0x4E3000004E4,
+        0x4E5000004E6,
+        0x4E7000004E8,
+        0x4E9000004EA,
+        0x4EB000004EC,
+        0x4ED000004EE,
+        0x4EF000004F0,
+        0x4F1000004F2,
+        0x4F3000004F4,
+        0x4F5000004F6,
+        0x4F7000004F8,
+        0x4F9000004FA,
+        0x4FB000004FC,
+        0x4FD000004FE,
+        0x4FF00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050A,
+        0x50B0000050C,
+        0x50D0000050E,
+        0x50F00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051A,
+        0x51B0000051C,
+        0x51D0000051E,
+        0x51F00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052A,
+        0x52B0000052C,
+        0x52D0000052E,
+        0x52F00000530,
+        0x5590000055A,
+        0x56000000587,
+        0x58800000589,
+        0x591000005BE,
+        0x5BF000005C0,
+        0x5C1000005C3,
+        0x5C4000005C6,
+        0x5C7000005C8,
+        0x5D0000005EB,
+        0x5EF000005F3,
+        0x6100000061B,
+        0x62000000640,
+        0x64100000660,
+        0x66E00000675,
+        0x679000006D4,
+        0x6D5000006DD,
+        0x6DF000006E9,
+        0x6EA000006F0,
+        0x6FA00000700,
+        0x7100000074B,
+        0x74D000007B2,
+        0x7C0000007F6,
+        0x7FD000007FE,
+        0x8000000082E,
+        0x8400000085C,
+        0x8600000086B,
+        0x87000000888,
+        0x8890000088F,
+        0x897000008E2,
+        0x8E300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098D,
+        0x98F00000991,
+        0x993000009A9,
+        0x9AA000009B1,
+        0x9B2000009B3,
+        0x9B6000009BA,
+        0x9BC000009C5,
+        0x9C7000009C9,
+        0x9CB000009CF,
+        0x9D7000009D8,
+        0x9E0000009E4,
+        0x9E6000009F2,
+        0x9FC000009FD,
+        0x9FE000009FF,
+        0xA0100000A04,
+        0xA0500000A0B,
+        0xA0F00000A11,
+        0xA1300000A29,
+        0xA2A00000A31,
+        0xA3200000A33,
+        0xA3500000A36,
+        0xA3800000A3A,
+        0xA3C00000A3D,
+        0xA3E00000A43,
+        0xA4700000A49,
+        0xA4B00000A4E,
+        0xA5100000A52,
+        0xA5C00000A5D,
+        0xA6600000A76,
+        0xA8100000A84,
+        0xA8500000A8E,
+        0xA8F00000A92,
+        0xA9300000AA9,
+        0xAAA00000AB1,
+        0xAB200000AB4,
+        0xAB500000ABA,
+        0xABC00000AC6,
+        0xAC700000ACA,
+        0xACB00000ACE,
+        0xAD000000AD1,
+        0xAE000000AE4,
+        0xAE600000AF0,
+        0xAF900000B00,
+        0xB0100000B04,
+        0xB0500000B0D,
+        0xB0F00000B11,
+        0xB1300000B29,
+        0xB2A00000B31,
+        0xB3200000B34,
+        0xB3500000B3A,
+        0xB3C00000B45,
+        0xB4700000B49,
+        0xB4B00000B4E,
+        0xB5500000B58,
+        0xB5F00000B64,
+        0xB6600000B70,
+        0xB7100000B72,
+        0xB8200000B84,
+        0xB8500000B8B,
+        0xB8E00000B91,
+        0xB9200000B96,
+        0xB9900000B9B,
+        0xB9C00000B9D,
+        0xB9E00000BA0,
+        0xBA300000BA5,
+        0xBA800000BAB,
+        0xBAE00000BBA,
+        0xBBE00000BC3,
+        0xBC600000BC9,
+        0xBCA00000BCE,
+        0xBD000000BD1,
+        0xBD700000BD8,
+        0xBE600000BF0,
+        0xC0000000C0D,
+        0xC0E00000C11,
+        0xC1200000C29,
+        0xC2A00000C3A,
+        0xC3C00000C45,
+        0xC4600000C49,
+        0xC4A00000C4E,
+        0xC5500000C57,
+        0xC5800000C5B,
+        0xC5D00000C5E,
+        0xC6000000C64,
+        0xC6600000C70,
+        0xC8000000C84,
+        0xC8500000C8D,
+        0xC8E00000C91,
+        0xC9200000CA9,
+        0xCAA00000CB4,
+        0xCB500000CBA,
+        0xCBC00000CC5,
+        0xCC600000CC9,
+        0xCCA00000CCE,
+        0xCD500000CD7,
+        0xCDD00000CDF,
+        0xCE000000CE4,
+        0xCE600000CF0,
+        0xCF100000CF4,
+        0xD0000000D0D,
+        0xD0E00000D11,
+        0xD1200000D45,
+        0xD4600000D49,
+        0xD4A00000D4F,
+        0xD5400000D58,
+        0xD5F00000D64,
+        0xD6600000D70,
+        0xD7A00000D80,
+        0xD8100000D84,
+        0xD8500000D97,
+        0xD9A00000DB2,
+        0xDB300000DBC,
+        0xDBD00000DBE,
+        0xDC000000DC7,
+        0xDCA00000DCB,
+        0xDCF00000DD5,
+        0xDD600000DD7,
+        0xDD800000DE0,
+        0xDE600000DF0,
+        0xDF200000DF4,
+        0xE0100000E33,
+        0xE3400000E3B,
+        0xE4000000E4F,
+        0xE5000000E5A,
+        0xE8100000E83,
+        0xE8400000E85,
+        0xE8600000E8B,
+        0xE8C00000EA4,
+        0xEA500000EA6,
+        0xEA700000EB3,
+        0xEB400000EBE,
+        0xEC000000EC5,
+        0xEC600000EC7,
+        0xEC800000ECF,
+        0xED000000EDA,
+        0xEDE00000EE0,
+        0xF0000000F01,
+        0xF0B00000F0C,
+        0xF1800000F1A,
+        0xF2000000F2A,
+        0xF3500000F36,
+        0xF3700000F38,
+        0xF3900000F3A,
+        0xF3E00000F43,
+        0xF4400000F48,
+        0xF4900000F4D,
+        0xF4E00000F52,
+        0xF5300000F57,
+        0xF5800000F5C,
+        0xF5D00000F69,
+        0xF6A00000F6D,
+        0xF7100000F73,
+        0xF7400000F75,
+        0xF7A00000F81,
+        0xF8200000F85,
+        0xF8600000F93,
+        0xF9400000F98,
+        0xF9900000F9D,
+        0xF9E00000FA2,
+        0xFA300000FA7,
+        0xFA800000FAC,
+        0xFAD00000FB9,
+        0xFBA00000FBD,
+        0xFC600000FC7,
+        0x10000000104A,
+        0x10500000109E,
+        0x10D0000010FB,
+        0x10FD00001100,
+        0x120000001249,
+        0x124A0000124E,
+        0x125000001257,
+        0x125800001259,
+        0x125A0000125E,
+        0x126000001289,
+        0x128A0000128E,
+        0x1290000012B1,
+        0x12B2000012B6,
+        0x12B8000012BF,
+        0x12C0000012C1,
+        0x12C2000012C6,
+        0x12C8000012D7,
+        0x12D800001311,
+        0x131200001316,
+        0x13180000135B,
+        0x135D00001360,
+        0x138000001390,
+        0x13A0000013F6,
+        0x14010000166D,
+        0x166F00001680,
+        0x16810000169B,
+        0x16A0000016EB,
+        0x16F1000016F9,
+        0x170000001716,
+        0x171F00001735,
+        0x174000001754,
+        0x17600000176D,
+        0x176E00001771,
+        0x177200001774,
+        0x1780000017B4,
+        0x17B6000017D4,
+        0x17D7000017D8,
+        0x17DC000017DE,
+        0x17E0000017EA,
+        0x18100000181A,
+        0x182000001879,
+        0x1880000018AB,
+        0x18B0000018F6,
+        0x19000000191F,
+        0x19200000192C,
+        0x19300000193C,
+        0x19460000196E,
+        0x197000001975,
+        0x1980000019AC,
+        0x19B0000019CA,
+        0x19D0000019DA,
+        0x1A0000001A1C,
+        0x1A2000001A5F,
+        0x1A6000001A7D,
+        0x1A7F00001A8A,
+        0x1A9000001A9A,
+        0x1AA700001AA8,
+        0x1AB000001ABE,
+        0x1ABF00001ACF,
+        0x1B0000001B4D,
+        0x1B5000001B5A,
+        0x1B6B00001B74,
+        0x1B8000001BF4,
+        0x1C0000001C38,
+        0x1C4000001C4A,
+        0x1C4D00001C7E,
+        0x1C8A00001C8B,
+        0x1CD000001CD3,
+        0x1CD400001CFB,
+        0x1D0000001D2C,
+        0x1D2F00001D30,
+        0x1D3B00001D3C,
+        0x1D4E00001D4F,
+        0x1D6B00001D78,
+        0x1D7900001D9B,
+        0x1DC000001E00,
+        0x1E0100001E02,
+        0x1E0300001E04,
+        0x1E0500001E06,
+        0x1E0700001E08,
+        0x1E0900001E0A,
+        0x1E0B00001E0C,
+        0x1E0D00001E0E,
+        0x1E0F00001E10,
+        0x1E1100001E12,
+        0x1E1300001E14,
+        0x1E1500001E16,
+        0x1E1700001E18,
+        0x1E1900001E1A,
+        0x1E1B00001E1C,
+        0x1E1D00001E1E,
+        0x1E1F00001E20,
+        0x1E2100001E22,
+        0x1E2300001E24,
+        0x1E2500001E26,
+        0x1E2700001E28,
+        0x1E2900001E2A,
+        0x1E2B00001E2C,
+        0x1E2D00001E2E,
+        0x1E2F00001E30,
+        0x1E3100001E32,
+        0x1E3300001E34,
+        0x1E3500001E36,
+        0x1E3700001E38,
+        0x1E3900001E3A,
+        0x1E3B00001E3C,
+        0x1E3D00001E3E,
+        0x1E3F00001E40,
+        0x1E4100001E42,
+        0x1E4300001E44,
+        0x1E4500001E46,
+        0x1E4700001E48,
+        0x1E4900001E4A,
+        0x1E4B00001E4C,
+        0x1E4D00001E4E,
+        0x1E4F00001E50,
+        0x1E5100001E52,
+        0x1E5300001E54,
+        0x1E5500001E56,
+        0x1E5700001E58,
+        0x1E5900001E5A,
+        0x1E5B00001E5C,
+        0x1E5D00001E5E,
+        0x1E5F00001E60,
+        0x1E6100001E62,
+        0x1E6300001E64,
+        0x1E6500001E66,
+        0x1E6700001E68,
+        0x1E6900001E6A,
+        0x1E6B00001E6C,
+        0x1E6D00001E6E,
+        0x1E6F00001E70,
+        0x1E7100001E72,
+        0x1E7300001E74,
+        0x1E7500001E76,
+        0x1E7700001E78,
+        0x1E7900001E7A,
+        0x1E7B00001E7C,
+        0x1E7D00001E7E,
+        0x1E7F00001E80,
+        0x1E8100001E82,
+        0x1E8300001E84,
+        0x1E8500001E86,
+        0x1E8700001E88,
+        0x1E8900001E8A,
+        0x1E8B00001E8C,
+        0x1E8D00001E8E,
+        0x1E8F00001E90,
+        0x1E9100001E92,
+        0x1E9300001E94,
+        0x1E9500001E9A,
+        0x1E9C00001E9E,
+        0x1E9F00001EA0,
+        0x1EA100001EA2,
+        0x1EA300001EA4,
+        0x1EA500001EA6,
+        0x1EA700001EA8,
+        0x1EA900001EAA,
+        0x1EAB00001EAC,
+        0x1EAD00001EAE,
+        0x1EAF00001EB0,
+        0x1EB100001EB2,
+        0x1EB300001EB4,
+        0x1EB500001EB6,
+        0x1EB700001EB8,
+        0x1EB900001EBA,
+        0x1EBB00001EBC,
+        0x1EBD00001EBE,
+        0x1EBF00001EC0,
+        0x1EC100001EC2,
+        0x1EC300001EC4,
+        0x1EC500001EC6,
+        0x1EC700001EC8,
+        0x1EC900001ECA,
+        0x1ECB00001ECC,
+        0x1ECD00001ECE,
+        0x1ECF00001ED0,
+        0x1ED100001ED2,
+        0x1ED300001ED4,
+        0x1ED500001ED6,
+        0x1ED700001ED8,
+        0x1ED900001EDA,
+        0x1EDB00001EDC,
+        0x1EDD00001EDE,
+        0x1EDF00001EE0,
+        0x1EE100001EE2,
+        0x1EE300001EE4,
+        0x1EE500001EE6,
+        0x1EE700001EE8,
+        0x1EE900001EEA,
+        0x1EEB00001EEC,
+        0x1EED00001EEE,
+        0x1EEF00001EF0,
+        0x1EF100001EF2,
+        0x1EF300001EF4,
+        0x1EF500001EF6,
+        0x1EF700001EF8,
+        0x1EF900001EFA,
+        0x1EFB00001EFC,
+        0x1EFD00001EFE,
+        0x1EFF00001F08,
+        0x1F1000001F16,
+        0x1F2000001F28,
+        0x1F3000001F38,
+        0x1F4000001F46,
+        0x1F5000001F58,
+        0x1F6000001F68,
+        0x1F7000001F71,
+        0x1F7200001F73,
+        0x1F7400001F75,
+        0x1F7600001F77,
+        0x1F7800001F79,
+        0x1F7A00001F7B,
+        0x1F7C00001F7D,
+        0x1FB000001FB2,
+        0x1FB600001FB7,
+        0x1FC600001FC7,
+        0x1FD000001FD3,
+        0x1FD600001FD8,
+        0x1FE000001FE3,
+        0x1FE400001FE8,
+        0x1FF600001FF7,
+        0x214E0000214F,
+        0x218400002185,
+        0x2C3000002C60,
+        0x2C6100002C62,
+        0x2C6500002C67,
+        0x2C6800002C69,
+        0x2C6A00002C6B,
+        0x2C6C00002C6D,
+        0x2C7100002C72,
+        0x2C7300002C75,
+        0x2C7600002C7C,
+        0x2C8100002C82,
+        0x2C8300002C84,
+        0x2C8500002C86,
+        0x2C8700002C88,
+        0x2C8900002C8A,
+        0x2C8B00002C8C,
+        0x2C8D00002C8E,
+        0x2C8F00002C90,
+        0x2C9100002C92,
+        0x2C9300002C94,
+        0x2C9500002C96,
+        0x2C9700002C98,
+        0x2C9900002C9A,
+        0x2C9B00002C9C,
+        0x2C9D00002C9E,
+        0x2C9F00002CA0,
+        0x2CA100002CA2,
+        0x2CA300002CA4,
+        0x2CA500002CA6,
+        0x2CA700002CA8,
+        0x2CA900002CAA,
+        0x2CAB00002CAC,
+        0x2CAD00002CAE,
+        0x2CAF00002CB0,
+        0x2CB100002CB2,
+        0x2CB300002CB4,
+        0x2CB500002CB6,
+        0x2CB700002CB8,
+        0x2CB900002CBA,
+        0x2CBB00002CBC,
+        0x2CBD00002CBE,
+        0x2CBF00002CC0,
+        0x2CC100002CC2,
+        0x2CC300002CC4,
+        0x2CC500002CC6,
+        0x2CC700002CC8,
+        0x2CC900002CCA,
+        0x2CCB00002CCC,
+        0x2CCD00002CCE,
+        0x2CCF00002CD0,
+        0x2CD100002CD2,
+        0x2CD300002CD4,
+        0x2CD500002CD6,
+        0x2CD700002CD8,
+        0x2CD900002CDA,
+        0x2CDB00002CDC,
+        0x2CDD00002CDE,
+        0x2CDF00002CE0,
+        0x2CE100002CE2,
+        0x2CE300002CE5,
+        0x2CEC00002CED,
+        0x2CEE00002CF2,
+        0x2CF300002CF4,
+        0x2D0000002D26,
+        0x2D2700002D28,
+        0x2D2D00002D2E,
+        0x2D3000002D68,
+        0x2D7F00002D97,
+        0x2DA000002DA7,
+        0x2DA800002DAF,
+        0x2DB000002DB7,
+        0x2DB800002DBF,
+        0x2DC000002DC7,
+        0x2DC800002DCF,
+        0x2DD000002DD7,
+        0x2DD800002DDF,
+        0x2DE000002E00,
+        0x2E2F00002E30,
+        0x300500003008,
+        0x302A0000302E,
+        0x303C0000303D,
+        0x304100003097,
+        0x30990000309B,
+        0x309D0000309F,
+        0x30A1000030FB,
+        0x30FC000030FF,
+        0x310500003130,
+        0x31A0000031C0,
+        0x31F000003200,
+        0x340000004DC0,
+        0x4E000000A48D,
+        0xA4D00000A4FE,
+        0xA5000000A60D,
+        0xA6100000A62C,
+        0xA6410000A642,
+        0xA6430000A644,
+        0xA6450000A646,
+        0xA6470000A648,
+        0xA6490000A64A,
+        0xA64B0000A64C,
+        0xA64D0000A64E,
+        0xA64F0000A650,
+        0xA6510000A652,
+        0xA6530000A654,
+        0xA6550000A656,
+        0xA6570000A658,
+        0xA6590000A65A,
+        0xA65B0000A65C,
+        0xA65D0000A65E,
+        0xA65F0000A660,
+        0xA6610000A662,
+        0xA6630000A664,
+        0xA6650000A666,
+        0xA6670000A668,
+        0xA6690000A66A,
+        0xA66B0000A66C,
+        0xA66D0000A670,
+        0xA6740000A67E,
+        0xA67F0000A680,
+        0xA6810000A682,
+        0xA6830000A684,
+        0xA6850000A686,
+        0xA6870000A688,
+        0xA6890000A68A,
+        0xA68B0000A68C,
+        0xA68D0000A68E,
+        0xA68F0000A690,
+        0xA6910000A692,
+        0xA6930000A694,
+        0xA6950000A696,
+        0xA6970000A698,
+        0xA6990000A69A,
+        0xA69B0000A69C,
+        0xA69E0000A6E6,
+        0xA6F00000A6F2,
+        0xA7170000A720,
+        0xA7230000A724,
+        0xA7250000A726,
+        0xA7270000A728,
+        0xA7290000A72A,
+        0xA72B0000A72C,
+        0xA72D0000A72E,
+        0xA72F0000A732,
+        0xA7330000A734,
+        0xA7350000A736,
+        0xA7370000A738,
+        0xA7390000A73A,
+        0xA73B0000A73C,
+        0xA73D0000A73E,
+        0xA73F0000A740,
+        0xA7410000A742,
+        0xA7430000A744,
+        0xA7450000A746,
+        0xA7470000A748,
+        0xA7490000A74A,
+        0xA74B0000A74C,
+        0xA74D0000A74E,
+        0xA74F0000A750,
+        0xA7510000A752,
+        0xA7530000A754,
+        0xA7550000A756,
+        0xA7570000A758,
+        0xA7590000A75A,
+        0xA75B0000A75C,
+        0xA75D0000A75E,
+        0xA75F0000A760,
+        0xA7610000A762,
+        0xA7630000A764,
+        0xA7650000A766,
+        0xA7670000A768,
+        0xA7690000A76A,
+        0xA76B0000A76C,
+        0xA76D0000A76E,
+        0xA76F0000A770,
+        0xA7710000A779,
+        0xA77A0000A77B,
+        0xA77C0000A77D,
+        0xA77F0000A780,
+        0xA7810000A782,
+        0xA7830000A784,
+        0xA7850000A786,
+        0xA7870000A789,
+        0xA78C0000A78D,
+        0xA78E0000A790,
+        0xA7910000A792,
+        0xA7930000A796,
+        0xA7970000A798,
+        0xA7990000A79A,
+        0xA79B0000A79C,
+        0xA79D0000A79E,
+        0xA79F0000A7A0,
+        0xA7A10000A7A2,
+        0xA7A30000A7A4,
+        0xA7A50000A7A6,
+        0xA7A70000A7A8,
+        0xA7A90000A7AA,
+        0xA7AF0000A7B0,
+        0xA7B50000A7B6,
+        0xA7B70000A7B8,
+        0xA7B90000A7BA,
+        0xA7BB0000A7BC,
+        0xA7BD0000A7BE,
+        0xA7BF0000A7C0,
+        0xA7C10000A7C2,
+        0xA7C30000A7C4,
+        0xA7C80000A7C9,
+        0xA7CA0000A7CB,
+        0xA7CD0000A7CE,
+        0xA7D10000A7D2,
+        0xA7D30000A7D4,
+        0xA7D50000A7D6,
+        0xA7D70000A7D8,
+        0xA7D90000A7DA,
+        0xA7DB0000A7DC,
+        0xA7F60000A7F8,
+        0xA7FA0000A828,
+        0xA82C0000A82D,
+        0xA8400000A874,
+        0xA8800000A8C6,
+        0xA8D00000A8DA,
+        0xA8E00000A8F8,
+        0xA8FB0000A8FC,
+        0xA8FD0000A92E,
+        0xA9300000A954,
+        0xA9800000A9C1,
+        0xA9CF0000A9DA,
+        0xA9E00000A9FF,
+        0xAA000000AA37,
+        0xAA400000AA4E,
+        0xAA500000AA5A,
+        0xAA600000AA77,
+        0xAA7A0000AAC3,
+        0xAADB0000AADE,
+        0xAAE00000AAF0,
+        0xAAF20000AAF7,
+        0xAB010000AB07,
+        0xAB090000AB0F,
+        0xAB110000AB17,
+        0xAB200000AB27,
+        0xAB280000AB2F,
+        0xAB300000AB5B,
+        0xAB600000AB69,
+        0xABC00000ABEB,
+        0xABEC0000ABEE,
+        0xABF00000ABFA,
+        0xAC000000D7A4,
+        0xFA0E0000FA10,
+        0xFA110000FA12,
+        0xFA130000FA15,
+        0xFA1F0000FA20,
+        0xFA210000FA22,
+        0xFA230000FA25,
+        0xFA270000FA2A,
+        0xFB1E0000FB1F,
+        0xFE200000FE30,
+        0xFE730000FE74,
+        0x100000001000C,
+        0x1000D00010027,
+        0x100280001003B,
+        0x1003C0001003E,
+        0x1003F0001004E,
+        0x100500001005E,
+        0x10080000100FB,
+        0x101FD000101FE,
+        0x102800001029D,
+        0x102A0000102D1,
+        0x102E0000102E1,
+        0x1030000010320,
+        0x1032D00010341,
+        0x103420001034A,
+        0x103500001037B,
+        0x103800001039E,
+        0x103A0000103C4,
+        0x103C8000103D0,
+        0x104280001049E,
+        0x104A0000104AA,
+        0x104D8000104FC,
+        0x1050000010528,
+        0x1053000010564,
+        0x10597000105A2,
+        0x105A3000105B2,
+        0x105B3000105BA,
+        0x105BB000105BD,
+        0x105C0000105F4,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1078000010781,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080A00010836,
+        0x1083700010839,
+        0x1083C0001083D,
+        0x1083F00010856,
+        0x1086000010877,
+        0x108800001089F,
+        0x108E0000108F3,
+        0x108F4000108F6,
+        0x1090000010916,
+        0x109200001093A,
+        0x10980000109B8,
+        0x109BE000109C0,
+        0x10A0000010A04,
+        0x10A0500010A07,
+        0x10A0C00010A14,
+        0x10A1500010A18,
+        0x10A1900010A36,
+        0x10A3800010A3B,
+        0x10A3F00010A40,
+        0x10A6000010A7D,
+        0x10A8000010A9D,
+        0x10AC000010AC8,
+        0x10AC900010AE7,
+        0x10B0000010B36,
+        0x10B4000010B56,
+        0x10B6000010B73,
+        0x10B8000010B92,
+        0x10C0000010C49,
+        0x10CC000010CF3,
+        0x10D0000010D28,
+        0x10D3000010D3A,
+        0x10D4000010D50,
+        0x10D6900010D6E,
+        0x10D6F00010D86,
+        0x10E8000010EAA,
+        0x10EAB00010EAD,
+        0x10EB000010EB2,
+        0x10EC200010EC5,
+        0x10EFC00010F1D,
+        0x10F2700010F28,
+        0x10F3000010F51,
+        0x10F7000010F86,
+        0x10FB000010FC5,
+        0x10FE000010FF7,
+        0x1100000011047,
+        0x1106600011076,
+        0x1107F000110BB,
+        0x110C2000110C3,
+        0x110D0000110E9,
+        0x110F0000110FA,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111C5,
+        0x111C9000111CD,
+        0x111CE000111DB,
+        0x111DC000111DD,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123E00011242,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128A0001128E,
+        0x1128F0001129E,
+        0x1129F000112A9,
+        0x112B0000112EB,
+        0x112F0000112FA,
+        0x1130000011304,
+        0x113050001130D,
+        0x1130F00011311,
+        0x1131300011329,
+        0x1132A00011331,
+        0x1133200011334,
+        0x113350001133A,
+        0x1133B00011345,
+        0x1134700011349,
+        0x1134B0001134E,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135D00011364,
+        0x113660001136D,
+        0x1137000011375,
+        0x113800001138A,
+        0x1138B0001138C,
+        0x1138E0001138F,
+        0x11390000113B6,
+        0x113B7000113C1,
+        0x113C2000113C3,
+        0x113C5000113C6,
+        0x113C7000113CB,
+        0x113CC000113D4,
+        0x113E1000113E3,
+        0x114000001144B,
+        0x114500001145A,
+        0x1145E00011462,
+        0x11480000114C6,
+        0x114C7000114C8,
+        0x114D0000114DA,
+        0x11580000115B6,
+        0x115B8000115C1,
+        0x115D8000115DE,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165A,
+        0x11680000116B9,
+        0x116C0000116CA,
+        0x116D0000116E4,
+        0x117000001171B,
+        0x1171D0001172C,
+        0x117300001173A,
+        0x1174000011747,
+        0x118000001183B,
+        0x118C0000118EA,
+        0x118FF00011907,
+        0x119090001190A,
+        0x1190C00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193B00011944,
+        0x119500001195A,
+        0x119A0000119A8,
+        0x119AA000119D8,
+        0x119DA000119E2,
+        0x119E3000119E5,
+        0x11A0000011A3F,
+        0x11A4700011A48,
+        0x11A5000011A9A,
+        0x11A9D00011A9E,
+        0x11AB000011AF9,
+        0x11BC000011BE1,
+        0x11BF000011BFA,
+        0x11C0000011C09,
+        0x11C0A00011C37,
+        0x11C3800011C41,
+        0x11C5000011C5A,
+        0x11C7200011C90,
+        0x11C9200011CA8,
+        0x11CA900011CB7,
+        0x11D0000011D07,
+        0x11D0800011D0A,
+        0x11D0B00011D37,
+        0x11D3A00011D3B,
+        0x11D3C00011D3E,
+        0x11D3F00011D48,
+        0x11D5000011D5A,
+        0x11D6000011D66,
+        0x11D6700011D69,
+        0x11D6A00011D8F,
+        0x11D9000011D92,
+        0x11D9300011D99,
+        0x11DA000011DAA,
+        0x11EE000011EF7,
+        0x11F0000011F11,
+        0x11F1200011F3B,
+        0x11F3E00011F43,
+        0x11F5000011F5B,
+        0x11FB000011FB1,
+        0x120000001239A,
+        0x1248000012544,
+        0x12F9000012FF1,
+        0x1300000013430,
+        0x1344000013456,
+        0x13460000143FB,
+        0x1440000014647,
+        0x161000001613A,
+        0x1680000016A39,
+        0x16A4000016A5F,
+        0x16A6000016A6A,
+        0x16A7000016ABF,
+        0x16AC000016ACA,
+        0x16AD000016AEE,
+        0x16AF000016AF5,
+        0x16B0000016B37,
+        0x16B4000016B44,
+        0x16B5000016B5A,
+        0x16B6300016B78,
+        0x16B7D00016B90,
+        0x16D4000016D6D,
+        0x16D7000016D7A,
+        0x16E6000016E80,
+        0x16F0000016F4B,
+        0x16F4F00016F88,
+        0x16F8F00016FA0,
+        0x16FE000016FE2,
+        0x16FE300016FE5,
+        0x16FF000016FF2,
+        0x17000000187F8,
+        0x1880000018CD6,
+        0x18CFF00018D09,
+        0x1AFF00001AFF4,
+        0x1AFF50001AFFC,
+        0x1AFFD0001AFFF,
+        0x1B0000001B123,
+        0x1B1320001B133,
+        0x1B1500001B153,
+        0x1B1550001B156,
+        0x1B1640001B168,
+        0x1B1700001B2FC,
+        0x1BC000001BC6B,
+        0x1BC700001BC7D,
+        0x1BC800001BC89,
+        0x1BC900001BC9A,
+        0x1BC9D0001BC9F,
+        0x1CCF00001CCFA,
+        0x1CF000001CF2E,
+        0x1CF300001CF47,
+        0x1DA000001DA37,
+        0x1DA3B0001DA6D,
+        0x1DA750001DA76,
+        0x1DA840001DA85,
+        0x1DA9B0001DAA0,
+        0x1DAA10001DAB0,
+        0x1DF000001DF1F,
+        0x1DF250001DF2B,
+        0x1E0000001E007,
+        0x1E0080001E019,
+        0x1E01B0001E022,
+        0x1E0230001E025,
+        0x1E0260001E02B,
+        0x1E08F0001E090,
+        0x1E1000001E12D,
+        0x1E1300001E13E,
+        0x1E1400001E14A,
+        0x1E14E0001E14F,
+        0x1E2900001E2AF,
+        0x1E2C00001E2FA,
+        0x1E4D00001E4FA,
+        0x1E5D00001E5FB,
+        0x1E7E00001E7E7,
+        0x1E7E80001E7EC,
+        0x1E7ED0001E7EF,
+        0x1E7F00001E7FF,
+        0x1E8000001E8C5,
+        0x1E8D00001E8D7,
+        0x1E9220001E94C,
+        0x1E9500001E95A,
+        0x200000002A6E0,
+        0x2A7000002B73A,
+        0x2B7400002B81E,
+        0x2B8200002CEA2,
+        0x2CEB00002EBE1,
+        0x2EBF00002EE5E,
+        0x300000003134B,
+        0x31350000323B0,
+    ),
+    "CONTEXTJ": (0x200C0000200E,),
+    "CONTEXTO": (
+        0xB7000000B8,
+        0x37500000376,
+        0x5F3000005F5,
+        0x6600000066A,
+        0x6F0000006FA,
+        0x30FB000030FC,
+    ),
+}
diff --git a/.venv/lib/python3.10/site-packages/idna/intranges.py b/.venv/lib/python3.10/site-packages/idna/intranges.py
new file mode 100644
index 0000000..7bfaa8d
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/intranges.py
@@ -0,0 +1,57 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+from typing import List, Tuple
+
+
+def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i + 1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i + 1] - 1:
+                continue
+        current_range = sorted_list[last_write + 1 : i + 1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+
+def _encode_range(start: int, end: int) -> int:
+    return (start << 32) | end
+
+
+def _decode_range(r: int) -> Tuple[int, int]:
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_: int, ranges: Tuple[int, ...]) -> bool:
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos - 1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False
diff --git a/.venv/lib/python3.10/site-packages/idna/package_data.py b/.venv/lib/python3.10/site-packages/idna/package_data.py
new file mode 100644
index 0000000..7272c8d
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/package_data.py
@@ -0,0 +1 @@
+__version__ = "3.11"
diff --git a/.venv/lib/python3.10/site-packages/idna/py.typed b/.venv/lib/python3.10/site-packages/idna/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/.venv/lib/python3.10/site-packages/idna/uts46data.py b/.venv/lib/python3.10/site-packages/idna/uts46data.py
new file mode 100644
index 0000000..4610b71
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/idna/uts46data.py
@@ -0,0 +1,8841 @@
+# This file is automatically generated by tools/idna-data
+# vim: set fileencoding=utf-8 :
+
+from typing import List, Tuple, Union
+
+"""IDNA Mapping Table from UTS46."""
+
+
+__version__ = "16.0.0"
+
+
+def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x0, "V"),
+        (0x1, "V"),
+        (0x2, "V"),
+        (0x3, "V"),
+        (0x4, "V"),
+        (0x5, "V"),
+        (0x6, "V"),
+        (0x7, "V"),
+        (0x8, "V"),
+        (0x9, "V"),
+        (0xA, "V"),
+        (0xB, "V"),
+        (0xC, "V"),
+        (0xD, "V"),
+        (0xE, "V"),
+        (0xF, "V"),
+        (0x10, "V"),
+        (0x11, "V"),
+        (0x12, "V"),
+        (0x13, "V"),
+        (0x14, "V"),
+        (0x15, "V"),
+        (0x16, "V"),
+        (0x17, "V"),
+        (0x18, "V"),
+        (0x19, "V"),
+        (0x1A, "V"),
+        (0x1B, "V"),
+        (0x1C, "V"),
+        (0x1D, "V"),
+        (0x1E, "V"),
+        (0x1F, "V"),
+        (0x20, "V"),
+        (0x21, "V"),
+        (0x22, "V"),
+        (0x23, "V"),
+        (0x24, "V"),
+        (0x25, "V"),
+        (0x26, "V"),
+        (0x27, "V"),
+        (0x28, "V"),
+        (0x29, "V"),
+        (0x2A, "V"),
+        (0x2B, "V"),
+        (0x2C, "V"),
+        (0x2D, "V"),
+        (0x2E, "V"),
+        (0x2F, "V"),
+        (0x30, "V"),
+        (0x31, "V"),
+        (0x32, "V"),
+        (0x33, "V"),
+        (0x34, "V"),
+        (0x35, "V"),
+        (0x36, "V"),
+        (0x37, "V"),
+        (0x38, "V"),
+        (0x39, "V"),
+        (0x3A, "V"),
+        (0x3B, "V"),
+        (0x3C, "V"),
+        (0x3D, "V"),
+        (0x3E, "V"),
+        (0x3F, "V"),
+        (0x40, "V"),
+        (0x41, "M", "a"),
+        (0x42, "M", "b"),
+        (0x43, "M", "c"),
+        (0x44, "M", "d"),
+        (0x45, "M", "e"),
+        (0x46, "M", "f"),
+        (0x47, "M", "g"),
+        (0x48, "M", "h"),
+        (0x49, "M", "i"),
+        (0x4A, "M", "j"),
+        (0x4B, "M", "k"),
+        (0x4C, "M", "l"),
+        (0x4D, "M", "m"),
+        (0x4E, "M", "n"),
+        (0x4F, "M", "o"),
+        (0x50, "M", "p"),
+        (0x51, "M", "q"),
+        (0x52, "M", "r"),
+        (0x53, "M", "s"),
+        (0x54, "M", "t"),
+        (0x55, "M", "u"),
+        (0x56, "M", "v"),
+        (0x57, "M", "w"),
+        (0x58, "M", "x"),
+        (0x59, "M", "y"),
+        (0x5A, "M", "z"),
+        (0x5B, "V"),
+        (0x5C, "V"),
+        (0x5D, "V"),
+        (0x5E, "V"),
+        (0x5F, "V"),
+        (0x60, "V"),
+        (0x61, "V"),
+        (0x62, "V"),
+        (0x63, "V"),
+    ]
+
+
+def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x64, "V"),
+        (0x65, "V"),
+        (0x66, "V"),
+        (0x67, "V"),
+        (0x68, "V"),
+        (0x69, "V"),
+        (0x6A, "V"),
+        (0x6B, "V"),
+        (0x6C, "V"),
+        (0x6D, "V"),
+        (0x6E, "V"),
+        (0x6F, "V"),
+        (0x70, "V"),
+        (0x71, "V"),
+        (0x72, "V"),
+        (0x73, "V"),
+        (0x74, "V"),
+        (0x75, "V"),
+        (0x76, "V"),
+        (0x77, "V"),
+        (0x78, "V"),
+        (0x79, "V"),
+        (0x7A, "V"),
+        (0x7B, "V"),
+        (0x7C, "V"),
+        (0x7D, "V"),
+        (0x7E, "V"),
+        (0x7F, "V"),
+        (0x80, "X"),
+        (0x81, "X"),
+        (0x82, "X"),
+        (0x83, "X"),
+        (0x84, "X"),
+        (0x85, "X"),
+        (0x86, "X"),
+        (0x87, "X"),
+        (0x88, "X"),
+        (0x89, "X"),
+        (0x8A, "X"),
+        (0x8B, "X"),
+        (0x8C, "X"),
+        (0x8D, "X"),
+        (0x8E, "X"),
+        (0x8F, "X"),
+        (0x90, "X"),
+        (0x91, "X"),
+        (0x92, "X"),
+        (0x93, "X"),
+        (0x94, "X"),
+        (0x95, "X"),
+        (0x96, "X"),
+        (0x97, "X"),
+        (0x98, "X"),
+        (0x99, "X"),
+        (0x9A, "X"),
+        (0x9B, "X"),
+        (0x9C, "X"),
+        (0x9D, "X"),
+        (0x9E, "X"),
+        (0x9F, "X"),
+        (0xA0, "M", " "),
+        (0xA1, "V"),
+        (0xA2, "V"),
+        (0xA3, "V"),
+        (0xA4, "V"),
+        (0xA5, "V"),
+        (0xA6, "V"),
+        (0xA7, "V"),
+        (0xA8, "M", " ̈"),
+        (0xA9, "V"),
+        (0xAA, "M", "a"),
+        (0xAB, "V"),
+        (0xAC, "V"),
+        (0xAD, "I"),
+        (0xAE, "V"),
+        (0xAF, "M", " ̄"),
+        (0xB0, "V"),
+        (0xB1, "V"),
+        (0xB2, "M", "2"),
+        (0xB3, "M", "3"),
+        (0xB4, "M", " ́"),
+        (0xB5, "M", "μ"),
+        (0xB6, "V"),
+        (0xB7, "V"),
+        (0xB8, "M", " ̧"),
+        (0xB9, "M", "1"),
+        (0xBA, "M", "o"),
+        (0xBB, "V"),
+        (0xBC, "M", "1⁄4"),
+        (0xBD, "M", "1⁄2"),
+        (0xBE, "M", "3⁄4"),
+        (0xBF, "V"),
+        (0xC0, "M", "à"),
+        (0xC1, "M", "á"),
+        (0xC2, "M", "â"),
+        (0xC3, "M", "ã"),
+        (0xC4, "M", "ä"),
+        (0xC5, "M", "å"),
+        (0xC6, "M", "æ"),
+        (0xC7, "M", "ç"),
+    ]
+
+
+def _seg_2() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xC8, "M", "è"),
+        (0xC9, "M", "é"),
+        (0xCA, "M", "ê"),
+        (0xCB, "M", "ë"),
+        (0xCC, "M", "ì"),
+        (0xCD, "M", "í"),
+        (0xCE, "M", "î"),
+        (0xCF, "M", "ï"),
+        (0xD0, "M", "ð"),
+        (0xD1, "M", "ñ"),
+        (0xD2, "M", "ò"),
+        (0xD3, "M", "ó"),
+        (0xD4, "M", "ô"),
+        (0xD5, "M", "õ"),
+        (0xD6, "M", "ö"),
+        (0xD7, "V"),
+        (0xD8, "M", "ø"),
+        (0xD9, "M", "ù"),
+        (0xDA, "M", "ú"),
+        (0xDB, "M", "û"),
+        (0xDC, "M", "ü"),
+        (0xDD, "M", "ý"),
+        (0xDE, "M", "þ"),
+        (0xDF, "D", "ss"),
+        (0xE0, "V"),
+        (0xE1, "V"),
+        (0xE2, "V"),
+        (0xE3, "V"),
+        (0xE4, "V"),
+        (0xE5, "V"),
+        (0xE6, "V"),
+        (0xE7, "V"),
+        (0xE8, "V"),
+        (0xE9, "V"),
+        (0xEA, "V"),
+        (0xEB, "V"),
+        (0xEC, "V"),
+        (0xED, "V"),
+        (0xEE, "V"),
+        (0xEF, "V"),
+        (0xF0, "V"),
+        (0xF1, "V"),
+        (0xF2, "V"),
+        (0xF3, "V"),
+        (0xF4, "V"),
+        (0xF5, "V"),
+        (0xF6, "V"),
+        (0xF7, "V"),
+        (0xF8, "V"),
+        (0xF9, "V"),
+        (0xFA, "V"),
+        (0xFB, "V"),
+        (0xFC, "V"),
+        (0xFD, "V"),
+        (0xFE, "V"),
+        (0xFF, "V"),
+        (0x100, "M", "ā"),
+        (0x101, "V"),
+        (0x102, "M", "ă"),
+        (0x103, "V"),
+        (0x104, "M", "ą"),
+        (0x105, "V"),
+        (0x106, "M", "ć"),
+        (0x107, "V"),
+        (0x108, "M", "ĉ"),
+        (0x109, "V"),
+        (0x10A, "M", "ċ"),
+        (0x10B, "V"),
+        (0x10C, "M", "č"),
+        (0x10D, "V"),
+        (0x10E, "M", "ď"),
+        (0x10F, "V"),
+        (0x110, "M", "đ"),
+        (0x111, "V"),
+        (0x112, "M", "ē"),
+        (0x113, "V"),
+        (0x114, "M", "ĕ"),
+        (0x115, "V"),
+        (0x116, "M", "ė"),
+        (0x117, "V"),
+        (0x118, "M", "ę"),
+        (0x119, "V"),
+        (0x11A, "M", "ě"),
+        (0x11B, "V"),
+        (0x11C, "M", "ĝ"),
+        (0x11D, "V"),
+        (0x11E, "M", "ğ"),
+        (0x11F, "V"),
+        (0x120, "M", "ġ"),
+        (0x121, "V"),
+        (0x122, "M", "ģ"),
+        (0x123, "V"),
+        (0x124, "M", "ĥ"),
+        (0x125, "V"),
+        (0x126, "M", "ħ"),
+        (0x127, "V"),
+        (0x128, "M", "ĩ"),
+        (0x129, "V"),
+        (0x12A, "M", "ī"),
+        (0x12B, "V"),
+    ]
+
+
+def _seg_3() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x12C, "M", "ĭ"),
+        (0x12D, "V"),
+        (0x12E, "M", "į"),
+        (0x12F, "V"),
+        (0x130, "M", "i̇"),
+        (0x131, "V"),
+        (0x132, "M", "ij"),
+        (0x134, "M", "ĵ"),
+        (0x135, "V"),
+        (0x136, "M", "ķ"),
+        (0x137, "V"),
+        (0x139, "M", "ĺ"),
+        (0x13A, "V"),
+        (0x13B, "M", "ļ"),
+        (0x13C, "V"),
+        (0x13D, "M", "ľ"),
+        (0x13E, "V"),
+        (0x13F, "M", "l·"),
+        (0x141, "M", "ł"),
+        (0x142, "V"),
+        (0x143, "M", "ń"),
+        (0x144, "V"),
+        (0x145, "M", "ņ"),
+        (0x146, "V"),
+        (0x147, "M", "ň"),
+        (0x148, "V"),
+        (0x149, "M", "ʼn"),
+        (0x14A, "M", "ŋ"),
+        (0x14B, "V"),
+        (0x14C, "M", "ō"),
+        (0x14D, "V"),
+        (0x14E, "M", "ŏ"),
+        (0x14F, "V"),
+        (0x150, "M", "ő"),
+        (0x151, "V"),
+        (0x152, "M", "œ"),
+        (0x153, "V"),
+        (0x154, "M", "ŕ"),
+        (0x155, "V"),
+        (0x156, "M", "ŗ"),
+        (0x157, "V"),
+        (0x158, "M", "ř"),
+        (0x159, "V"),
+        (0x15A, "M", "ś"),
+        (0x15B, "V"),
+        (0x15C, "M", "ŝ"),
+        (0x15D, "V"),
+        (0x15E, "M", "ş"),
+        (0x15F, "V"),
+        (0x160, "M", "š"),
+        (0x161, "V"),
+        (0x162, "M", "ţ"),
+        (0x163, "V"),
+        (0x164, "M", "ť"),
+        (0x165, "V"),
+        (0x166, "M", "ŧ"),
+        (0x167, "V"),
+        (0x168, "M", "ũ"),
+        (0x169, "V"),
+        (0x16A, "M", "ū"),
+        (0x16B, "V"),
+        (0x16C, "M", "ŭ"),
+        (0x16D, "V"),
+        (0x16E, "M", "ů"),
+        (0x16F, "V"),
+        (0x170, "M", "ű"),
+        (0x171, "V"),
+        (0x172, "M", "ų"),
+        (0x173, "V"),
+        (0x174, "M", "ŵ"),
+        (0x175, "V"),
+        (0x176, "M", "ŷ"),
+        (0x177, "V"),
+        (0x178, "M", "ÿ"),
+        (0x179, "M", "ź"),
+        (0x17A, "V"),
+        (0x17B, "M", "ż"),
+        (0x17C, "V"),
+        (0x17D, "M", "ž"),
+        (0x17E, "V"),
+        (0x17F, "M", "s"),
+        (0x180, "V"),
+        (0x181, "M", "ɓ"),
+        (0x182, "M", "ƃ"),
+        (0x183, "V"),
+        (0x184, "M", "ƅ"),
+        (0x185, "V"),
+        (0x186, "M", "ɔ"),
+        (0x187, "M", "ƈ"),
+        (0x188, "V"),
+        (0x189, "M", "ɖ"),
+        (0x18A, "M", "ɗ"),
+        (0x18B, "M", "ƌ"),
+        (0x18C, "V"),
+        (0x18E, "M", "ǝ"),
+        (0x18F, "M", "ə"),
+        (0x190, "M", "ɛ"),
+        (0x191, "M", "ƒ"),
+        (0x192, "V"),
+        (0x193, "M", "ɠ"),
+    ]
+
+
+def _seg_4() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x194, "M", "ɣ"),
+        (0x195, "V"),
+        (0x196, "M", "ɩ"),
+        (0x197, "M", "ɨ"),
+        (0x198, "M", "ƙ"),
+        (0x199, "V"),
+        (0x19C, "M", "ɯ"),
+        (0x19D, "M", "ɲ"),
+        (0x19E, "V"),
+        (0x19F, "M", "ɵ"),
+        (0x1A0, "M", "ơ"),
+        (0x1A1, "V"),
+        (0x1A2, "M", "ƣ"),
+        (0x1A3, "V"),
+        (0x1A4, "M", "ƥ"),
+        (0x1A5, "V"),
+        (0x1A6, "M", "ʀ"),
+        (0x1A7, "M", "ƨ"),
+        (0x1A8, "V"),
+        (0x1A9, "M", "ʃ"),
+        (0x1AA, "V"),
+        (0x1AC, "M", "ƭ"),
+        (0x1AD, "V"),
+        (0x1AE, "M", "ʈ"),
+        (0x1AF, "M", "ư"),
+        (0x1B0, "V"),
+        (0x1B1, "M", "ʊ"),
+        (0x1B2, "M", "ʋ"),
+        (0x1B3, "M", "ƴ"),
+        (0x1B4, "V"),
+        (0x1B5, "M", "ƶ"),
+        (0x1B6, "V"),
+        (0x1B7, "M", "ʒ"),
+        (0x1B8, "M", "ƹ"),
+        (0x1B9, "V"),
+        (0x1BC, "M", "ƽ"),
+        (0x1BD, "V"),
+        (0x1C4, "M", "dž"),
+        (0x1C7, "M", "lj"),
+        (0x1CA, "M", "nj"),
+        (0x1CD, "M", "ǎ"),
+        (0x1CE, "V"),
+        (0x1CF, "M", "ǐ"),
+        (0x1D0, "V"),
+        (0x1D1, "M", "ǒ"),
+        (0x1D2, "V"),
+        (0x1D3, "M", "ǔ"),
+        (0x1D4, "V"),
+        (0x1D5, "M", "ǖ"),
+        (0x1D6, "V"),
+        (0x1D7, "M", "ǘ"),
+        (0x1D8, "V"),
+        (0x1D9, "M", "ǚ"),
+        (0x1DA, "V"),
+        (0x1DB, "M", "ǜ"),
+        (0x1DC, "V"),
+        (0x1DE, "M", "ǟ"),
+        (0x1DF, "V"),
+        (0x1E0, "M", "ǡ"),
+        (0x1E1, "V"),
+        (0x1E2, "M", "ǣ"),
+        (0x1E3, "V"),
+        (0x1E4, "M", "ǥ"),
+        (0x1E5, "V"),
+        (0x1E6, "M", "ǧ"),
+        (0x1E7, "V"),
+        (0x1E8, "M", "ǩ"),
+        (0x1E9, "V"),
+        (0x1EA, "M", "ǫ"),
+        (0x1EB, "V"),
+        (0x1EC, "M", "ǭ"),
+        (0x1ED, "V"),
+        (0x1EE, "M", "ǯ"),
+        (0x1EF, "V"),
+        (0x1F1, "M", "dz"),
+        (0x1F4, "M", "ǵ"),
+        (0x1F5, "V"),
+        (0x1F6, "M", "ƕ"),
+        (0x1F7, "M", "ƿ"),
+        (0x1F8, "M", "ǹ"),
+        (0x1F9, "V"),
+        (0x1FA, "M", "ǻ"),
+        (0x1FB, "V"),
+        (0x1FC, "M", "ǽ"),
+        (0x1FD, "V"),
+        (0x1FE, "M", "ǿ"),
+        (0x1FF, "V"),
+        (0x200, "M", "ȁ"),
+        (0x201, "V"),
+        (0x202, "M", "ȃ"),
+        (0x203, "V"),
+        (0x204, "M", "ȅ"),
+        (0x205, "V"),
+        (0x206, "M", "ȇ"),
+        (0x207, "V"),
+        (0x208, "M", "ȉ"),
+        (0x209, "V"),
+        (0x20A, "M", "ȋ"),
+        (0x20B, "V"),
+        (0x20C, "M", "ȍ"),
+    ]
+
+
+def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x20D, "V"),
+        (0x20E, "M", "ȏ"),
+        (0x20F, "V"),
+        (0x210, "M", "ȑ"),
+        (0x211, "V"),
+        (0x212, "M", "ȓ"),
+        (0x213, "V"),
+        (0x214, "M", "ȕ"),
+        (0x215, "V"),
+        (0x216, "M", "ȗ"),
+        (0x217, "V"),
+        (0x218, "M", "ș"),
+        (0x219, "V"),
+        (0x21A, "M", "ț"),
+        (0x21B, "V"),
+        (0x21C, "M", "ȝ"),
+        (0x21D, "V"),
+        (0x21E, "M", "ȟ"),
+        (0x21F, "V"),
+        (0x220, "M", "ƞ"),
+        (0x221, "V"),
+        (0x222, "M", "ȣ"),
+        (0x223, "V"),
+        (0x224, "M", "ȥ"),
+        (0x225, "V"),
+        (0x226, "M", "ȧ"),
+        (0x227, "V"),
+        (0x228, "M", "ȩ"),
+        (0x229, "V"),
+        (0x22A, "M", "ȫ"),
+        (0x22B, "V"),
+        (0x22C, "M", "ȭ"),
+        (0x22D, "V"),
+        (0x22E, "M", "ȯ"),
+        (0x22F, "V"),
+        (0x230, "M", "ȱ"),
+        (0x231, "V"),
+        (0x232, "M", "ȳ"),
+        (0x233, "V"),
+        (0x23A, "M", "ⱥ"),
+        (0x23B, "M", "ȼ"),
+        (0x23C, "V"),
+        (0x23D, "M", "ƚ"),
+        (0x23E, "M", "ⱦ"),
+        (0x23F, "V"),
+        (0x241, "M", "ɂ"),
+        (0x242, "V"),
+        (0x243, "M", "ƀ"),
+        (0x244, "M", "ʉ"),
+        (0x245, "M", "ʌ"),
+        (0x246, "M", "ɇ"),
+        (0x247, "V"),
+        (0x248, "M", "ɉ"),
+        (0x249, "V"),
+        (0x24A, "M", "ɋ"),
+        (0x24B, "V"),
+        (0x24C, "M", "ɍ"),
+        (0x24D, "V"),
+        (0x24E, "M", "ɏ"),
+        (0x24F, "V"),
+        (0x2B0, "M", "h"),
+        (0x2B1, "M", "ɦ"),
+        (0x2B2, "M", "j"),
+        (0x2B3, "M", "r"),
+        (0x2B4, "M", "ɹ"),
+        (0x2B5, "M", "ɻ"),
+        (0x2B6, "M", "ʁ"),
+        (0x2B7, "M", "w"),
+        (0x2B8, "M", "y"),
+        (0x2B9, "V"),
+        (0x2D8, "M", " ̆"),
+        (0x2D9, "M", " ̇"),
+        (0x2DA, "M", " ̊"),
+        (0x2DB, "M", " ̨"),
+        (0x2DC, "M", " ̃"),
+        (0x2DD, "M", " ̋"),
+        (0x2DE, "V"),
+        (0x2E0, "M", "ɣ"),
+        (0x2E1, "M", "l"),
+        (0x2E2, "M", "s"),
+        (0x2E3, "M", "x"),
+        (0x2E4, "M", "ʕ"),
+        (0x2E5, "V"),
+        (0x340, "M", "̀"),
+        (0x341, "M", "́"),
+        (0x342, "V"),
+        (0x343, "M", "̓"),
+        (0x344, "M", "̈́"),
+        (0x345, "M", "ι"),
+        (0x346, "V"),
+        (0x34F, "I"),
+        (0x350, "V"),
+        (0x370, "M", "ͱ"),
+        (0x371, "V"),
+        (0x372, "M", "ͳ"),
+        (0x373, "V"),
+        (0x374, "M", "ʹ"),
+        (0x375, "V"),
+        (0x376, "M", "ͷ"),
+        (0x377, "V"),
+    ]
+
+
+def _seg_6() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x378, "X"),
+        (0x37A, "M", " ι"),
+        (0x37B, "V"),
+        (0x37E, "M", ";"),
+        (0x37F, "M", "ϳ"),
+        (0x380, "X"),
+        (0x384, "M", " ́"),
+        (0x385, "M", " ̈́"),
+        (0x386, "M", "ά"),
+        (0x387, "M", "·"),
+        (0x388, "M", "έ"),
+        (0x389, "M", "ή"),
+        (0x38A, "M", "ί"),
+        (0x38B, "X"),
+        (0x38C, "M", "ό"),
+        (0x38D, "X"),
+        (0x38E, "M", "ύ"),
+        (0x38F, "M", "ώ"),
+        (0x390, "V"),
+        (0x391, "M", "α"),
+        (0x392, "M", "β"),
+        (0x393, "M", "γ"),
+        (0x394, "M", "δ"),
+        (0x395, "M", "ε"),
+        (0x396, "M", "ζ"),
+        (0x397, "M", "η"),
+        (0x398, "M", "θ"),
+        (0x399, "M", "ι"),
+        (0x39A, "M", "κ"),
+        (0x39B, "M", "λ"),
+        (0x39C, "M", "μ"),
+        (0x39D, "M", "ν"),
+        (0x39E, "M", "ξ"),
+        (0x39F, "M", "ο"),
+        (0x3A0, "M", "π"),
+        (0x3A1, "M", "ρ"),
+        (0x3A2, "X"),
+        (0x3A3, "M", "σ"),
+        (0x3A4, "M", "τ"),
+        (0x3A5, "M", "υ"),
+        (0x3A6, "M", "φ"),
+        (0x3A7, "M", "χ"),
+        (0x3A8, "M", "ψ"),
+        (0x3A9, "M", "ω"),
+        (0x3AA, "M", "ϊ"),
+        (0x3AB, "M", "ϋ"),
+        (0x3AC, "V"),
+        (0x3C2, "D", "σ"),
+        (0x3C3, "V"),
+        (0x3CF, "M", "ϗ"),
+        (0x3D0, "M", "β"),
+        (0x3D1, "M", "θ"),
+        (0x3D2, "M", "υ"),
+        (0x3D3, "M", "ύ"),
+        (0x3D4, "M", "ϋ"),
+        (0x3D5, "M", "φ"),
+        (0x3D6, "M", "π"),
+        (0x3D7, "V"),
+        (0x3D8, "M", "ϙ"),
+        (0x3D9, "V"),
+        (0x3DA, "M", "ϛ"),
+        (0x3DB, "V"),
+        (0x3DC, "M", "ϝ"),
+        (0x3DD, "V"),
+        (0x3DE, "M", "ϟ"),
+        (0x3DF, "V"),
+        (0x3E0, "M", "ϡ"),
+        (0x3E1, "V"),
+        (0x3E2, "M", "ϣ"),
+        (0x3E3, "V"),
+        (0x3E4, "M", "ϥ"),
+        (0x3E5, "V"),
+        (0x3E6, "M", "ϧ"),
+        (0x3E7, "V"),
+        (0x3E8, "M", "ϩ"),
+        (0x3E9, "V"),
+        (0x3EA, "M", "ϫ"),
+        (0x3EB, "V"),
+        (0x3EC, "M", "ϭ"),
+        (0x3ED, "V"),
+        (0x3EE, "M", "ϯ"),
+        (0x3EF, "V"),
+        (0x3F0, "M", "κ"),
+        (0x3F1, "M", "ρ"),
+        (0x3F2, "M", "σ"),
+        (0x3F3, "V"),
+        (0x3F4, "M", "θ"),
+        (0x3F5, "M", "ε"),
+        (0x3F6, "V"),
+        (0x3F7, "M", "ϸ"),
+        (0x3F8, "V"),
+        (0x3F9, "M", "σ"),
+        (0x3FA, "M", "ϻ"),
+        (0x3FB, "V"),
+        (0x3FD, "M", "ͻ"),
+        (0x3FE, "M", "ͼ"),
+        (0x3FF, "M", "ͽ"),
+        (0x400, "M", "ѐ"),
+        (0x401, "M", "ё"),
+        (0x402, "M", "ђ"),
+    ]
+
+
+def _seg_7() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x403, "M", "ѓ"),
+        (0x404, "M", "є"),
+        (0x405, "M", "ѕ"),
+        (0x406, "M", "і"),
+        (0x407, "M", "ї"),
+        (0x408, "M", "ј"),
+        (0x409, "M", "љ"),
+        (0x40A, "M", "њ"),
+        (0x40B, "M", "ћ"),
+        (0x40C, "M", "ќ"),
+        (0x40D, "M", "ѝ"),
+        (0x40E, "M", "ў"),
+        (0x40F, "M", "џ"),
+        (0x410, "M", "а"),
+        (0x411, "M", "б"),
+        (0x412, "M", "в"),
+        (0x413, "M", "г"),
+        (0x414, "M", "д"),
+        (0x415, "M", "е"),
+        (0x416, "M", "ж"),
+        (0x417, "M", "з"),
+        (0x418, "M", "и"),
+        (0x419, "M", "й"),
+        (0x41A, "M", "к"),
+        (0x41B, "M", "л"),
+        (0x41C, "M", "м"),
+        (0x41D, "M", "н"),
+        (0x41E, "M", "о"),
+        (0x41F, "M", "п"),
+        (0x420, "M", "р"),
+        (0x421, "M", "с"),
+        (0x422, "M", "т"),
+        (0x423, "M", "у"),
+        (0x424, "M", "ф"),
+        (0x425, "M", "х"),
+        (0x426, "M", "ц"),
+        (0x427, "M", "ч"),
+        (0x428, "M", "ш"),
+        (0x429, "M", "щ"),
+        (0x42A, "M", "ъ"),
+        (0x42B, "M", "ы"),
+        (0x42C, "M", "ь"),
+        (0x42D, "M", "э"),
+        (0x42E, "M", "ю"),
+        (0x42F, "M", "я"),
+        (0x430, "V"),
+        (0x460, "M", "ѡ"),
+        (0x461, "V"),
+        (0x462, "M", "ѣ"),
+        (0x463, "V"),
+        (0x464, "M", "ѥ"),
+        (0x465, "V"),
+        (0x466, "M", "ѧ"),
+        (0x467, "V"),
+        (0x468, "M", "ѩ"),
+        (0x469, "V"),
+        (0x46A, "M", "ѫ"),
+        (0x46B, "V"),
+        (0x46C, "M", "ѭ"),
+        (0x46D, "V"),
+        (0x46E, "M", "ѯ"),
+        (0x46F, "V"),
+        (0x470, "M", "ѱ"),
+        (0x471, "V"),
+        (0x472, "M", "ѳ"),
+        (0x473, "V"),
+        (0x474, "M", "ѵ"),
+        (0x475, "V"),
+        (0x476, "M", "ѷ"),
+        (0x477, "V"),
+        (0x478, "M", "ѹ"),
+        (0x479, "V"),
+        (0x47A, "M", "ѻ"),
+        (0x47B, "V"),
+        (0x47C, "M", "ѽ"),
+        (0x47D, "V"),
+        (0x47E, "M", "ѿ"),
+        (0x47F, "V"),
+        (0x480, "M", "ҁ"),
+        (0x481, "V"),
+        (0x48A, "M", "ҋ"),
+        (0x48B, "V"),
+        (0x48C, "M", "ҍ"),
+        (0x48D, "V"),
+        (0x48E, "M", "ҏ"),
+        (0x48F, "V"),
+        (0x490, "M", "ґ"),
+        (0x491, "V"),
+        (0x492, "M", "ғ"),
+        (0x493, "V"),
+        (0x494, "M", "ҕ"),
+        (0x495, "V"),
+        (0x496, "M", "җ"),
+        (0x497, "V"),
+        (0x498, "M", "ҙ"),
+        (0x499, "V"),
+        (0x49A, "M", "қ"),
+        (0x49B, "V"),
+        (0x49C, "M", "ҝ"),
+        (0x49D, "V"),
+    ]
+
+
+def _seg_8() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x49E, "M", "ҟ"),
+        (0x49F, "V"),
+        (0x4A0, "M", "ҡ"),
+        (0x4A1, "V"),
+        (0x4A2, "M", "ң"),
+        (0x4A3, "V"),
+        (0x4A4, "M", "ҥ"),
+        (0x4A5, "V"),
+        (0x4A6, "M", "ҧ"),
+        (0x4A7, "V"),
+        (0x4A8, "M", "ҩ"),
+        (0x4A9, "V"),
+        (0x4AA, "M", "ҫ"),
+        (0x4AB, "V"),
+        (0x4AC, "M", "ҭ"),
+        (0x4AD, "V"),
+        (0x4AE, "M", "ү"),
+        (0x4AF, "V"),
+        (0x4B0, "M", "ұ"),
+        (0x4B1, "V"),
+        (0x4B2, "M", "ҳ"),
+        (0x4B3, "V"),
+        (0x4B4, "M", "ҵ"),
+        (0x4B5, "V"),
+        (0x4B6, "M", "ҷ"),
+        (0x4B7, "V"),
+        (0x4B8, "M", "ҹ"),
+        (0x4B9, "V"),
+        (0x4BA, "M", "һ"),
+        (0x4BB, "V"),
+        (0x4BC, "M", "ҽ"),
+        (0x4BD, "V"),
+        (0x4BE, "M", "ҿ"),
+        (0x4BF, "V"),
+        (0x4C0, "M", "ӏ"),
+        (0x4C1, "M", "ӂ"),
+        (0x4C2, "V"),
+        (0x4C3, "M", "ӄ"),
+        (0x4C4, "V"),
+        (0x4C5, "M", "ӆ"),
+        (0x4C6, "V"),
+        (0x4C7, "M", "ӈ"),
+        (0x4C8, "V"),
+        (0x4C9, "M", "ӊ"),
+        (0x4CA, "V"),
+        (0x4CB, "M", "ӌ"),
+        (0x4CC, "V"),
+        (0x4CD, "M", "ӎ"),
+        (0x4CE, "V"),
+        (0x4D0, "M", "ӑ"),
+        (0x4D1, "V"),
+        (0x4D2, "M", "ӓ"),
+        (0x4D3, "V"),
+        (0x4D4, "M", "ӕ"),
+        (0x4D5, "V"),
+        (0x4D6, "M", "ӗ"),
+        (0x4D7, "V"),
+        (0x4D8, "M", "ә"),
+        (0x4D9, "V"),
+        (0x4DA, "M", "ӛ"),
+        (0x4DB, "V"),
+        (0x4DC, "M", "ӝ"),
+        (0x4DD, "V"),
+        (0x4DE, "M", "ӟ"),
+        (0x4DF, "V"),
+        (0x4E0, "M", "ӡ"),
+        (0x4E1, "V"),
+        (0x4E2, "M", "ӣ"),
+        (0x4E3, "V"),
+        (0x4E4, "M", "ӥ"),
+        (0x4E5, "V"),
+        (0x4E6, "M", "ӧ"),
+        (0x4E7, "V"),
+        (0x4E8, "M", "ө"),
+        (0x4E9, "V"),
+        (0x4EA, "M", "ӫ"),
+        (0x4EB, "V"),
+        (0x4EC, "M", "ӭ"),
+        (0x4ED, "V"),
+        (0x4EE, "M", "ӯ"),
+        (0x4EF, "V"),
+        (0x4F0, "M", "ӱ"),
+        (0x4F1, "V"),
+        (0x4F2, "M", "ӳ"),
+        (0x4F3, "V"),
+        (0x4F4, "M", "ӵ"),
+        (0x4F5, "V"),
+        (0x4F6, "M", "ӷ"),
+        (0x4F7, "V"),
+        (0x4F8, "M", "ӹ"),
+        (0x4F9, "V"),
+        (0x4FA, "M", "ӻ"),
+        (0x4FB, "V"),
+        (0x4FC, "M", "ӽ"),
+        (0x4FD, "V"),
+        (0x4FE, "M", "ӿ"),
+        (0x4FF, "V"),
+        (0x500, "M", "ԁ"),
+        (0x501, "V"),
+        (0x502, "M", "ԃ"),
+    ]
+
+
+def _seg_9() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x503, "V"),
+        (0x504, "M", "ԅ"),
+        (0x505, "V"),
+        (0x506, "M", "ԇ"),
+        (0x507, "V"),
+        (0x508, "M", "ԉ"),
+        (0x509, "V"),
+        (0x50A, "M", "ԋ"),
+        (0x50B, "V"),
+        (0x50C, "M", "ԍ"),
+        (0x50D, "V"),
+        (0x50E, "M", "ԏ"),
+        (0x50F, "V"),
+        (0x510, "M", "ԑ"),
+        (0x511, "V"),
+        (0x512, "M", "ԓ"),
+        (0x513, "V"),
+        (0x514, "M", "ԕ"),
+        (0x515, "V"),
+        (0x516, "M", "ԗ"),
+        (0x517, "V"),
+        (0x518, "M", "ԙ"),
+        (0x519, "V"),
+        (0x51A, "M", "ԛ"),
+        (0x51B, "V"),
+        (0x51C, "M", "ԝ"),
+        (0x51D, "V"),
+        (0x51E, "M", "ԟ"),
+        (0x51F, "V"),
+        (0x520, "M", "ԡ"),
+        (0x521, "V"),
+        (0x522, "M", "ԣ"),
+        (0x523, "V"),
+        (0x524, "M", "ԥ"),
+        (0x525, "V"),
+        (0x526, "M", "ԧ"),
+        (0x527, "V"),
+        (0x528, "M", "ԩ"),
+        (0x529, "V"),
+        (0x52A, "M", "ԫ"),
+        (0x52B, "V"),
+        (0x52C, "M", "ԭ"),
+        (0x52D, "V"),
+        (0x52E, "M", "ԯ"),
+        (0x52F, "V"),
+        (0x530, "X"),
+        (0x531, "M", "ա"),
+        (0x532, "M", "բ"),
+        (0x533, "M", "գ"),
+        (0x534, "M", "դ"),
+        (0x535, "M", "ե"),
+        (0x536, "M", "զ"),
+        (0x537, "M", "է"),
+        (0x538, "M", "ը"),
+        (0x539, "M", "թ"),
+        (0x53A, "M", "ժ"),
+        (0x53B, "M", "ի"),
+        (0x53C, "M", "լ"),
+        (0x53D, "M", "խ"),
+        (0x53E, "M", "ծ"),
+        (0x53F, "M", "կ"),
+        (0x540, "M", "հ"),
+        (0x541, "M", "ձ"),
+        (0x542, "M", "ղ"),
+        (0x543, "M", "ճ"),
+        (0x544, "M", "մ"),
+        (0x545, "M", "յ"),
+        (0x546, "M", "ն"),
+        (0x547, "M", "շ"),
+        (0x548, "M", "ո"),
+        (0x549, "M", "չ"),
+        (0x54A, "M", "պ"),
+        (0x54B, "M", "ջ"),
+        (0x54C, "M", "ռ"),
+        (0x54D, "M", "ս"),
+        (0x54E, "M", "վ"),
+        (0x54F, "M", "տ"),
+        (0x550, "M", "ր"),
+        (0x551, "M", "ց"),
+        (0x552, "M", "ւ"),
+        (0x553, "M", "փ"),
+        (0x554, "M", "ք"),
+        (0x555, "M", "օ"),
+        (0x556, "M", "ֆ"),
+        (0x557, "X"),
+        (0x559, "V"),
+        (0x587, "M", "եւ"),
+        (0x588, "V"),
+        (0x58B, "X"),
+        (0x58D, "V"),
+        (0x590, "X"),
+        (0x591, "V"),
+        (0x5C8, "X"),
+        (0x5D0, "V"),
+        (0x5EB, "X"),
+        (0x5EF, "V"),
+        (0x5F5, "X"),
+        (0x606, "V"),
+        (0x61C, "X"),
+        (0x61D, "V"),
+    ]
+
+
+def _seg_10() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x675, "M", "اٴ"),
+        (0x676, "M", "وٴ"),
+        (0x677, "M", "ۇٴ"),
+        (0x678, "M", "يٴ"),
+        (0x679, "V"),
+        (0x6DD, "X"),
+        (0x6DE, "V"),
+        (0x70E, "X"),
+        (0x710, "V"),
+        (0x74B, "X"),
+        (0x74D, "V"),
+        (0x7B2, "X"),
+        (0x7C0, "V"),
+        (0x7FB, "X"),
+        (0x7FD, "V"),
+        (0x82E, "X"),
+        (0x830, "V"),
+        (0x83F, "X"),
+        (0x840, "V"),
+        (0x85C, "X"),
+        (0x85E, "V"),
+        (0x85F, "X"),
+        (0x860, "V"),
+        (0x86B, "X"),
+        (0x870, "V"),
+        (0x88F, "X"),
+        (0x897, "V"),
+        (0x8E2, "X"),
+        (0x8E3, "V"),
+        (0x958, "M", "क़"),
+        (0x959, "M", "ख़"),
+        (0x95A, "M", "ग़"),
+        (0x95B, "M", "ज़"),
+        (0x95C, "M", "ड़"),
+        (0x95D, "M", "ढ़"),
+        (0x95E, "M", "फ़"),
+        (0x95F, "M", "य़"),
+        (0x960, "V"),
+        (0x984, "X"),
+        (0x985, "V"),
+        (0x98D, "X"),
+        (0x98F, "V"),
+        (0x991, "X"),
+        (0x993, "V"),
+        (0x9A9, "X"),
+        (0x9AA, "V"),
+        (0x9B1, "X"),
+        (0x9B2, "V"),
+        (0x9B3, "X"),
+        (0x9B6, "V"),
+        (0x9BA, "X"),
+        (0x9BC, "V"),
+        (0x9C5, "X"),
+        (0x9C7, "V"),
+        (0x9C9, "X"),
+        (0x9CB, "V"),
+        (0x9CF, "X"),
+        (0x9D7, "V"),
+        (0x9D8, "X"),
+        (0x9DC, "M", "ড়"),
+        (0x9DD, "M", "ঢ়"),
+        (0x9DE, "X"),
+        (0x9DF, "M", "য়"),
+        (0x9E0, "V"),
+        (0x9E4, "X"),
+        (0x9E6, "V"),
+        (0x9FF, "X"),
+        (0xA01, "V"),
+        (0xA04, "X"),
+        (0xA05, "V"),
+        (0xA0B, "X"),
+        (0xA0F, "V"),
+        (0xA11, "X"),
+        (0xA13, "V"),
+        (0xA29, "X"),
+        (0xA2A, "V"),
+        (0xA31, "X"),
+        (0xA32, "V"),
+        (0xA33, "M", "ਲ਼"),
+        (0xA34, "X"),
+        (0xA35, "V"),
+        (0xA36, "M", "ਸ਼"),
+        (0xA37, "X"),
+        (0xA38, "V"),
+        (0xA3A, "X"),
+        (0xA3C, "V"),
+        (0xA3D, "X"),
+        (0xA3E, "V"),
+        (0xA43, "X"),
+        (0xA47, "V"),
+        (0xA49, "X"),
+        (0xA4B, "V"),
+        (0xA4E, "X"),
+        (0xA51, "V"),
+        (0xA52, "X"),
+        (0xA59, "M", "ਖ਼"),
+        (0xA5A, "M", "ਗ਼"),
+        (0xA5B, "M", "ਜ਼"),
+        (0xA5C, "V"),
+        (0xA5D, "X"),
+    ]
+
+
+def _seg_11() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xA5E, "M", "ਫ਼"),
+        (0xA5F, "X"),
+        (0xA66, "V"),
+        (0xA77, "X"),
+        (0xA81, "V"),
+        (0xA84, "X"),
+        (0xA85, "V"),
+        (0xA8E, "X"),
+        (0xA8F, "V"),
+        (0xA92, "X"),
+        (0xA93, "V"),
+        (0xAA9, "X"),
+        (0xAAA, "V"),
+        (0xAB1, "X"),
+        (0xAB2, "V"),
+        (0xAB4, "X"),
+        (0xAB5, "V"),
+        (0xABA, "X"),
+        (0xABC, "V"),
+        (0xAC6, "X"),
+        (0xAC7, "V"),
+        (0xACA, "X"),
+        (0xACB, "V"),
+        (0xACE, "X"),
+        (0xAD0, "V"),
+        (0xAD1, "X"),
+        (0xAE0, "V"),
+        (0xAE4, "X"),
+        (0xAE6, "V"),
+        (0xAF2, "X"),
+        (0xAF9, "V"),
+        (0xB00, "X"),
+        (0xB01, "V"),
+        (0xB04, "X"),
+        (0xB05, "V"),
+        (0xB0D, "X"),
+        (0xB0F, "V"),
+        (0xB11, "X"),
+        (0xB13, "V"),
+        (0xB29, "X"),
+        (0xB2A, "V"),
+        (0xB31, "X"),
+        (0xB32, "V"),
+        (0xB34, "X"),
+        (0xB35, "V"),
+        (0xB3A, "X"),
+        (0xB3C, "V"),
+        (0xB45, "X"),
+        (0xB47, "V"),
+        (0xB49, "X"),
+        (0xB4B, "V"),
+        (0xB4E, "X"),
+        (0xB55, "V"),
+        (0xB58, "X"),
+        (0xB5C, "M", "ଡ଼"),
+        (0xB5D, "M", "ଢ଼"),
+        (0xB5E, "X"),
+        (0xB5F, "V"),
+        (0xB64, "X"),
+        (0xB66, "V"),
+        (0xB78, "X"),
+        (0xB82, "V"),
+        (0xB84, "X"),
+        (0xB85, "V"),
+        (0xB8B, "X"),
+        (0xB8E, "V"),
+        (0xB91, "X"),
+        (0xB92, "V"),
+        (0xB96, "X"),
+        (0xB99, "V"),
+        (0xB9B, "X"),
+        (0xB9C, "V"),
+        (0xB9D, "X"),
+        (0xB9E, "V"),
+        (0xBA0, "X"),
+        (0xBA3, "V"),
+        (0xBA5, "X"),
+        (0xBA8, "V"),
+        (0xBAB, "X"),
+        (0xBAE, "V"),
+        (0xBBA, "X"),
+        (0xBBE, "V"),
+        (0xBC3, "X"),
+        (0xBC6, "V"),
+        (0xBC9, "X"),
+        (0xBCA, "V"),
+        (0xBCE, "X"),
+        (0xBD0, "V"),
+        (0xBD1, "X"),
+        (0xBD7, "V"),
+        (0xBD8, "X"),
+        (0xBE6, "V"),
+        (0xBFB, "X"),
+        (0xC00, "V"),
+        (0xC0D, "X"),
+        (0xC0E, "V"),
+        (0xC11, "X"),
+        (0xC12, "V"),
+        (0xC29, "X"),
+        (0xC2A, "V"),
+    ]
+
+
+def _seg_12() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xC3A, "X"),
+        (0xC3C, "V"),
+        (0xC45, "X"),
+        (0xC46, "V"),
+        (0xC49, "X"),
+        (0xC4A, "V"),
+        (0xC4E, "X"),
+        (0xC55, "V"),
+        (0xC57, "X"),
+        (0xC58, "V"),
+        (0xC5B, "X"),
+        (0xC5D, "V"),
+        (0xC5E, "X"),
+        (0xC60, "V"),
+        (0xC64, "X"),
+        (0xC66, "V"),
+        (0xC70, "X"),
+        (0xC77, "V"),
+        (0xC8D, "X"),
+        (0xC8E, "V"),
+        (0xC91, "X"),
+        (0xC92, "V"),
+        (0xCA9, "X"),
+        (0xCAA, "V"),
+        (0xCB4, "X"),
+        (0xCB5, "V"),
+        (0xCBA, "X"),
+        (0xCBC, "V"),
+        (0xCC5, "X"),
+        (0xCC6, "V"),
+        (0xCC9, "X"),
+        (0xCCA, "V"),
+        (0xCCE, "X"),
+        (0xCD5, "V"),
+        (0xCD7, "X"),
+        (0xCDD, "V"),
+        (0xCDF, "X"),
+        (0xCE0, "V"),
+        (0xCE4, "X"),
+        (0xCE6, "V"),
+        (0xCF0, "X"),
+        (0xCF1, "V"),
+        (0xCF4, "X"),
+        (0xD00, "V"),
+        (0xD0D, "X"),
+        (0xD0E, "V"),
+        (0xD11, "X"),
+        (0xD12, "V"),
+        (0xD45, "X"),
+        (0xD46, "V"),
+        (0xD49, "X"),
+        (0xD4A, "V"),
+        (0xD50, "X"),
+        (0xD54, "V"),
+        (0xD64, "X"),
+        (0xD66, "V"),
+        (0xD80, "X"),
+        (0xD81, "V"),
+        (0xD84, "X"),
+        (0xD85, "V"),
+        (0xD97, "X"),
+        (0xD9A, "V"),
+        (0xDB2, "X"),
+        (0xDB3, "V"),
+        (0xDBC, "X"),
+        (0xDBD, "V"),
+        (0xDBE, "X"),
+        (0xDC0, "V"),
+        (0xDC7, "X"),
+        (0xDCA, "V"),
+        (0xDCB, "X"),
+        (0xDCF, "V"),
+        (0xDD5, "X"),
+        (0xDD6, "V"),
+        (0xDD7, "X"),
+        (0xDD8, "V"),
+        (0xDE0, "X"),
+        (0xDE6, "V"),
+        (0xDF0, "X"),
+        (0xDF2, "V"),
+        (0xDF5, "X"),
+        (0xE01, "V"),
+        (0xE33, "M", "ํา"),
+        (0xE34, "V"),
+        (0xE3B, "X"),
+        (0xE3F, "V"),
+        (0xE5C, "X"),
+        (0xE81, "V"),
+        (0xE83, "X"),
+        (0xE84, "V"),
+        (0xE85, "X"),
+        (0xE86, "V"),
+        (0xE8B, "X"),
+        (0xE8C, "V"),
+        (0xEA4, "X"),
+        (0xEA5, "V"),
+        (0xEA6, "X"),
+        (0xEA7, "V"),
+        (0xEB3, "M", "ໍາ"),
+        (0xEB4, "V"),
+    ]
+
+
+def _seg_13() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xEBE, "X"),
+        (0xEC0, "V"),
+        (0xEC5, "X"),
+        (0xEC6, "V"),
+        (0xEC7, "X"),
+        (0xEC8, "V"),
+        (0xECF, "X"),
+        (0xED0, "V"),
+        (0xEDA, "X"),
+        (0xEDC, "M", "ຫນ"),
+        (0xEDD, "M", "ຫມ"),
+        (0xEDE, "V"),
+        (0xEE0, "X"),
+        (0xF00, "V"),
+        (0xF0C, "M", "་"),
+        (0xF0D, "V"),
+        (0xF43, "M", "གྷ"),
+        (0xF44, "V"),
+        (0xF48, "X"),
+        (0xF49, "V"),
+        (0xF4D, "M", "ཌྷ"),
+        (0xF4E, "V"),
+        (0xF52, "M", "དྷ"),
+        (0xF53, "V"),
+        (0xF57, "M", "བྷ"),
+        (0xF58, "V"),
+        (0xF5C, "M", "ཛྷ"),
+        (0xF5D, "V"),
+        (0xF69, "M", "ཀྵ"),
+        (0xF6A, "V"),
+        (0xF6D, "X"),
+        (0xF71, "V"),
+        (0xF73, "M", "ཱི"),
+        (0xF74, "V"),
+        (0xF75, "M", "ཱུ"),
+        (0xF76, "M", "ྲྀ"),
+        (0xF77, "M", "ྲཱྀ"),
+        (0xF78, "M", "ླྀ"),
+        (0xF79, "M", "ླཱྀ"),
+        (0xF7A, "V"),
+        (0xF81, "M", "ཱྀ"),
+        (0xF82, "V"),
+        (0xF93, "M", "ྒྷ"),
+        (0xF94, "V"),
+        (0xF98, "X"),
+        (0xF99, "V"),
+        (0xF9D, "M", "ྜྷ"),
+        (0xF9E, "V"),
+        (0xFA2, "M", "ྡྷ"),
+        (0xFA3, "V"),
+        (0xFA7, "M", "ྦྷ"),
+        (0xFA8, "V"),
+        (0xFAC, "M", "ྫྷ"),
+        (0xFAD, "V"),
+        (0xFB9, "M", "ྐྵ"),
+        (0xFBA, "V"),
+        (0xFBD, "X"),
+        (0xFBE, "V"),
+        (0xFCD, "X"),
+        (0xFCE, "V"),
+        (0xFDB, "X"),
+        (0x1000, "V"),
+        (0x10A0, "M", "ⴀ"),
+        (0x10A1, "M", "ⴁ"),
+        (0x10A2, "M", "ⴂ"),
+        (0x10A3, "M", "ⴃ"),
+        (0x10A4, "M", "ⴄ"),
+        (0x10A5, "M", "ⴅ"),
+        (0x10A6, "M", "ⴆ"),
+        (0x10A7, "M", "ⴇ"),
+        (0x10A8, "M", "ⴈ"),
+        (0x10A9, "M", "ⴉ"),
+        (0x10AA, "M", "ⴊ"),
+        (0x10AB, "M", "ⴋ"),
+        (0x10AC, "M", "ⴌ"),
+        (0x10AD, "M", "ⴍ"),
+        (0x10AE, "M", "ⴎ"),
+        (0x10AF, "M", "ⴏ"),
+        (0x10B0, "M", "ⴐ"),
+        (0x10B1, "M", "ⴑ"),
+        (0x10B2, "M", "ⴒ"),
+        (0x10B3, "M", "ⴓ"),
+        (0x10B4, "M", "ⴔ"),
+        (0x10B5, "M", "ⴕ"),
+        (0x10B6, "M", "ⴖ"),
+        (0x10B7, "M", "ⴗ"),
+        (0x10B8, "M", "ⴘ"),
+        (0x10B9, "M", "ⴙ"),
+        (0x10BA, "M", "ⴚ"),
+        (0x10BB, "M", "ⴛ"),
+        (0x10BC, "M", "ⴜ"),
+        (0x10BD, "M", "ⴝ"),
+        (0x10BE, "M", "ⴞ"),
+        (0x10BF, "M", "ⴟ"),
+        (0x10C0, "M", "ⴠ"),
+        (0x10C1, "M", "ⴡ"),
+        (0x10C2, "M", "ⴢ"),
+        (0x10C3, "M", "ⴣ"),
+        (0x10C4, "M", "ⴤ"),
+        (0x10C5, "M", "ⴥ"),
+    ]
+
+
+def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x10C6, "X"),
+        (0x10C7, "M", "ⴧ"),
+        (0x10C8, "X"),
+        (0x10CD, "M", "ⴭ"),
+        (0x10CE, "X"),
+        (0x10D0, "V"),
+        (0x10FC, "M", "ნ"),
+        (0x10FD, "V"),
+        (0x115F, "I"),
+        (0x1161, "V"),
+        (0x1249, "X"),
+        (0x124A, "V"),
+        (0x124E, "X"),
+        (0x1250, "V"),
+        (0x1257, "X"),
+        (0x1258, "V"),
+        (0x1259, "X"),
+        (0x125A, "V"),
+        (0x125E, "X"),
+        (0x1260, "V"),
+        (0x1289, "X"),
+        (0x128A, "V"),
+        (0x128E, "X"),
+        (0x1290, "V"),
+        (0x12B1, "X"),
+        (0x12B2, "V"),
+        (0x12B6, "X"),
+        (0x12B8, "V"),
+        (0x12BF, "X"),
+        (0x12C0, "V"),
+        (0x12C1, "X"),
+        (0x12C2, "V"),
+        (0x12C6, "X"),
+        (0x12C8, "V"),
+        (0x12D7, "X"),
+        (0x12D8, "V"),
+        (0x1311, "X"),
+        (0x1312, "V"),
+        (0x1316, "X"),
+        (0x1318, "V"),
+        (0x135B, "X"),
+        (0x135D, "V"),
+        (0x137D, "X"),
+        (0x1380, "V"),
+        (0x139A, "X"),
+        (0x13A0, "V"),
+        (0x13F6, "X"),
+        (0x13F8, "M", "Ᏸ"),
+        (0x13F9, "M", "Ᏹ"),
+        (0x13FA, "M", "Ᏺ"),
+        (0x13FB, "M", "Ᏻ"),
+        (0x13FC, "M", "Ᏼ"),
+        (0x13FD, "M", "Ᏽ"),
+        (0x13FE, "X"),
+        (0x1400, "V"),
+        (0x1680, "X"),
+        (0x1681, "V"),
+        (0x169D, "X"),
+        (0x16A0, "V"),
+        (0x16F9, "X"),
+        (0x1700, "V"),
+        (0x1716, "X"),
+        (0x171F, "V"),
+        (0x1737, "X"),
+        (0x1740, "V"),
+        (0x1754, "X"),
+        (0x1760, "V"),
+        (0x176D, "X"),
+        (0x176E, "V"),
+        (0x1771, "X"),
+        (0x1772, "V"),
+        (0x1774, "X"),
+        (0x1780, "V"),
+        (0x17B4, "I"),
+        (0x17B6, "V"),
+        (0x17DE, "X"),
+        (0x17E0, "V"),
+        (0x17EA, "X"),
+        (0x17F0, "V"),
+        (0x17FA, "X"),
+        (0x1800, "V"),
+        (0x180B, "I"),
+        (0x1810, "V"),
+        (0x181A, "X"),
+        (0x1820, "V"),
+        (0x1879, "X"),
+        (0x1880, "V"),
+        (0x18AB, "X"),
+        (0x18B0, "V"),
+        (0x18F6, "X"),
+        (0x1900, "V"),
+        (0x191F, "X"),
+        (0x1920, "V"),
+        (0x192C, "X"),
+        (0x1930, "V"),
+        (0x193C, "X"),
+        (0x1940, "V"),
+        (0x1941, "X"),
+        (0x1944, "V"),
+        (0x196E, "X"),
+    ]
+
+
+def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1970, "V"),
+        (0x1975, "X"),
+        (0x1980, "V"),
+        (0x19AC, "X"),
+        (0x19B0, "V"),
+        (0x19CA, "X"),
+        (0x19D0, "V"),
+        (0x19DB, "X"),
+        (0x19DE, "V"),
+        (0x1A1C, "X"),
+        (0x1A1E, "V"),
+        (0x1A5F, "X"),
+        (0x1A60, "V"),
+        (0x1A7D, "X"),
+        (0x1A7F, "V"),
+        (0x1A8A, "X"),
+        (0x1A90, "V"),
+        (0x1A9A, "X"),
+        (0x1AA0, "V"),
+        (0x1AAE, "X"),
+        (0x1AB0, "V"),
+        (0x1ACF, "X"),
+        (0x1B00, "V"),
+        (0x1B4D, "X"),
+        (0x1B4E, "V"),
+        (0x1BF4, "X"),
+        (0x1BFC, "V"),
+        (0x1C38, "X"),
+        (0x1C3B, "V"),
+        (0x1C4A, "X"),
+        (0x1C4D, "V"),
+        (0x1C80, "M", "в"),
+        (0x1C81, "M", "д"),
+        (0x1C82, "M", "о"),
+        (0x1C83, "M", "с"),
+        (0x1C84, "M", "т"),
+        (0x1C86, "M", "ъ"),
+        (0x1C87, "M", "ѣ"),
+        (0x1C88, "M", "ꙋ"),
+        (0x1C89, "M", "ᲊ"),
+        (0x1C8A, "V"),
+        (0x1C8B, "X"),
+        (0x1C90, "M", "ა"),
+        (0x1C91, "M", "ბ"),
+        (0x1C92, "M", "გ"),
+        (0x1C93, "M", "დ"),
+        (0x1C94, "M", "ე"),
+        (0x1C95, "M", "ვ"),
+        (0x1C96, "M", "ზ"),
+        (0x1C97, "M", "თ"),
+        (0x1C98, "M", "ი"),
+        (0x1C99, "M", "კ"),
+        (0x1C9A, "M", "ლ"),
+        (0x1C9B, "M", "მ"),
+        (0x1C9C, "M", "ნ"),
+        (0x1C9D, "M", "ო"),
+        (0x1C9E, "M", "პ"),
+        (0x1C9F, "M", "ჟ"),
+        (0x1CA0, "M", "რ"),
+        (0x1CA1, "M", "ს"),
+        (0x1CA2, "M", "ტ"),
+        (0x1CA3, "M", "უ"),
+        (0x1CA4, "M", "ფ"),
+        (0x1CA5, "M", "ქ"),
+        (0x1CA6, "M", "ღ"),
+        (0x1CA7, "M", "ყ"),
+        (0x1CA8, "M", "შ"),
+        (0x1CA9, "M", "ჩ"),
+        (0x1CAA, "M", "ც"),
+        (0x1CAB, "M", "ძ"),
+        (0x1CAC, "M", "წ"),
+        (0x1CAD, "M", "ჭ"),
+        (0x1CAE, "M", "ხ"),
+        (0x1CAF, "M", "ჯ"),
+        (0x1CB0, "M", "ჰ"),
+        (0x1CB1, "M", "ჱ"),
+        (0x1CB2, "M", "ჲ"),
+        (0x1CB3, "M", "ჳ"),
+        (0x1CB4, "M", "ჴ"),
+        (0x1CB5, "M", "ჵ"),
+        (0x1CB6, "M", "ჶ"),
+        (0x1CB7, "M", "ჷ"),
+        (0x1CB8, "M", "ჸ"),
+        (0x1CB9, "M", "ჹ"),
+        (0x1CBA, "M", "ჺ"),
+        (0x1CBB, "X"),
+        (0x1CBD, "M", "ჽ"),
+        (0x1CBE, "M", "ჾ"),
+        (0x1CBF, "M", "ჿ"),
+        (0x1CC0, "V"),
+        (0x1CC8, "X"),
+        (0x1CD0, "V"),
+        (0x1CFB, "X"),
+        (0x1D00, "V"),
+        (0x1D2C, "M", "a"),
+        (0x1D2D, "M", "æ"),
+        (0x1D2E, "M", "b"),
+        (0x1D2F, "V"),
+        (0x1D30, "M", "d"),
+        (0x1D31, "M", "e"),
+    ]
+
+
+def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D32, "M", "ǝ"),
+        (0x1D33, "M", "g"),
+        (0x1D34, "M", "h"),
+        (0x1D35, "M", "i"),
+        (0x1D36, "M", "j"),
+        (0x1D37, "M", "k"),
+        (0x1D38, "M", "l"),
+        (0x1D39, "M", "m"),
+        (0x1D3A, "M", "n"),
+        (0x1D3B, "V"),
+        (0x1D3C, "M", "o"),
+        (0x1D3D, "M", "ȣ"),
+        (0x1D3E, "M", "p"),
+        (0x1D3F, "M", "r"),
+        (0x1D40, "M", "t"),
+        (0x1D41, "M", "u"),
+        (0x1D42, "M", "w"),
+        (0x1D43, "M", "a"),
+        (0x1D44, "M", "ɐ"),
+        (0x1D45, "M", "ɑ"),
+        (0x1D46, "M", "ᴂ"),
+        (0x1D47, "M", "b"),
+        (0x1D48, "M", "d"),
+        (0x1D49, "M", "e"),
+        (0x1D4A, "M", "ə"),
+        (0x1D4B, "M", "ɛ"),
+        (0x1D4C, "M", "ɜ"),
+        (0x1D4D, "M", "g"),
+        (0x1D4E, "V"),
+        (0x1D4F, "M", "k"),
+        (0x1D50, "M", "m"),
+        (0x1D51, "M", "ŋ"),
+        (0x1D52, "M", "o"),
+        (0x1D53, "M", "ɔ"),
+        (0x1D54, "M", "ᴖ"),
+        (0x1D55, "M", "ᴗ"),
+        (0x1D56, "M", "p"),
+        (0x1D57, "M", "t"),
+        (0x1D58, "M", "u"),
+        (0x1D59, "M", "ᴝ"),
+        (0x1D5A, "M", "ɯ"),
+        (0x1D5B, "M", "v"),
+        (0x1D5C, "M", "ᴥ"),
+        (0x1D5D, "M", "β"),
+        (0x1D5E, "M", "γ"),
+        (0x1D5F, "M", "δ"),
+        (0x1D60, "M", "φ"),
+        (0x1D61, "M", "χ"),
+        (0x1D62, "M", "i"),
+        (0x1D63, "M", "r"),
+        (0x1D64, "M", "u"),
+        (0x1D65, "M", "v"),
+        (0x1D66, "M", "β"),
+        (0x1D67, "M", "γ"),
+        (0x1D68, "M", "ρ"),
+        (0x1D69, "M", "φ"),
+        (0x1D6A, "M", "χ"),
+        (0x1D6B, "V"),
+        (0x1D78, "M", "н"),
+        (0x1D79, "V"),
+        (0x1D9B, "M", "ɒ"),
+        (0x1D9C, "M", "c"),
+        (0x1D9D, "M", "ɕ"),
+        (0x1D9E, "M", "ð"),
+        (0x1D9F, "M", "ɜ"),
+        (0x1DA0, "M", "f"),
+        (0x1DA1, "M", "ɟ"),
+        (0x1DA2, "M", "ɡ"),
+        (0x1DA3, "M", "ɥ"),
+        (0x1DA4, "M", "ɨ"),
+        (0x1DA5, "M", "ɩ"),
+        (0x1DA6, "M", "ɪ"),
+        (0x1DA7, "M", "ᵻ"),
+        (0x1DA8, "M", "ʝ"),
+        (0x1DA9, "M", "ɭ"),
+        (0x1DAA, "M", "ᶅ"),
+        (0x1DAB, "M", "ʟ"),
+        (0x1DAC, "M", "ɱ"),
+        (0x1DAD, "M", "ɰ"),
+        (0x1DAE, "M", "ɲ"),
+        (0x1DAF, "M", "ɳ"),
+        (0x1DB0, "M", "ɴ"),
+        (0x1DB1, "M", "ɵ"),
+        (0x1DB2, "M", "ɸ"),
+        (0x1DB3, "M", "ʂ"),
+        (0x1DB4, "M", "ʃ"),
+        (0x1DB5, "M", "ƫ"),
+        (0x1DB6, "M", "ʉ"),
+        (0x1DB7, "M", "ʊ"),
+        (0x1DB8, "M", "ᴜ"),
+        (0x1DB9, "M", "ʋ"),
+        (0x1DBA, "M", "ʌ"),
+        (0x1DBB, "M", "z"),
+        (0x1DBC, "M", "ʐ"),
+        (0x1DBD, "M", "ʑ"),
+        (0x1DBE, "M", "ʒ"),
+        (0x1DBF, "M", "θ"),
+        (0x1DC0, "V"),
+        (0x1E00, "M", "ḁ"),
+        (0x1E01, "V"),
+    ]
+
+
+def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1E02, "M", "ḃ"),
+        (0x1E03, "V"),
+        (0x1E04, "M", "ḅ"),
+        (0x1E05, "V"),
+        (0x1E06, "M", "ḇ"),
+        (0x1E07, "V"),
+        (0x1E08, "M", "ḉ"),
+        (0x1E09, "V"),
+        (0x1E0A, "M", "ḋ"),
+        (0x1E0B, "V"),
+        (0x1E0C, "M", "ḍ"),
+        (0x1E0D, "V"),
+        (0x1E0E, "M", "ḏ"),
+        (0x1E0F, "V"),
+        (0x1E10, "M", "ḑ"),
+        (0x1E11, "V"),
+        (0x1E12, "M", "ḓ"),
+        (0x1E13, "V"),
+        (0x1E14, "M", "ḕ"),
+        (0x1E15, "V"),
+        (0x1E16, "M", "ḗ"),
+        (0x1E17, "V"),
+        (0x1E18, "M", "ḙ"),
+        (0x1E19, "V"),
+        (0x1E1A, "M", "ḛ"),
+        (0x1E1B, "V"),
+        (0x1E1C, "M", "ḝ"),
+        (0x1E1D, "V"),
+        (0x1E1E, "M", "ḟ"),
+        (0x1E1F, "V"),
+        (0x1E20, "M", "ḡ"),
+        (0x1E21, "V"),
+        (0x1E22, "M", "ḣ"),
+        (0x1E23, "V"),
+        (0x1E24, "M", "ḥ"),
+        (0x1E25, "V"),
+        (0x1E26, "M", "ḧ"),
+        (0x1E27, "V"),
+        (0x1E28, "M", "ḩ"),
+        (0x1E29, "V"),
+        (0x1E2A, "M", "ḫ"),
+        (0x1E2B, "V"),
+        (0x1E2C, "M", "ḭ"),
+        (0x1E2D, "V"),
+        (0x1E2E, "M", "ḯ"),
+        (0x1E2F, "V"),
+        (0x1E30, "M", "ḱ"),
+        (0x1E31, "V"),
+        (0x1E32, "M", "ḳ"),
+        (0x1E33, "V"),
+        (0x1E34, "M", "ḵ"),
+        (0x1E35, "V"),
+        (0x1E36, "M", "ḷ"),
+        (0x1E37, "V"),
+        (0x1E38, "M", "ḹ"),
+        (0x1E39, "V"),
+        (0x1E3A, "M", "ḻ"),
+        (0x1E3B, "V"),
+        (0x1E3C, "M", "ḽ"),
+        (0x1E3D, "V"),
+        (0x1E3E, "M", "ḿ"),
+        (0x1E3F, "V"),
+        (0x1E40, "M", "ṁ"),
+        (0x1E41, "V"),
+        (0x1E42, "M", "ṃ"),
+        (0x1E43, "V"),
+        (0x1E44, "M", "ṅ"),
+        (0x1E45, "V"),
+        (0x1E46, "M", "ṇ"),
+        (0x1E47, "V"),
+        (0x1E48, "M", "ṉ"),
+        (0x1E49, "V"),
+        (0x1E4A, "M", "ṋ"),
+        (0x1E4B, "V"),
+        (0x1E4C, "M", "ṍ"),
+        (0x1E4D, "V"),
+        (0x1E4E, "M", "ṏ"),
+        (0x1E4F, "V"),
+        (0x1E50, "M", "ṑ"),
+        (0x1E51, "V"),
+        (0x1E52, "M", "ṓ"),
+        (0x1E53, "V"),
+        (0x1E54, "M", "ṕ"),
+        (0x1E55, "V"),
+        (0x1E56, "M", "ṗ"),
+        (0x1E57, "V"),
+        (0x1E58, "M", "ṙ"),
+        (0x1E59, "V"),
+        (0x1E5A, "M", "ṛ"),
+        (0x1E5B, "V"),
+        (0x1E5C, "M", "ṝ"),
+        (0x1E5D, "V"),
+        (0x1E5E, "M", "ṟ"),
+        (0x1E5F, "V"),
+        (0x1E60, "M", "ṡ"),
+        (0x1E61, "V"),
+        (0x1E62, "M", "ṣ"),
+        (0x1E63, "V"),
+        (0x1E64, "M", "ṥ"),
+        (0x1E65, "V"),
+    ]
+
+
+def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1E66, "M", "ṧ"),
+        (0x1E67, "V"),
+        (0x1E68, "M", "ṩ"),
+        (0x1E69, "V"),
+        (0x1E6A, "M", "ṫ"),
+        (0x1E6B, "V"),
+        (0x1E6C, "M", "ṭ"),
+        (0x1E6D, "V"),
+        (0x1E6E, "M", "ṯ"),
+        (0x1E6F, "V"),
+        (0x1E70, "M", "ṱ"),
+        (0x1E71, "V"),
+        (0x1E72, "M", "ṳ"),
+        (0x1E73, "V"),
+        (0x1E74, "M", "ṵ"),
+        (0x1E75, "V"),
+        (0x1E76, "M", "ṷ"),
+        (0x1E77, "V"),
+        (0x1E78, "M", "ṹ"),
+        (0x1E79, "V"),
+        (0x1E7A, "M", "ṻ"),
+        (0x1E7B, "V"),
+        (0x1E7C, "M", "ṽ"),
+        (0x1E7D, "V"),
+        (0x1E7E, "M", "ṿ"),
+        (0x1E7F, "V"),
+        (0x1E80, "M", "ẁ"),
+        (0x1E81, "V"),
+        (0x1E82, "M", "ẃ"),
+        (0x1E83, "V"),
+        (0x1E84, "M", "ẅ"),
+        (0x1E85, "V"),
+        (0x1E86, "M", "ẇ"),
+        (0x1E87, "V"),
+        (0x1E88, "M", "ẉ"),
+        (0x1E89, "V"),
+        (0x1E8A, "M", "ẋ"),
+        (0x1E8B, "V"),
+        (0x1E8C, "M", "ẍ"),
+        (0x1E8D, "V"),
+        (0x1E8E, "M", "ẏ"),
+        (0x1E8F, "V"),
+        (0x1E90, "M", "ẑ"),
+        (0x1E91, "V"),
+        (0x1E92, "M", "ẓ"),
+        (0x1E93, "V"),
+        (0x1E94, "M", "ẕ"),
+        (0x1E95, "V"),
+        (0x1E9A, "M", "aʾ"),
+        (0x1E9B, "M", "ṡ"),
+        (0x1E9C, "V"),
+        (0x1E9E, "M", "ß"),
+        (0x1E9F, "V"),
+        (0x1EA0, "M", "ạ"),
+        (0x1EA1, "V"),
+        (0x1EA2, "M", "ả"),
+        (0x1EA3, "V"),
+        (0x1EA4, "M", "ấ"),
+        (0x1EA5, "V"),
+        (0x1EA6, "M", "ầ"),
+        (0x1EA7, "V"),
+        (0x1EA8, "M", "ẩ"),
+        (0x1EA9, "V"),
+        (0x1EAA, "M", "ẫ"),
+        (0x1EAB, "V"),
+        (0x1EAC, "M", "ậ"),
+        (0x1EAD, "V"),
+        (0x1EAE, "M", "ắ"),
+        (0x1EAF, "V"),
+        (0x1EB0, "M", "ằ"),
+        (0x1EB1, "V"),
+        (0x1EB2, "M", "ẳ"),
+        (0x1EB3, "V"),
+        (0x1EB4, "M", "ẵ"),
+        (0x1EB5, "V"),
+        (0x1EB6, "M", "ặ"),
+        (0x1EB7, "V"),
+        (0x1EB8, "M", "ẹ"),
+        (0x1EB9, "V"),
+        (0x1EBA, "M", "ẻ"),
+        (0x1EBB, "V"),
+        (0x1EBC, "M", "ẽ"),
+        (0x1EBD, "V"),
+        (0x1EBE, "M", "ế"),
+        (0x1EBF, "V"),
+        (0x1EC0, "M", "ề"),
+        (0x1EC1, "V"),
+        (0x1EC2, "M", "ể"),
+        (0x1EC3, "V"),
+        (0x1EC4, "M", "ễ"),
+        (0x1EC5, "V"),
+        (0x1EC6, "M", "ệ"),
+        (0x1EC7, "V"),
+        (0x1EC8, "M", "ỉ"),
+        (0x1EC9, "V"),
+        (0x1ECA, "M", "ị"),
+        (0x1ECB, "V"),
+        (0x1ECC, "M", "ọ"),
+        (0x1ECD, "V"),
+        (0x1ECE, "M", "ỏ"),
+    ]
+
+
+def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1ECF, "V"),
+        (0x1ED0, "M", "ố"),
+        (0x1ED1, "V"),
+        (0x1ED2, "M", "ồ"),
+        (0x1ED3, "V"),
+        (0x1ED4, "M", "ổ"),
+        (0x1ED5, "V"),
+        (0x1ED6, "M", "ỗ"),
+        (0x1ED7, "V"),
+        (0x1ED8, "M", "ộ"),
+        (0x1ED9, "V"),
+        (0x1EDA, "M", "ớ"),
+        (0x1EDB, "V"),
+        (0x1EDC, "M", "ờ"),
+        (0x1EDD, "V"),
+        (0x1EDE, "M", "ở"),
+        (0x1EDF, "V"),
+        (0x1EE0, "M", "ỡ"),
+        (0x1EE1, "V"),
+        (0x1EE2, "M", "ợ"),
+        (0x1EE3, "V"),
+        (0x1EE4, "M", "ụ"),
+        (0x1EE5, "V"),
+        (0x1EE6, "M", "ủ"),
+        (0x1EE7, "V"),
+        (0x1EE8, "M", "ứ"),
+        (0x1EE9, "V"),
+        (0x1EEA, "M", "ừ"),
+        (0x1EEB, "V"),
+        (0x1EEC, "M", "ử"),
+        (0x1EED, "V"),
+        (0x1EEE, "M", "ữ"),
+        (0x1EEF, "V"),
+        (0x1EF0, "M", "ự"),
+        (0x1EF1, "V"),
+        (0x1EF2, "M", "ỳ"),
+        (0x1EF3, "V"),
+        (0x1EF4, "M", "ỵ"),
+        (0x1EF5, "V"),
+        (0x1EF6, "M", "ỷ"),
+        (0x1EF7, "V"),
+        (0x1EF8, "M", "ỹ"),
+        (0x1EF9, "V"),
+        (0x1EFA, "M", "ỻ"),
+        (0x1EFB, "V"),
+        (0x1EFC, "M", "ỽ"),
+        (0x1EFD, "V"),
+        (0x1EFE, "M", "ỿ"),
+        (0x1EFF, "V"),
+        (0x1F08, "M", "ἀ"),
+        (0x1F09, "M", "ἁ"),
+        (0x1F0A, "M", "ἂ"),
+        (0x1F0B, "M", "ἃ"),
+        (0x1F0C, "M", "ἄ"),
+        (0x1F0D, "M", "ἅ"),
+        (0x1F0E, "M", "ἆ"),
+        (0x1F0F, "M", "ἇ"),
+        (0x1F10, "V"),
+        (0x1F16, "X"),
+        (0x1F18, "M", "ἐ"),
+        (0x1F19, "M", "ἑ"),
+        (0x1F1A, "M", "ἒ"),
+        (0x1F1B, "M", "ἓ"),
+        (0x1F1C, "M", "ἔ"),
+        (0x1F1D, "M", "ἕ"),
+        (0x1F1E, "X"),
+        (0x1F20, "V"),
+        (0x1F28, "M", "ἠ"),
+        (0x1F29, "M", "ἡ"),
+        (0x1F2A, "M", "ἢ"),
+        (0x1F2B, "M", "ἣ"),
+        (0x1F2C, "M", "ἤ"),
+        (0x1F2D, "M", "ἥ"),
+        (0x1F2E, "M", "ἦ"),
+        (0x1F2F, "M", "ἧ"),
+        (0x1F30, "V"),
+        (0x1F38, "M", "ἰ"),
+        (0x1F39, "M", "ἱ"),
+        (0x1F3A, "M", "ἲ"),
+        (0x1F3B, "M", "ἳ"),
+        (0x1F3C, "M", "ἴ"),
+        (0x1F3D, "M", "ἵ"),
+        (0x1F3E, "M", "ἶ"),
+        (0x1F3F, "M", "ἷ"),
+        (0x1F40, "V"),
+        (0x1F46, "X"),
+        (0x1F48, "M", "ὀ"),
+        (0x1F49, "M", "ὁ"),
+        (0x1F4A, "M", "ὂ"),
+        (0x1F4B, "M", "ὃ"),
+        (0x1F4C, "M", "ὄ"),
+        (0x1F4D, "M", "ὅ"),
+        (0x1F4E, "X"),
+        (0x1F50, "V"),
+        (0x1F58, "X"),
+        (0x1F59, "M", "ὑ"),
+        (0x1F5A, "X"),
+        (0x1F5B, "M", "ὓ"),
+        (0x1F5C, "X"),
+        (0x1F5D, "M", "ὕ"),
+    ]
+
+
+def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1F5E, "X"),
+        (0x1F5F, "M", "ὗ"),
+        (0x1F60, "V"),
+        (0x1F68, "M", "ὠ"),
+        (0x1F69, "M", "ὡ"),
+        (0x1F6A, "M", "ὢ"),
+        (0x1F6B, "M", "ὣ"),
+        (0x1F6C, "M", "ὤ"),
+        (0x1F6D, "M", "ὥ"),
+        (0x1F6E, "M", "ὦ"),
+        (0x1F6F, "M", "ὧ"),
+        (0x1F70, "V"),
+        (0x1F71, "M", "ά"),
+        (0x1F72, "V"),
+        (0x1F73, "M", "έ"),
+        (0x1F74, "V"),
+        (0x1F75, "M", "ή"),
+        (0x1F76, "V"),
+        (0x1F77, "M", "ί"),
+        (0x1F78, "V"),
+        (0x1F79, "M", "ό"),
+        (0x1F7A, "V"),
+        (0x1F7B, "M", "ύ"),
+        (0x1F7C, "V"),
+        (0x1F7D, "M", "ώ"),
+        (0x1F7E, "X"),
+        (0x1F80, "M", "ἀι"),
+        (0x1F81, "M", "ἁι"),
+        (0x1F82, "M", "ἂι"),
+        (0x1F83, "M", "ἃι"),
+        (0x1F84, "M", "ἄι"),
+        (0x1F85, "M", "ἅι"),
+        (0x1F86, "M", "ἆι"),
+        (0x1F87, "M", "ἇι"),
+        (0x1F88, "M", "ἀι"),
+        (0x1F89, "M", "ἁι"),
+        (0x1F8A, "M", "ἂι"),
+        (0x1F8B, "M", "ἃι"),
+        (0x1F8C, "M", "ἄι"),
+        (0x1F8D, "M", "ἅι"),
+        (0x1F8E, "M", "ἆι"),
+        (0x1F8F, "M", "ἇι"),
+        (0x1F90, "M", "ἠι"),
+        (0x1F91, "M", "ἡι"),
+        (0x1F92, "M", "ἢι"),
+        (0x1F93, "M", "ἣι"),
+        (0x1F94, "M", "ἤι"),
+        (0x1F95, "M", "ἥι"),
+        (0x1F96, "M", "ἦι"),
+        (0x1F97, "M", "ἧι"),
+        (0x1F98, "M", "ἠι"),
+        (0x1F99, "M", "ἡι"),
+        (0x1F9A, "M", "ἢι"),
+        (0x1F9B, "M", "ἣι"),
+        (0x1F9C, "M", "ἤι"),
+        (0x1F9D, "M", "ἥι"),
+        (0x1F9E, "M", "ἦι"),
+        (0x1F9F, "M", "ἧι"),
+        (0x1FA0, "M", "ὠι"),
+        (0x1FA1, "M", "ὡι"),
+        (0x1FA2, "M", "ὢι"),
+        (0x1FA3, "M", "ὣι"),
+        (0x1FA4, "M", "ὤι"),
+        (0x1FA5, "M", "ὥι"),
+        (0x1FA6, "M", "ὦι"),
+        (0x1FA7, "M", "ὧι"),
+        (0x1FA8, "M", "ὠι"),
+        (0x1FA9, "M", "ὡι"),
+        (0x1FAA, "M", "ὢι"),
+        (0x1FAB, "M", "ὣι"),
+        (0x1FAC, "M", "ὤι"),
+        (0x1FAD, "M", "ὥι"),
+        (0x1FAE, "M", "ὦι"),
+        (0x1FAF, "M", "ὧι"),
+        (0x1FB0, "V"),
+        (0x1FB2, "M", "ὰι"),
+        (0x1FB3, "M", "αι"),
+        (0x1FB4, "M", "άι"),
+        (0x1FB5, "X"),
+        (0x1FB6, "V"),
+        (0x1FB7, "M", "ᾶι"),
+        (0x1FB8, "M", "ᾰ"),
+        (0x1FB9, "M", "ᾱ"),
+        (0x1FBA, "M", "ὰ"),
+        (0x1FBB, "M", "ά"),
+        (0x1FBC, "M", "αι"),
+        (0x1FBD, "M", " ̓"),
+        (0x1FBE, "M", "ι"),
+        (0x1FBF, "M", " ̓"),
+        (0x1FC0, "M", " ͂"),
+        (0x1FC1, "M", " ̈͂"),
+        (0x1FC2, "M", "ὴι"),
+        (0x1FC3, "M", "ηι"),
+        (0x1FC4, "M", "ήι"),
+        (0x1FC5, "X"),
+        (0x1FC6, "V"),
+        (0x1FC7, "M", "ῆι"),
+        (0x1FC8, "M", "ὲ"),
+        (0x1FC9, "M", "έ"),
+        (0x1FCA, "M", "ὴ"),
+    ]
+
+
+def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1FCB, "M", "ή"),
+        (0x1FCC, "M", "ηι"),
+        (0x1FCD, "M", " ̓̀"),
+        (0x1FCE, "M", " ̓́"),
+        (0x1FCF, "M", " ̓͂"),
+        (0x1FD0, "V"),
+        (0x1FD3, "M", "ΐ"),
+        (0x1FD4, "X"),
+        (0x1FD6, "V"),
+        (0x1FD8, "M", "ῐ"),
+        (0x1FD9, "M", "ῑ"),
+        (0x1FDA, "M", "ὶ"),
+        (0x1FDB, "M", "ί"),
+        (0x1FDC, "X"),
+        (0x1FDD, "M", " ̔̀"),
+        (0x1FDE, "M", " ̔́"),
+        (0x1FDF, "M", " ̔͂"),
+        (0x1FE0, "V"),
+        (0x1FE3, "M", "ΰ"),
+        (0x1FE4, "V"),
+        (0x1FE8, "M", "ῠ"),
+        (0x1FE9, "M", "ῡ"),
+        (0x1FEA, "M", "ὺ"),
+        (0x1FEB, "M", "ύ"),
+        (0x1FEC, "M", "ῥ"),
+        (0x1FED, "M", " ̈̀"),
+        (0x1FEE, "M", " ̈́"),
+        (0x1FEF, "M", "`"),
+        (0x1FF0, "X"),
+        (0x1FF2, "M", "ὼι"),
+        (0x1FF3, "M", "ωι"),
+        (0x1FF4, "M", "ώι"),
+        (0x1FF5, "X"),
+        (0x1FF6, "V"),
+        (0x1FF7, "M", "ῶι"),
+        (0x1FF8, "M", "ὸ"),
+        (0x1FF9, "M", "ό"),
+        (0x1FFA, "M", "ὼ"),
+        (0x1FFB, "M", "ώ"),
+        (0x1FFC, "M", "ωι"),
+        (0x1FFD, "M", " ́"),
+        (0x1FFE, "M", " ̔"),
+        (0x1FFF, "X"),
+        (0x2000, "M", " "),
+        (0x200B, "I"),
+        (0x200C, "D", ""),
+        (0x200E, "X"),
+        (0x2010, "V"),
+        (0x2011, "M", "‐"),
+        (0x2012, "V"),
+        (0x2017, "M", " ̳"),
+        (0x2018, "V"),
+        (0x2024, "X"),
+        (0x2027, "V"),
+        (0x2028, "X"),
+        (0x202F, "M", " "),
+        (0x2030, "V"),
+        (0x2033, "M", "′′"),
+        (0x2034, "M", "′′′"),
+        (0x2035, "V"),
+        (0x2036, "M", "‵‵"),
+        (0x2037, "M", "‵‵‵"),
+        (0x2038, "V"),
+        (0x203C, "M", "!!"),
+        (0x203D, "V"),
+        (0x203E, "M", " ̅"),
+        (0x203F, "V"),
+        (0x2047, "M", "??"),
+        (0x2048, "M", "?!"),
+        (0x2049, "M", "!?"),
+        (0x204A, "V"),
+        (0x2057, "M", "′′′′"),
+        (0x2058, "V"),
+        (0x205F, "M", " "),
+        (0x2060, "I"),
+        (0x2065, "X"),
+        (0x206A, "I"),
+        (0x2070, "M", "0"),
+        (0x2071, "M", "i"),
+        (0x2072, "X"),
+        (0x2074, "M", "4"),
+        (0x2075, "M", "5"),
+        (0x2076, "M", "6"),
+        (0x2077, "M", "7"),
+        (0x2078, "M", "8"),
+        (0x2079, "M", "9"),
+        (0x207A, "M", "+"),
+        (0x207B, "M", "−"),
+        (0x207C, "M", "="),
+        (0x207D, "M", "("),
+        (0x207E, "M", ")"),
+        (0x207F, "M", "n"),
+        (0x2080, "M", "0"),
+        (0x2081, "M", "1"),
+        (0x2082, "M", "2"),
+        (0x2083, "M", "3"),
+        (0x2084, "M", "4"),
+        (0x2085, "M", "5"),
+        (0x2086, "M", "6"),
+        (0x2087, "M", "7"),
+    ]
+
+
+def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2088, "M", "8"),
+        (0x2089, "M", "9"),
+        (0x208A, "M", "+"),
+        (0x208B, "M", "−"),
+        (0x208C, "M", "="),
+        (0x208D, "M", "("),
+        (0x208E, "M", ")"),
+        (0x208F, "X"),
+        (0x2090, "M", "a"),
+        (0x2091, "M", "e"),
+        (0x2092, "M", "o"),
+        (0x2093, "M", "x"),
+        (0x2094, "M", "ə"),
+        (0x2095, "M", "h"),
+        (0x2096, "M", "k"),
+        (0x2097, "M", "l"),
+        (0x2098, "M", "m"),
+        (0x2099, "M", "n"),
+        (0x209A, "M", "p"),
+        (0x209B, "M", "s"),
+        (0x209C, "M", "t"),
+        (0x209D, "X"),
+        (0x20A0, "V"),
+        (0x20A8, "M", "rs"),
+        (0x20A9, "V"),
+        (0x20C1, "X"),
+        (0x20D0, "V"),
+        (0x20F1, "X"),
+        (0x2100, "M", "a/c"),
+        (0x2101, "M", "a/s"),
+        (0x2102, "M", "c"),
+        (0x2103, "M", "°c"),
+        (0x2104, "V"),
+        (0x2105, "M", "c/o"),
+        (0x2106, "M", "c/u"),
+        (0x2107, "M", "ɛ"),
+        (0x2108, "V"),
+        (0x2109, "M", "°f"),
+        (0x210A, "M", "g"),
+        (0x210B, "M", "h"),
+        (0x210F, "M", "ħ"),
+        (0x2110, "M", "i"),
+        (0x2112, "M", "l"),
+        (0x2114, "V"),
+        (0x2115, "M", "n"),
+        (0x2116, "M", "no"),
+        (0x2117, "V"),
+        (0x2119, "M", "p"),
+        (0x211A, "M", "q"),
+        (0x211B, "M", "r"),
+        (0x211E, "V"),
+        (0x2120, "M", "sm"),
+        (0x2121, "M", "tel"),
+        (0x2122, "M", "tm"),
+        (0x2123, "V"),
+        (0x2124, "M", "z"),
+        (0x2125, "V"),
+        (0x2126, "M", "ω"),
+        (0x2127, "V"),
+        (0x2128, "M", "z"),
+        (0x2129, "V"),
+        (0x212A, "M", "k"),
+        (0x212B, "M", "å"),
+        (0x212C, "M", "b"),
+        (0x212D, "M", "c"),
+        (0x212E, "V"),
+        (0x212F, "M", "e"),
+        (0x2131, "M", "f"),
+        (0x2132, "M", "ⅎ"),
+        (0x2133, "M", "m"),
+        (0x2134, "M", "o"),
+        (0x2135, "M", "א"),
+        (0x2136, "M", "ב"),
+        (0x2137, "M", "ג"),
+        (0x2138, "M", "ד"),
+        (0x2139, "M", "i"),
+        (0x213A, "V"),
+        (0x213B, "M", "fax"),
+        (0x213C, "M", "π"),
+        (0x213D, "M", "γ"),
+        (0x213F, "M", "π"),
+        (0x2140, "M", "∑"),
+        (0x2141, "V"),
+        (0x2145, "M", "d"),
+        (0x2147, "M", "e"),
+        (0x2148, "M", "i"),
+        (0x2149, "M", "j"),
+        (0x214A, "V"),
+        (0x2150, "M", "1⁄7"),
+        (0x2151, "M", "1⁄9"),
+        (0x2152, "M", "1⁄10"),
+        (0x2153, "M", "1⁄3"),
+        (0x2154, "M", "2⁄3"),
+        (0x2155, "M", "1⁄5"),
+        (0x2156, "M", "2⁄5"),
+        (0x2157, "M", "3⁄5"),
+        (0x2158, "M", "4⁄5"),
+        (0x2159, "M", "1⁄6"),
+        (0x215A, "M", "5⁄6"),
+        (0x215B, "M", "1⁄8"),
+    ]
+
+
+def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x215C, "M", "3⁄8"),
+        (0x215D, "M", "5⁄8"),
+        (0x215E, "M", "7⁄8"),
+        (0x215F, "M", "1⁄"),
+        (0x2160, "M", "i"),
+        (0x2161, "M", "ii"),
+        (0x2162, "M", "iii"),
+        (0x2163, "M", "iv"),
+        (0x2164, "M", "v"),
+        (0x2165, "M", "vi"),
+        (0x2166, "M", "vii"),
+        (0x2167, "M", "viii"),
+        (0x2168, "M", "ix"),
+        (0x2169, "M", "x"),
+        (0x216A, "M", "xi"),
+        (0x216B, "M", "xii"),
+        (0x216C, "M", "l"),
+        (0x216D, "M", "c"),
+        (0x216E, "M", "d"),
+        (0x216F, "M", "m"),
+        (0x2170, "M", "i"),
+        (0x2171, "M", "ii"),
+        (0x2172, "M", "iii"),
+        (0x2173, "M", "iv"),
+        (0x2174, "M", "v"),
+        (0x2175, "M", "vi"),
+        (0x2176, "M", "vii"),
+        (0x2177, "M", "viii"),
+        (0x2178, "M", "ix"),
+        (0x2179, "M", "x"),
+        (0x217A, "M", "xi"),
+        (0x217B, "M", "xii"),
+        (0x217C, "M", "l"),
+        (0x217D, "M", "c"),
+        (0x217E, "M", "d"),
+        (0x217F, "M", "m"),
+        (0x2180, "V"),
+        (0x2183, "M", "ↄ"),
+        (0x2184, "V"),
+        (0x2189, "M", "0⁄3"),
+        (0x218A, "V"),
+        (0x218C, "X"),
+        (0x2190, "V"),
+        (0x222C, "M", "∫∫"),
+        (0x222D, "M", "∫∫∫"),
+        (0x222E, "V"),
+        (0x222F, "M", "∮∮"),
+        (0x2230, "M", "∮∮∮"),
+        (0x2231, "V"),
+        (0x2329, "M", "〈"),
+        (0x232A, "M", "〉"),
+        (0x232B, "V"),
+        (0x242A, "X"),
+        (0x2440, "V"),
+        (0x244B, "X"),
+        (0x2460, "M", "1"),
+        (0x2461, "M", "2"),
+        (0x2462, "M", "3"),
+        (0x2463, "M", "4"),
+        (0x2464, "M", "5"),
+        (0x2465, "M", "6"),
+        (0x2466, "M", "7"),
+        (0x2467, "M", "8"),
+        (0x2468, "M", "9"),
+        (0x2469, "M", "10"),
+        (0x246A, "M", "11"),
+        (0x246B, "M", "12"),
+        (0x246C, "M", "13"),
+        (0x246D, "M", "14"),
+        (0x246E, "M", "15"),
+        (0x246F, "M", "16"),
+        (0x2470, "M", "17"),
+        (0x2471, "M", "18"),
+        (0x2472, "M", "19"),
+        (0x2473, "M", "20"),
+        (0x2474, "M", "(1)"),
+        (0x2475, "M", "(2)"),
+        (0x2476, "M", "(3)"),
+        (0x2477, "M", "(4)"),
+        (0x2478, "M", "(5)"),
+        (0x2479, "M", "(6)"),
+        (0x247A, "M", "(7)"),
+        (0x247B, "M", "(8)"),
+        (0x247C, "M", "(9)"),
+        (0x247D, "M", "(10)"),
+        (0x247E, "M", "(11)"),
+        (0x247F, "M", "(12)"),
+        (0x2480, "M", "(13)"),
+        (0x2481, "M", "(14)"),
+        (0x2482, "M", "(15)"),
+        (0x2483, "M", "(16)"),
+        (0x2484, "M", "(17)"),
+        (0x2485, "M", "(18)"),
+        (0x2486, "M", "(19)"),
+        (0x2487, "M", "(20)"),
+        (0x2488, "X"),
+        (0x249C, "M", "(a)"),
+        (0x249D, "M", "(b)"),
+        (0x249E, "M", "(c)"),
+        (0x249F, "M", "(d)"),
+    ]
+
+
+def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x24A0, "M", "(e)"),
+        (0x24A1, "M", "(f)"),
+        (0x24A2, "M", "(g)"),
+        (0x24A3, "M", "(h)"),
+        (0x24A4, "M", "(i)"),
+        (0x24A5, "M", "(j)"),
+        (0x24A6, "M", "(k)"),
+        (0x24A7, "M", "(l)"),
+        (0x24A8, "M", "(m)"),
+        (0x24A9, "M", "(n)"),
+        (0x24AA, "M", "(o)"),
+        (0x24AB, "M", "(p)"),
+        (0x24AC, "M", "(q)"),
+        (0x24AD, "M", "(r)"),
+        (0x24AE, "M", "(s)"),
+        (0x24AF, "M", "(t)"),
+        (0x24B0, "M", "(u)"),
+        (0x24B1, "M", "(v)"),
+        (0x24B2, "M", "(w)"),
+        (0x24B3, "M", "(x)"),
+        (0x24B4, "M", "(y)"),
+        (0x24B5, "M", "(z)"),
+        (0x24B6, "M", "a"),
+        (0x24B7, "M", "b"),
+        (0x24B8, "M", "c"),
+        (0x24B9, "M", "d"),
+        (0x24BA, "M", "e"),
+        (0x24BB, "M", "f"),
+        (0x24BC, "M", "g"),
+        (0x24BD, "M", "h"),
+        (0x24BE, "M", "i"),
+        (0x24BF, "M", "j"),
+        (0x24C0, "M", "k"),
+        (0x24C1, "M", "l"),
+        (0x24C2, "M", "m"),
+        (0x24C3, "M", "n"),
+        (0x24C4, "M", "o"),
+        (0x24C5, "M", "p"),
+        (0x24C6, "M", "q"),
+        (0x24C7, "M", "r"),
+        (0x24C8, "M", "s"),
+        (0x24C9, "M", "t"),
+        (0x24CA, "M", "u"),
+        (0x24CB, "M", "v"),
+        (0x24CC, "M", "w"),
+        (0x24CD, "M", "x"),
+        (0x24CE, "M", "y"),
+        (0x24CF, "M", "z"),
+        (0x24D0, "M", "a"),
+        (0x24D1, "M", "b"),
+        (0x24D2, "M", "c"),
+        (0x24D3, "M", "d"),
+        (0x24D4, "M", "e"),
+        (0x24D5, "M", "f"),
+        (0x24D6, "M", "g"),
+        (0x24D7, "M", "h"),
+        (0x24D8, "M", "i"),
+        (0x24D9, "M", "j"),
+        (0x24DA, "M", "k"),
+        (0x24DB, "M", "l"),
+        (0x24DC, "M", "m"),
+        (0x24DD, "M", "n"),
+        (0x24DE, "M", "o"),
+        (0x24DF, "M", "p"),
+        (0x24E0, "M", "q"),
+        (0x24E1, "M", "r"),
+        (0x24E2, "M", "s"),
+        (0x24E3, "M", "t"),
+        (0x24E4, "M", "u"),
+        (0x24E5, "M", "v"),
+        (0x24E6, "M", "w"),
+        (0x24E7, "M", "x"),
+        (0x24E8, "M", "y"),
+        (0x24E9, "M", "z"),
+        (0x24EA, "M", "0"),
+        (0x24EB, "V"),
+        (0x2A0C, "M", "∫∫∫∫"),
+        (0x2A0D, "V"),
+        (0x2A74, "M", "::="),
+        (0x2A75, "M", "=="),
+        (0x2A76, "M", "==="),
+        (0x2A77, "V"),
+        (0x2ADC, "M", "⫝̸"),
+        (0x2ADD, "V"),
+        (0x2B74, "X"),
+        (0x2B76, "V"),
+        (0x2B96, "X"),
+        (0x2B97, "V"),
+        (0x2C00, "M", "ⰰ"),
+        (0x2C01, "M", "ⰱ"),
+        (0x2C02, "M", "ⰲ"),
+        (0x2C03, "M", "ⰳ"),
+        (0x2C04, "M", "ⰴ"),
+        (0x2C05, "M", "ⰵ"),
+        (0x2C06, "M", "ⰶ"),
+        (0x2C07, "M", "ⰷ"),
+        (0x2C08, "M", "ⰸ"),
+        (0x2C09, "M", "ⰹ"),
+        (0x2C0A, "M", "ⰺ"),
+        (0x2C0B, "M", "ⰻ"),
+    ]
+
+
+def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2C0C, "M", "ⰼ"),
+        (0x2C0D, "M", "ⰽ"),
+        (0x2C0E, "M", "ⰾ"),
+        (0x2C0F, "M", "ⰿ"),
+        (0x2C10, "M", "ⱀ"),
+        (0x2C11, "M", "ⱁ"),
+        (0x2C12, "M", "ⱂ"),
+        (0x2C13, "M", "ⱃ"),
+        (0x2C14, "M", "ⱄ"),
+        (0x2C15, "M", "ⱅ"),
+        (0x2C16, "M", "ⱆ"),
+        (0x2C17, "M", "ⱇ"),
+        (0x2C18, "M", "ⱈ"),
+        (0x2C19, "M", "ⱉ"),
+        (0x2C1A, "M", "ⱊ"),
+        (0x2C1B, "M", "ⱋ"),
+        (0x2C1C, "M", "ⱌ"),
+        (0x2C1D, "M", "ⱍ"),
+        (0x2C1E, "M", "ⱎ"),
+        (0x2C1F, "M", "ⱏ"),
+        (0x2C20, "M", "ⱐ"),
+        (0x2C21, "M", "ⱑ"),
+        (0x2C22, "M", "ⱒ"),
+        (0x2C23, "M", "ⱓ"),
+        (0x2C24, "M", "ⱔ"),
+        (0x2C25, "M", "ⱕ"),
+        (0x2C26, "M", "ⱖ"),
+        (0x2C27, "M", "ⱗ"),
+        (0x2C28, "M", "ⱘ"),
+        (0x2C29, "M", "ⱙ"),
+        (0x2C2A, "M", "ⱚ"),
+        (0x2C2B, "M", "ⱛ"),
+        (0x2C2C, "M", "ⱜ"),
+        (0x2C2D, "M", "ⱝ"),
+        (0x2C2E, "M", "ⱞ"),
+        (0x2C2F, "M", "ⱟ"),
+        (0x2C30, "V"),
+        (0x2C60, "M", "ⱡ"),
+        (0x2C61, "V"),
+        (0x2C62, "M", "ɫ"),
+        (0x2C63, "M", "ᵽ"),
+        (0x2C64, "M", "ɽ"),
+        (0x2C65, "V"),
+        (0x2C67, "M", "ⱨ"),
+        (0x2C68, "V"),
+        (0x2C69, "M", "ⱪ"),
+        (0x2C6A, "V"),
+        (0x2C6B, "M", "ⱬ"),
+        (0x2C6C, "V"),
+        (0x2C6D, "M", "ɑ"),
+        (0x2C6E, "M", "ɱ"),
+        (0x2C6F, "M", "ɐ"),
+        (0x2C70, "M", "ɒ"),
+        (0x2C71, "V"),
+        (0x2C72, "M", "ⱳ"),
+        (0x2C73, "V"),
+        (0x2C75, "M", "ⱶ"),
+        (0x2C76, "V"),
+        (0x2C7C, "M", "j"),
+        (0x2C7D, "M", "v"),
+        (0x2C7E, "M", "ȿ"),
+        (0x2C7F, "M", "ɀ"),
+        (0x2C80, "M", "ⲁ"),
+        (0x2C81, "V"),
+        (0x2C82, "M", "ⲃ"),
+        (0x2C83, "V"),
+        (0x2C84, "M", "ⲅ"),
+        (0x2C85, "V"),
+        (0x2C86, "M", "ⲇ"),
+        (0x2C87, "V"),
+        (0x2C88, "M", "ⲉ"),
+        (0x2C89, "V"),
+        (0x2C8A, "M", "ⲋ"),
+        (0x2C8B, "V"),
+        (0x2C8C, "M", "ⲍ"),
+        (0x2C8D, "V"),
+        (0x2C8E, "M", "ⲏ"),
+        (0x2C8F, "V"),
+        (0x2C90, "M", "ⲑ"),
+        (0x2C91, "V"),
+        (0x2C92, "M", "ⲓ"),
+        (0x2C93, "V"),
+        (0x2C94, "M", "ⲕ"),
+        (0x2C95, "V"),
+        (0x2C96, "M", "ⲗ"),
+        (0x2C97, "V"),
+        (0x2C98, "M", "ⲙ"),
+        (0x2C99, "V"),
+        (0x2C9A, "M", "ⲛ"),
+        (0x2C9B, "V"),
+        (0x2C9C, "M", "ⲝ"),
+        (0x2C9D, "V"),
+        (0x2C9E, "M", "ⲟ"),
+        (0x2C9F, "V"),
+        (0x2CA0, "M", "ⲡ"),
+        (0x2CA1, "V"),
+        (0x2CA2, "M", "ⲣ"),
+        (0x2CA3, "V"),
+        (0x2CA4, "M", "ⲥ"),
+        (0x2CA5, "V"),
+    ]
+
+
+def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2CA6, "M", "ⲧ"),
+        (0x2CA7, "V"),
+        (0x2CA8, "M", "ⲩ"),
+        (0x2CA9, "V"),
+        (0x2CAA, "M", "ⲫ"),
+        (0x2CAB, "V"),
+        (0x2CAC, "M", "ⲭ"),
+        (0x2CAD, "V"),
+        (0x2CAE, "M", "ⲯ"),
+        (0x2CAF, "V"),
+        (0x2CB0, "M", "ⲱ"),
+        (0x2CB1, "V"),
+        (0x2CB2, "M", "ⲳ"),
+        (0x2CB3, "V"),
+        (0x2CB4, "M", "ⲵ"),
+        (0x2CB5, "V"),
+        (0x2CB6, "M", "ⲷ"),
+        (0x2CB7, "V"),
+        (0x2CB8, "M", "ⲹ"),
+        (0x2CB9, "V"),
+        (0x2CBA, "M", "ⲻ"),
+        (0x2CBB, "V"),
+        (0x2CBC, "M", "ⲽ"),
+        (0x2CBD, "V"),
+        (0x2CBE, "M", "ⲿ"),
+        (0x2CBF, "V"),
+        (0x2CC0, "M", "ⳁ"),
+        (0x2CC1, "V"),
+        (0x2CC2, "M", "ⳃ"),
+        (0x2CC3, "V"),
+        (0x2CC4, "M", "ⳅ"),
+        (0x2CC5, "V"),
+        (0x2CC6, "M", "ⳇ"),
+        (0x2CC7, "V"),
+        (0x2CC8, "M", "ⳉ"),
+        (0x2CC9, "V"),
+        (0x2CCA, "M", "ⳋ"),
+        (0x2CCB, "V"),
+        (0x2CCC, "M", "ⳍ"),
+        (0x2CCD, "V"),
+        (0x2CCE, "M", "ⳏ"),
+        (0x2CCF, "V"),
+        (0x2CD0, "M", "ⳑ"),
+        (0x2CD1, "V"),
+        (0x2CD2, "M", "ⳓ"),
+        (0x2CD3, "V"),
+        (0x2CD4, "M", "ⳕ"),
+        (0x2CD5, "V"),
+        (0x2CD6, "M", "ⳗ"),
+        (0x2CD7, "V"),
+        (0x2CD8, "M", "ⳙ"),
+        (0x2CD9, "V"),
+        (0x2CDA, "M", "ⳛ"),
+        (0x2CDB, "V"),
+        (0x2CDC, "M", "ⳝ"),
+        (0x2CDD, "V"),
+        (0x2CDE, "M", "ⳟ"),
+        (0x2CDF, "V"),
+        (0x2CE0, "M", "ⳡ"),
+        (0x2CE1, "V"),
+        (0x2CE2, "M", "ⳣ"),
+        (0x2CE3, "V"),
+        (0x2CEB, "M", "ⳬ"),
+        (0x2CEC, "V"),
+        (0x2CED, "M", "ⳮ"),
+        (0x2CEE, "V"),
+        (0x2CF2, "M", "ⳳ"),
+        (0x2CF3, "V"),
+        (0x2CF4, "X"),
+        (0x2CF9, "V"),
+        (0x2D26, "X"),
+        (0x2D27, "V"),
+        (0x2D28, "X"),
+        (0x2D2D, "V"),
+        (0x2D2E, "X"),
+        (0x2D30, "V"),
+        (0x2D68, "X"),
+        (0x2D6F, "M", "ⵡ"),
+        (0x2D70, "V"),
+        (0x2D71, "X"),
+        (0x2D7F, "V"),
+        (0x2D97, "X"),
+        (0x2DA0, "V"),
+        (0x2DA7, "X"),
+        (0x2DA8, "V"),
+        (0x2DAF, "X"),
+        (0x2DB0, "V"),
+        (0x2DB7, "X"),
+        (0x2DB8, "V"),
+        (0x2DBF, "X"),
+        (0x2DC0, "V"),
+        (0x2DC7, "X"),
+        (0x2DC8, "V"),
+        (0x2DCF, "X"),
+        (0x2DD0, "V"),
+        (0x2DD7, "X"),
+        (0x2DD8, "V"),
+        (0x2DDF, "X"),
+        (0x2DE0, "V"),
+        (0x2E5E, "X"),
+    ]
+
+
+def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2E80, "V"),
+        (0x2E9A, "X"),
+        (0x2E9B, "V"),
+        (0x2E9F, "M", "母"),
+        (0x2EA0, "V"),
+        (0x2EF3, "M", "龟"),
+        (0x2EF4, "X"),
+        (0x2F00, "M", "一"),
+        (0x2F01, "M", "丨"),
+        (0x2F02, "M", "丶"),
+        (0x2F03, "M", "丿"),
+        (0x2F04, "M", "乙"),
+        (0x2F05, "M", "亅"),
+        (0x2F06, "M", "二"),
+        (0x2F07, "M", "亠"),
+        (0x2F08, "M", "人"),
+        (0x2F09, "M", "儿"),
+        (0x2F0A, "M", "入"),
+        (0x2F0B, "M", "八"),
+        (0x2F0C, "M", "冂"),
+        (0x2F0D, "M", "冖"),
+        (0x2F0E, "M", "冫"),
+        (0x2F0F, "M", "几"),
+        (0x2F10, "M", "凵"),
+        (0x2F11, "M", "刀"),
+        (0x2F12, "M", "力"),
+        (0x2F13, "M", "勹"),
+        (0x2F14, "M", "匕"),
+        (0x2F15, "M", "匚"),
+        (0x2F16, "M", "匸"),
+        (0x2F17, "M", "十"),
+        (0x2F18, "M", "卜"),
+        (0x2F19, "M", "卩"),
+        (0x2F1A, "M", "厂"),
+        (0x2F1B, "M", "厶"),
+        (0x2F1C, "M", "又"),
+        (0x2F1D, "M", "口"),
+        (0x2F1E, "M", "囗"),
+        (0x2F1F, "M", "土"),
+        (0x2F20, "M", "士"),
+        (0x2F21, "M", "夂"),
+        (0x2F22, "M", "夊"),
+        (0x2F23, "M", "夕"),
+        (0x2F24, "M", "大"),
+        (0x2F25, "M", "女"),
+        (0x2F26, "M", "子"),
+        (0x2F27, "M", "宀"),
+        (0x2F28, "M", "寸"),
+        (0x2F29, "M", "小"),
+        (0x2F2A, "M", "尢"),
+        (0x2F2B, "M", "尸"),
+        (0x2F2C, "M", "屮"),
+        (0x2F2D, "M", "山"),
+        (0x2F2E, "M", "巛"),
+        (0x2F2F, "M", "工"),
+        (0x2F30, "M", "己"),
+        (0x2F31, "M", "巾"),
+        (0x2F32, "M", "干"),
+        (0x2F33, "M", "幺"),
+        (0x2F34, "M", "广"),
+        (0x2F35, "M", "廴"),
+        (0x2F36, "M", "廾"),
+        (0x2F37, "M", "弋"),
+        (0x2F38, "M", "弓"),
+        (0x2F39, "M", "彐"),
+        (0x2F3A, "M", "彡"),
+        (0x2F3B, "M", "彳"),
+        (0x2F3C, "M", "心"),
+        (0x2F3D, "M", "戈"),
+        (0x2F3E, "M", "戶"),
+        (0x2F3F, "M", "手"),
+        (0x2F40, "M", "支"),
+        (0x2F41, "M", "攴"),
+        (0x2F42, "M", "文"),
+        (0x2F43, "M", "斗"),
+        (0x2F44, "M", "斤"),
+        (0x2F45, "M", "方"),
+        (0x2F46, "M", "无"),
+        (0x2F47, "M", "日"),
+        (0x2F48, "M", "曰"),
+        (0x2F49, "M", "月"),
+        (0x2F4A, "M", "木"),
+        (0x2F4B, "M", "欠"),
+        (0x2F4C, "M", "止"),
+        (0x2F4D, "M", "歹"),
+        (0x2F4E, "M", "殳"),
+        (0x2F4F, "M", "毋"),
+        (0x2F50, "M", "比"),
+        (0x2F51, "M", "毛"),
+        (0x2F52, "M", "氏"),
+        (0x2F53, "M", "气"),
+        (0x2F54, "M", "水"),
+        (0x2F55, "M", "火"),
+        (0x2F56, "M", "爪"),
+        (0x2F57, "M", "父"),
+        (0x2F58, "M", "爻"),
+        (0x2F59, "M", "爿"),
+        (0x2F5A, "M", "片"),
+        (0x2F5B, "M", "牙"),
+        (0x2F5C, "M", "牛"),
+    ]
+
+
+def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F5D, "M", "犬"),
+        (0x2F5E, "M", "玄"),
+        (0x2F5F, "M", "玉"),
+        (0x2F60, "M", "瓜"),
+        (0x2F61, "M", "瓦"),
+        (0x2F62, "M", "甘"),
+        (0x2F63, "M", "生"),
+        (0x2F64, "M", "用"),
+        (0x2F65, "M", "田"),
+        (0x2F66, "M", "疋"),
+        (0x2F67, "M", "疒"),
+        (0x2F68, "M", "癶"),
+        (0x2F69, "M", "白"),
+        (0x2F6A, "M", "皮"),
+        (0x2F6B, "M", "皿"),
+        (0x2F6C, "M", "目"),
+        (0x2F6D, "M", "矛"),
+        (0x2F6E, "M", "矢"),
+        (0x2F6F, "M", "石"),
+        (0x2F70, "M", "示"),
+        (0x2F71, "M", "禸"),
+        (0x2F72, "M", "禾"),
+        (0x2F73, "M", "穴"),
+        (0x2F74, "M", "立"),
+        (0x2F75, "M", "竹"),
+        (0x2F76, "M", "米"),
+        (0x2F77, "M", "糸"),
+        (0x2F78, "M", "缶"),
+        (0x2F79, "M", "网"),
+        (0x2F7A, "M", "羊"),
+        (0x2F7B, "M", "羽"),
+        (0x2F7C, "M", "老"),
+        (0x2F7D, "M", "而"),
+        (0x2F7E, "M", "耒"),
+        (0x2F7F, "M", "耳"),
+        (0x2F80, "M", "聿"),
+        (0x2F81, "M", "肉"),
+        (0x2F82, "M", "臣"),
+        (0x2F83, "M", "自"),
+        (0x2F84, "M", "至"),
+        (0x2F85, "M", "臼"),
+        (0x2F86, "M", "舌"),
+        (0x2F87, "M", "舛"),
+        (0x2F88, "M", "舟"),
+        (0x2F89, "M", "艮"),
+        (0x2F8A, "M", "色"),
+        (0x2F8B, "M", "艸"),
+        (0x2F8C, "M", "虍"),
+        (0x2F8D, "M", "虫"),
+        (0x2F8E, "M", "血"),
+        (0x2F8F, "M", "行"),
+        (0x2F90, "M", "衣"),
+        (0x2F91, "M", "襾"),
+        (0x2F92, "M", "見"),
+        (0x2F93, "M", "角"),
+        (0x2F94, "M", "言"),
+        (0x2F95, "M", "谷"),
+        (0x2F96, "M", "豆"),
+        (0x2F97, "M", "豕"),
+        (0x2F98, "M", "豸"),
+        (0x2F99, "M", "貝"),
+        (0x2F9A, "M", "赤"),
+        (0x2F9B, "M", "走"),
+        (0x2F9C, "M", "足"),
+        (0x2F9D, "M", "身"),
+        (0x2F9E, "M", "車"),
+        (0x2F9F, "M", "辛"),
+        (0x2FA0, "M", "辰"),
+        (0x2FA1, "M", "辵"),
+        (0x2FA2, "M", "邑"),
+        (0x2FA3, "M", "酉"),
+        (0x2FA4, "M", "釆"),
+        (0x2FA5, "M", "里"),
+        (0x2FA6, "M", "金"),
+        (0x2FA7, "M", "長"),
+        (0x2FA8, "M", "門"),
+        (0x2FA9, "M", "阜"),
+        (0x2FAA, "M", "隶"),
+        (0x2FAB, "M", "隹"),
+        (0x2FAC, "M", "雨"),
+        (0x2FAD, "M", "靑"),
+        (0x2FAE, "M", "非"),
+        (0x2FAF, "M", "面"),
+        (0x2FB0, "M", "革"),
+        (0x2FB1, "M", "韋"),
+        (0x2FB2, "M", "韭"),
+        (0x2FB3, "M", "音"),
+        (0x2FB4, "M", "頁"),
+        (0x2FB5, "M", "風"),
+        (0x2FB6, "M", "飛"),
+        (0x2FB7, "M", "食"),
+        (0x2FB8, "M", "首"),
+        (0x2FB9, "M", "香"),
+        (0x2FBA, "M", "馬"),
+        (0x2FBB, "M", "骨"),
+        (0x2FBC, "M", "高"),
+        (0x2FBD, "M", "髟"),
+        (0x2FBE, "M", "鬥"),
+        (0x2FBF, "M", "鬯"),
+        (0x2FC0, "M", "鬲"),
+    ]
+
+
+def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2FC1, "M", "鬼"),
+        (0x2FC2, "M", "魚"),
+        (0x2FC3, "M", "鳥"),
+        (0x2FC4, "M", "鹵"),
+        (0x2FC5, "M", "鹿"),
+        (0x2FC6, "M", "麥"),
+        (0x2FC7, "M", "麻"),
+        (0x2FC8, "M", "黃"),
+        (0x2FC9, "M", "黍"),
+        (0x2FCA, "M", "黑"),
+        (0x2FCB, "M", "黹"),
+        (0x2FCC, "M", "黽"),
+        (0x2FCD, "M", "鼎"),
+        (0x2FCE, "M", "鼓"),
+        (0x2FCF, "M", "鼠"),
+        (0x2FD0, "M", "鼻"),
+        (0x2FD1, "M", "齊"),
+        (0x2FD2, "M", "齒"),
+        (0x2FD3, "M", "龍"),
+        (0x2FD4, "M", "龜"),
+        (0x2FD5, "M", "龠"),
+        (0x2FD6, "X"),
+        (0x3000, "M", " "),
+        (0x3001, "V"),
+        (0x3002, "M", "."),
+        (0x3003, "V"),
+        (0x3036, "M", "〒"),
+        (0x3037, "V"),
+        (0x3038, "M", "十"),
+        (0x3039, "M", "卄"),
+        (0x303A, "M", "卅"),
+        (0x303B, "V"),
+        (0x3040, "X"),
+        (0x3041, "V"),
+        (0x3097, "X"),
+        (0x3099, "V"),
+        (0x309B, "M", " ゙"),
+        (0x309C, "M", " ゚"),
+        (0x309D, "V"),
+        (0x309F, "M", "より"),
+        (0x30A0, "V"),
+        (0x30FF, "M", "コト"),
+        (0x3100, "X"),
+        (0x3105, "V"),
+        (0x3130, "X"),
+        (0x3131, "M", "ᄀ"),
+        (0x3132, "M", "ᄁ"),
+        (0x3133, "M", "ᆪ"),
+        (0x3134, "M", "ᄂ"),
+        (0x3135, "M", "ᆬ"),
+        (0x3136, "M", "ᆭ"),
+        (0x3137, "M", "ᄃ"),
+        (0x3138, "M", "ᄄ"),
+        (0x3139, "M", "ᄅ"),
+        (0x313A, "M", "ᆰ"),
+        (0x313B, "M", "ᆱ"),
+        (0x313C, "M", "ᆲ"),
+        (0x313D, "M", "ᆳ"),
+        (0x313E, "M", "ᆴ"),
+        (0x313F, "M", "ᆵ"),
+        (0x3140, "M", "ᄚ"),
+        (0x3141, "M", "ᄆ"),
+        (0x3142, "M", "ᄇ"),
+        (0x3143, "M", "ᄈ"),
+        (0x3144, "M", "ᄡ"),
+        (0x3145, "M", "ᄉ"),
+        (0x3146, "M", "ᄊ"),
+        (0x3147, "M", "ᄋ"),
+        (0x3148, "M", "ᄌ"),
+        (0x3149, "M", "ᄍ"),
+        (0x314A, "M", "ᄎ"),
+        (0x314B, "M", "ᄏ"),
+        (0x314C, "M", "ᄐ"),
+        (0x314D, "M", "ᄑ"),
+        (0x314E, "M", "ᄒ"),
+        (0x314F, "M", "ᅡ"),
+        (0x3150, "M", "ᅢ"),
+        (0x3151, "M", "ᅣ"),
+        (0x3152, "M", "ᅤ"),
+        (0x3153, "M", "ᅥ"),
+        (0x3154, "M", "ᅦ"),
+        (0x3155, "M", "ᅧ"),
+        (0x3156, "M", "ᅨ"),
+        (0x3157, "M", "ᅩ"),
+        (0x3158, "M", "ᅪ"),
+        (0x3159, "M", "ᅫ"),
+        (0x315A, "M", "ᅬ"),
+        (0x315B, "M", "ᅭ"),
+        (0x315C, "M", "ᅮ"),
+        (0x315D, "M", "ᅯ"),
+        (0x315E, "M", "ᅰ"),
+        (0x315F, "M", "ᅱ"),
+        (0x3160, "M", "ᅲ"),
+        (0x3161, "M", "ᅳ"),
+        (0x3162, "M", "ᅴ"),
+        (0x3163, "M", "ᅵ"),
+        (0x3164, "I"),
+        (0x3165, "M", "ᄔ"),
+        (0x3166, "M", "ᄕ"),
+        (0x3167, "M", "ᇇ"),
+    ]
+
+
+def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x3168, "M", "ᇈ"),
+        (0x3169, "M", "ᇌ"),
+        (0x316A, "M", "ᇎ"),
+        (0x316B, "M", "ᇓ"),
+        (0x316C, "M", "ᇗ"),
+        (0x316D, "M", "ᇙ"),
+        (0x316E, "M", "ᄜ"),
+        (0x316F, "M", "ᇝ"),
+        (0x3170, "M", "ᇟ"),
+        (0x3171, "M", "ᄝ"),
+        (0x3172, "M", "ᄞ"),
+        (0x3173, "M", "ᄠ"),
+        (0x3174, "M", "ᄢ"),
+        (0x3175, "M", "ᄣ"),
+        (0x3176, "M", "ᄧ"),
+        (0x3177, "M", "ᄩ"),
+        (0x3178, "M", "ᄫ"),
+        (0x3179, "M", "ᄬ"),
+        (0x317A, "M", "ᄭ"),
+        (0x317B, "M", "ᄮ"),
+        (0x317C, "M", "ᄯ"),
+        (0x317D, "M", "ᄲ"),
+        (0x317E, "M", "ᄶ"),
+        (0x317F, "M", "ᅀ"),
+        (0x3180, "M", "ᅇ"),
+        (0x3181, "M", "ᅌ"),
+        (0x3182, "M", "ᇱ"),
+        (0x3183, "M", "ᇲ"),
+        (0x3184, "M", "ᅗ"),
+        (0x3185, "M", "ᅘ"),
+        (0x3186, "M", "ᅙ"),
+        (0x3187, "M", "ᆄ"),
+        (0x3188, "M", "ᆅ"),
+        (0x3189, "M", "ᆈ"),
+        (0x318A, "M", "ᆑ"),
+        (0x318B, "M", "ᆒ"),
+        (0x318C, "M", "ᆔ"),
+        (0x318D, "M", "ᆞ"),
+        (0x318E, "M", "ᆡ"),
+        (0x318F, "X"),
+        (0x3190, "V"),
+        (0x3192, "M", "一"),
+        (0x3193, "M", "二"),
+        (0x3194, "M", "三"),
+        (0x3195, "M", "四"),
+        (0x3196, "M", "上"),
+        (0x3197, "M", "中"),
+        (0x3198, "M", "下"),
+        (0x3199, "M", "甲"),
+        (0x319A, "M", "乙"),
+        (0x319B, "M", "丙"),
+        (0x319C, "M", "丁"),
+        (0x319D, "M", "天"),
+        (0x319E, "M", "地"),
+        (0x319F, "M", "人"),
+        (0x31A0, "V"),
+        (0x31E6, "X"),
+        (0x31F0, "V"),
+        (0x3200, "M", "(ᄀ)"),
+        (0x3201, "M", "(ᄂ)"),
+        (0x3202, "M", "(ᄃ)"),
+        (0x3203, "M", "(ᄅ)"),
+        (0x3204, "M", "(ᄆ)"),
+        (0x3205, "M", "(ᄇ)"),
+        (0x3206, "M", "(ᄉ)"),
+        (0x3207, "M", "(ᄋ)"),
+        (0x3208, "M", "(ᄌ)"),
+        (0x3209, "M", "(ᄎ)"),
+        (0x320A, "M", "(ᄏ)"),
+        (0x320B, "M", "(ᄐ)"),
+        (0x320C, "M", "(ᄑ)"),
+        (0x320D, "M", "(ᄒ)"),
+        (0x320E, "M", "(가)"),
+        (0x320F, "M", "(나)"),
+        (0x3210, "M", "(다)"),
+        (0x3211, "M", "(라)"),
+        (0x3212, "M", "(마)"),
+        (0x3213, "M", "(바)"),
+        (0x3214, "M", "(사)"),
+        (0x3215, "M", "(아)"),
+        (0x3216, "M", "(자)"),
+        (0x3217, "M", "(차)"),
+        (0x3218, "M", "(카)"),
+        (0x3219, "M", "(타)"),
+        (0x321A, "M", "(파)"),
+        (0x321B, "M", "(하)"),
+        (0x321C, "M", "(주)"),
+        (0x321D, "M", "(오전)"),
+        (0x321E, "M", "(오후)"),
+        (0x321F, "X"),
+        (0x3220, "M", "(一)"),
+        (0x3221, "M", "(二)"),
+        (0x3222, "M", "(三)"),
+        (0x3223, "M", "(四)"),
+        (0x3224, "M", "(五)"),
+        (0x3225, "M", "(六)"),
+        (0x3226, "M", "(七)"),
+        (0x3227, "M", "(八)"),
+        (0x3228, "M", "(九)"),
+        (0x3229, "M", "(十)"),
+    ]
+
+
+def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x322A, "M", "(月)"),
+        (0x322B, "M", "(火)"),
+        (0x322C, "M", "(水)"),
+        (0x322D, "M", "(木)"),
+        (0x322E, "M", "(金)"),
+        (0x322F, "M", "(土)"),
+        (0x3230, "M", "(日)"),
+        (0x3231, "M", "(株)"),
+        (0x3232, "M", "(有)"),
+        (0x3233, "M", "(社)"),
+        (0x3234, "M", "(名)"),
+        (0x3235, "M", "(特)"),
+        (0x3236, "M", "(財)"),
+        (0x3237, "M", "(祝)"),
+        (0x3238, "M", "(労)"),
+        (0x3239, "M", "(代)"),
+        (0x323A, "M", "(呼)"),
+        (0x323B, "M", "(学)"),
+        (0x323C, "M", "(監)"),
+        (0x323D, "M", "(企)"),
+        (0x323E, "M", "(資)"),
+        (0x323F, "M", "(協)"),
+        (0x3240, "M", "(祭)"),
+        (0x3241, "M", "(休)"),
+        (0x3242, "M", "(自)"),
+        (0x3243, "M", "(至)"),
+        (0x3244, "M", "問"),
+        (0x3245, "M", "幼"),
+        (0x3246, "M", "文"),
+        (0x3247, "M", "箏"),
+        (0x3248, "V"),
+        (0x3250, "M", "pte"),
+        (0x3251, "M", "21"),
+        (0x3252, "M", "22"),
+        (0x3253, "M", "23"),
+        (0x3254, "M", "24"),
+        (0x3255, "M", "25"),
+        (0x3256, "M", "26"),
+        (0x3257, "M", "27"),
+        (0x3258, "M", "28"),
+        (0x3259, "M", "29"),
+        (0x325A, "M", "30"),
+        (0x325B, "M", "31"),
+        (0x325C, "M", "32"),
+        (0x325D, "M", "33"),
+        (0x325E, "M", "34"),
+        (0x325F, "M", "35"),
+        (0x3260, "M", "ᄀ"),
+        (0x3261, "M", "ᄂ"),
+        (0x3262, "M", "ᄃ"),
+        (0x3263, "M", "ᄅ"),
+        (0x3264, "M", "ᄆ"),
+        (0x3265, "M", "ᄇ"),
+        (0x3266, "M", "ᄉ"),
+        (0x3267, "M", "ᄋ"),
+        (0x3268, "M", "ᄌ"),
+        (0x3269, "M", "ᄎ"),
+        (0x326A, "M", "ᄏ"),
+        (0x326B, "M", "ᄐ"),
+        (0x326C, "M", "ᄑ"),
+        (0x326D, "M", "ᄒ"),
+        (0x326E, "M", "가"),
+        (0x326F, "M", "나"),
+        (0x3270, "M", "다"),
+        (0x3271, "M", "라"),
+        (0x3272, "M", "마"),
+        (0x3273, "M", "바"),
+        (0x3274, "M", "사"),
+        (0x3275, "M", "아"),
+        (0x3276, "M", "자"),
+        (0x3277, "M", "차"),
+        (0x3278, "M", "카"),
+        (0x3279, "M", "타"),
+        (0x327A, "M", "파"),
+        (0x327B, "M", "하"),
+        (0x327C, "M", "참고"),
+        (0x327D, "M", "주의"),
+        (0x327E, "M", "우"),
+        (0x327F, "V"),
+        (0x3280, "M", "一"),
+        (0x3281, "M", "二"),
+        (0x3282, "M", "三"),
+        (0x3283, "M", "四"),
+        (0x3284, "M", "五"),
+        (0x3285, "M", "六"),
+        (0x3286, "M", "七"),
+        (0x3287, "M", "八"),
+        (0x3288, "M", "九"),
+        (0x3289, "M", "十"),
+        (0x328A, "M", "月"),
+        (0x328B, "M", "火"),
+        (0x328C, "M", "水"),
+        (0x328D, "M", "木"),
+        (0x328E, "M", "金"),
+        (0x328F, "M", "土"),
+        (0x3290, "M", "日"),
+        (0x3291, "M", "株"),
+        (0x3292, "M", "有"),
+        (0x3293, "M", "社"),
+        (0x3294, "M", "名"),
+    ]
+
+
+def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x3295, "M", "特"),
+        (0x3296, "M", "財"),
+        (0x3297, "M", "祝"),
+        (0x3298, "M", "労"),
+        (0x3299, "M", "秘"),
+        (0x329A, "M", "男"),
+        (0x329B, "M", "女"),
+        (0x329C, "M", "適"),
+        (0x329D, "M", "優"),
+        (0x329E, "M", "印"),
+        (0x329F, "M", "注"),
+        (0x32A0, "M", "項"),
+        (0x32A1, "M", "休"),
+        (0x32A2, "M", "写"),
+        (0x32A3, "M", "正"),
+        (0x32A4, "M", "上"),
+        (0x32A5, "M", "中"),
+        (0x32A6, "M", "下"),
+        (0x32A7, "M", "左"),
+        (0x32A8, "M", "右"),
+        (0x32A9, "M", "医"),
+        (0x32AA, "M", "宗"),
+        (0x32AB, "M", "学"),
+        (0x32AC, "M", "監"),
+        (0x32AD, "M", "企"),
+        (0x32AE, "M", "資"),
+        (0x32AF, "M", "協"),
+        (0x32B0, "M", "夜"),
+        (0x32B1, "M", "36"),
+        (0x32B2, "M", "37"),
+        (0x32B3, "M", "38"),
+        (0x32B4, "M", "39"),
+        (0x32B5, "M", "40"),
+        (0x32B6, "M", "41"),
+        (0x32B7, "M", "42"),
+        (0x32B8, "M", "43"),
+        (0x32B9, "M", "44"),
+        (0x32BA, "M", "45"),
+        (0x32BB, "M", "46"),
+        (0x32BC, "M", "47"),
+        (0x32BD, "M", "48"),
+        (0x32BE, "M", "49"),
+        (0x32BF, "M", "50"),
+        (0x32C0, "M", "1月"),
+        (0x32C1, "M", "2月"),
+        (0x32C2, "M", "3月"),
+        (0x32C3, "M", "4月"),
+        (0x32C4, "M", "5月"),
+        (0x32C5, "M", "6月"),
+        (0x32C6, "M", "7月"),
+        (0x32C7, "M", "8月"),
+        (0x32C8, "M", "9月"),
+        (0x32C9, "M", "10月"),
+        (0x32CA, "M", "11月"),
+        (0x32CB, "M", "12月"),
+        (0x32CC, "M", "hg"),
+        (0x32CD, "M", "erg"),
+        (0x32CE, "M", "ev"),
+        (0x32CF, "M", "ltd"),
+        (0x32D0, "M", "ア"),
+        (0x32D1, "M", "イ"),
+        (0x32D2, "M", "ウ"),
+        (0x32D3, "M", "エ"),
+        (0x32D4, "M", "オ"),
+        (0x32D5, "M", "カ"),
+        (0x32D6, "M", "キ"),
+        (0x32D7, "M", "ク"),
+        (0x32D8, "M", "ケ"),
+        (0x32D9, "M", "コ"),
+        (0x32DA, "M", "サ"),
+        (0x32DB, "M", "シ"),
+        (0x32DC, "M", "ス"),
+        (0x32DD, "M", "セ"),
+        (0x32DE, "M", "ソ"),
+        (0x32DF, "M", "タ"),
+        (0x32E0, "M", "チ"),
+        (0x32E1, "M", "ツ"),
+        (0x32E2, "M", "テ"),
+        (0x32E3, "M", "ト"),
+        (0x32E4, "M", "ナ"),
+        (0x32E5, "M", "ニ"),
+        (0x32E6, "M", "ヌ"),
+        (0x32E7, "M", "ネ"),
+        (0x32E8, "M", "ノ"),
+        (0x32E9, "M", "ハ"),
+        (0x32EA, "M", "ヒ"),
+        (0x32EB, "M", "フ"),
+        (0x32EC, "M", "ヘ"),
+        (0x32ED, "M", "ホ"),
+        (0x32EE, "M", "マ"),
+        (0x32EF, "M", "ミ"),
+        (0x32F0, "M", "ム"),
+        (0x32F1, "M", "メ"),
+        (0x32F2, "M", "モ"),
+        (0x32F3, "M", "ヤ"),
+        (0x32F4, "M", "ユ"),
+        (0x32F5, "M", "ヨ"),
+        (0x32F6, "M", "ラ"),
+        (0x32F7, "M", "リ"),
+        (0x32F8, "M", "ル"),
+    ]
+
+
+def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x32F9, "M", "レ"),
+        (0x32FA, "M", "ロ"),
+        (0x32FB, "M", "ワ"),
+        (0x32FC, "M", "ヰ"),
+        (0x32FD, "M", "ヱ"),
+        (0x32FE, "M", "ヲ"),
+        (0x32FF, "M", "令和"),
+        (0x3300, "M", "アパート"),
+        (0x3301, "M", "アルファ"),
+        (0x3302, "M", "アンペア"),
+        (0x3303, "M", "アール"),
+        (0x3304, "M", "イニング"),
+        (0x3305, "M", "インチ"),
+        (0x3306, "M", "ウォン"),
+        (0x3307, "M", "エスクード"),
+        (0x3308, "M", "エーカー"),
+        (0x3309, "M", "オンス"),
+        (0x330A, "M", "オーム"),
+        (0x330B, "M", "カイリ"),
+        (0x330C, "M", "カラット"),
+        (0x330D, "M", "カロリー"),
+        (0x330E, "M", "ガロン"),
+        (0x330F, "M", "ガンマ"),
+        (0x3310, "M", "ギガ"),
+        (0x3311, "M", "ギニー"),
+        (0x3312, "M", "キュリー"),
+        (0x3313, "M", "ギルダー"),
+        (0x3314, "M", "キロ"),
+        (0x3315, "M", "キログラム"),
+        (0x3316, "M", "キロメートル"),
+        (0x3317, "M", "キロワット"),
+        (0x3318, "M", "グラム"),
+        (0x3319, "M", "グラムトン"),
+        (0x331A, "M", "クルゼイロ"),
+        (0x331B, "M", "クローネ"),
+        (0x331C, "M", "ケース"),
+        (0x331D, "M", "コルナ"),
+        (0x331E, "M", "コーポ"),
+        (0x331F, "M", "サイクル"),
+        (0x3320, "M", "サンチーム"),
+        (0x3321, "M", "シリング"),
+        (0x3322, "M", "センチ"),
+        (0x3323, "M", "セント"),
+        (0x3324, "M", "ダース"),
+        (0x3325, "M", "デシ"),
+        (0x3326, "M", "ドル"),
+        (0x3327, "M", "トン"),
+        (0x3328, "M", "ナノ"),
+        (0x3329, "M", "ノット"),
+        (0x332A, "M", "ハイツ"),
+        (0x332B, "M", "パーセント"),
+        (0x332C, "M", "パーツ"),
+        (0x332D, "M", "バーレル"),
+        (0x332E, "M", "ピアストル"),
+        (0x332F, "M", "ピクル"),
+        (0x3330, "M", "ピコ"),
+        (0x3331, "M", "ビル"),
+        (0x3332, "M", "ファラッド"),
+        (0x3333, "M", "フィート"),
+        (0x3334, "M", "ブッシェル"),
+        (0x3335, "M", "フラン"),
+        (0x3336, "M", "ヘクタール"),
+        (0x3337, "M", "ペソ"),
+        (0x3338, "M", "ペニヒ"),
+        (0x3339, "M", "ヘルツ"),
+        (0x333A, "M", "ペンス"),
+        (0x333B, "M", "ページ"),
+        (0x333C, "M", "ベータ"),
+        (0x333D, "M", "ポイント"),
+        (0x333E, "M", "ボルト"),
+        (0x333F, "M", "ホン"),
+        (0x3340, "M", "ポンド"),
+        (0x3341, "M", "ホール"),
+        (0x3342, "M", "ホーン"),
+        (0x3343, "M", "マイクロ"),
+        (0x3344, "M", "マイル"),
+        (0x3345, "M", "マッハ"),
+        (0x3346, "M", "マルク"),
+        (0x3347, "M", "マンション"),
+        (0x3348, "M", "ミクロン"),
+        (0x3349, "M", "ミリ"),
+        (0x334A, "M", "ミリバール"),
+        (0x334B, "M", "メガ"),
+        (0x334C, "M", "メガトン"),
+        (0x334D, "M", "メートル"),
+        (0x334E, "M", "ヤード"),
+        (0x334F, "M", "ヤール"),
+        (0x3350, "M", "ユアン"),
+        (0x3351, "M", "リットル"),
+        (0x3352, "M", "リラ"),
+        (0x3353, "M", "ルピー"),
+        (0x3354, "M", "ルーブル"),
+        (0x3355, "M", "レム"),
+        (0x3356, "M", "レントゲン"),
+        (0x3357, "M", "ワット"),
+        (0x3358, "M", "0点"),
+        (0x3359, "M", "1点"),
+        (0x335A, "M", "2点"),
+        (0x335B, "M", "3点"),
+        (0x335C, "M", "4点"),
+    ]
+
+
+def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x335D, "M", "5点"),
+        (0x335E, "M", "6点"),
+        (0x335F, "M", "7点"),
+        (0x3360, "M", "8点"),
+        (0x3361, "M", "9点"),
+        (0x3362, "M", "10点"),
+        (0x3363, "M", "11点"),
+        (0x3364, "M", "12点"),
+        (0x3365, "M", "13点"),
+        (0x3366, "M", "14点"),
+        (0x3367, "M", "15点"),
+        (0x3368, "M", "16点"),
+        (0x3369, "M", "17点"),
+        (0x336A, "M", "18点"),
+        (0x336B, "M", "19点"),
+        (0x336C, "M", "20点"),
+        (0x336D, "M", "21点"),
+        (0x336E, "M", "22点"),
+        (0x336F, "M", "23点"),
+        (0x3370, "M", "24点"),
+        (0x3371, "M", "hpa"),
+        (0x3372, "M", "da"),
+        (0x3373, "M", "au"),
+        (0x3374, "M", "bar"),
+        (0x3375, "M", "ov"),
+        (0x3376, "M", "pc"),
+        (0x3377, "M", "dm"),
+        (0x3378, "M", "dm2"),
+        (0x3379, "M", "dm3"),
+        (0x337A, "M", "iu"),
+        (0x337B, "M", "平成"),
+        (0x337C, "M", "昭和"),
+        (0x337D, "M", "大正"),
+        (0x337E, "M", "明治"),
+        (0x337F, "M", "株式会社"),
+        (0x3380, "M", "pa"),
+        (0x3381, "M", "na"),
+        (0x3382, "M", "μa"),
+        (0x3383, "M", "ma"),
+        (0x3384, "M", "ka"),
+        (0x3385, "M", "kb"),
+        (0x3386, "M", "mb"),
+        (0x3387, "M", "gb"),
+        (0x3388, "M", "cal"),
+        (0x3389, "M", "kcal"),
+        (0x338A, "M", "pf"),
+        (0x338B, "M", "nf"),
+        (0x338C, "M", "μf"),
+        (0x338D, "M", "μg"),
+        (0x338E, "M", "mg"),
+        (0x338F, "M", "kg"),
+        (0x3390, "M", "hz"),
+        (0x3391, "M", "khz"),
+        (0x3392, "M", "mhz"),
+        (0x3393, "M", "ghz"),
+        (0x3394, "M", "thz"),
+        (0x3395, "M", "μl"),
+        (0x3396, "M", "ml"),
+        (0x3397, "M", "dl"),
+        (0x3398, "M", "kl"),
+        (0x3399, "M", "fm"),
+        (0x339A, "M", "nm"),
+        (0x339B, "M", "μm"),
+        (0x339C, "M", "mm"),
+        (0x339D, "M", "cm"),
+        (0x339E, "M", "km"),
+        (0x339F, "M", "mm2"),
+        (0x33A0, "M", "cm2"),
+        (0x33A1, "M", "m2"),
+        (0x33A2, "M", "km2"),
+        (0x33A3, "M", "mm3"),
+        (0x33A4, "M", "cm3"),
+        (0x33A5, "M", "m3"),
+        (0x33A6, "M", "km3"),
+        (0x33A7, "M", "m∕s"),
+        (0x33A8, "M", "m∕s2"),
+        (0x33A9, "M", "pa"),
+        (0x33AA, "M", "kpa"),
+        (0x33AB, "M", "mpa"),
+        (0x33AC, "M", "gpa"),
+        (0x33AD, "M", "rad"),
+        (0x33AE, "M", "rad∕s"),
+        (0x33AF, "M", "rad∕s2"),
+        (0x33B0, "M", "ps"),
+        (0x33B1, "M", "ns"),
+        (0x33B2, "M", "μs"),
+        (0x33B3, "M", "ms"),
+        (0x33B4, "M", "pv"),
+        (0x33B5, "M", "nv"),
+        (0x33B6, "M", "μv"),
+        (0x33B7, "M", "mv"),
+        (0x33B8, "M", "kv"),
+        (0x33B9, "M", "mv"),
+        (0x33BA, "M", "pw"),
+        (0x33BB, "M", "nw"),
+        (0x33BC, "M", "μw"),
+        (0x33BD, "M", "mw"),
+        (0x33BE, "M", "kw"),
+        (0x33BF, "M", "mw"),
+        (0x33C0, "M", "kω"),
+    ]
+
+
+def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x33C1, "M", "mω"),
+        (0x33C2, "X"),
+        (0x33C3, "M", "bq"),
+        (0x33C4, "M", "cc"),
+        (0x33C5, "M", "cd"),
+        (0x33C6, "M", "c∕kg"),
+        (0x33C7, "X"),
+        (0x33C8, "M", "db"),
+        (0x33C9, "M", "gy"),
+        (0x33CA, "M", "ha"),
+        (0x33CB, "M", "hp"),
+        (0x33CC, "M", "in"),
+        (0x33CD, "M", "kk"),
+        (0x33CE, "M", "km"),
+        (0x33CF, "M", "kt"),
+        (0x33D0, "M", "lm"),
+        (0x33D1, "M", "ln"),
+        (0x33D2, "M", "log"),
+        (0x33D3, "M", "lx"),
+        (0x33D4, "M", "mb"),
+        (0x33D5, "M", "mil"),
+        (0x33D6, "M", "mol"),
+        (0x33D7, "M", "ph"),
+        (0x33D8, "X"),
+        (0x33D9, "M", "ppm"),
+        (0x33DA, "M", "pr"),
+        (0x33DB, "M", "sr"),
+        (0x33DC, "M", "sv"),
+        (0x33DD, "M", "wb"),
+        (0x33DE, "M", "v∕m"),
+        (0x33DF, "M", "a∕m"),
+        (0x33E0, "M", "1日"),
+        (0x33E1, "M", "2日"),
+        (0x33E2, "M", "3日"),
+        (0x33E3, "M", "4日"),
+        (0x33E4, "M", "5日"),
+        (0x33E5, "M", "6日"),
+        (0x33E6, "M", "7日"),
+        (0x33E7, "M", "8日"),
+        (0x33E8, "M", "9日"),
+        (0x33E9, "M", "10日"),
+        (0x33EA, "M", "11日"),
+        (0x33EB, "M", "12日"),
+        (0x33EC, "M", "13日"),
+        (0x33ED, "M", "14日"),
+        (0x33EE, "M", "15日"),
+        (0x33EF, "M", "16日"),
+        (0x33F0, "M", "17日"),
+        (0x33F1, "M", "18日"),
+        (0x33F2, "M", "19日"),
+        (0x33F3, "M", "20日"),
+        (0x33F4, "M", "21日"),
+        (0x33F5, "M", "22日"),
+        (0x33F6, "M", "23日"),
+        (0x33F7, "M", "24日"),
+        (0x33F8, "M", "25日"),
+        (0x33F9, "M", "26日"),
+        (0x33FA, "M", "27日"),
+        (0x33FB, "M", "28日"),
+        (0x33FC, "M", "29日"),
+        (0x33FD, "M", "30日"),
+        (0x33FE, "M", "31日"),
+        (0x33FF, "M", "gal"),
+        (0x3400, "V"),
+        (0xA48D, "X"),
+        (0xA490, "V"),
+        (0xA4C7, "X"),
+        (0xA4D0, "V"),
+        (0xA62C, "X"),
+        (0xA640, "M", "ꙁ"),
+        (0xA641, "V"),
+        (0xA642, "M", "ꙃ"),
+        (0xA643, "V"),
+        (0xA644, "M", "ꙅ"),
+        (0xA645, "V"),
+        (0xA646, "M", "ꙇ"),
+        (0xA647, "V"),
+        (0xA648, "M", "ꙉ"),
+        (0xA649, "V"),
+        (0xA64A, "M", "ꙋ"),
+        (0xA64B, "V"),
+        (0xA64C, "M", "ꙍ"),
+        (0xA64D, "V"),
+        (0xA64E, "M", "ꙏ"),
+        (0xA64F, "V"),
+        (0xA650, "M", "ꙑ"),
+        (0xA651, "V"),
+        (0xA652, "M", "ꙓ"),
+        (0xA653, "V"),
+        (0xA654, "M", "ꙕ"),
+        (0xA655, "V"),
+        (0xA656, "M", "ꙗ"),
+        (0xA657, "V"),
+        (0xA658, "M", "ꙙ"),
+        (0xA659, "V"),
+        (0xA65A, "M", "ꙛ"),
+        (0xA65B, "V"),
+        (0xA65C, "M", "ꙝ"),
+        (0xA65D, "V"),
+        (0xA65E, "M", "ꙟ"),
+    ]
+
+
+def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xA65F, "V"),
+        (0xA660, "M", "ꙡ"),
+        (0xA661, "V"),
+        (0xA662, "M", "ꙣ"),
+        (0xA663, "V"),
+        (0xA664, "M", "ꙥ"),
+        (0xA665, "V"),
+        (0xA666, "M", "ꙧ"),
+        (0xA667, "V"),
+        (0xA668, "M", "ꙩ"),
+        (0xA669, "V"),
+        (0xA66A, "M", "ꙫ"),
+        (0xA66B, "V"),
+        (0xA66C, "M", "ꙭ"),
+        (0xA66D, "V"),
+        (0xA680, "M", "ꚁ"),
+        (0xA681, "V"),
+        (0xA682, "M", "ꚃ"),
+        (0xA683, "V"),
+        (0xA684, "M", "ꚅ"),
+        (0xA685, "V"),
+        (0xA686, "M", "ꚇ"),
+        (0xA687, "V"),
+        (0xA688, "M", "ꚉ"),
+        (0xA689, "V"),
+        (0xA68A, "M", "ꚋ"),
+        (0xA68B, "V"),
+        (0xA68C, "M", "ꚍ"),
+        (0xA68D, "V"),
+        (0xA68E, "M", "ꚏ"),
+        (0xA68F, "V"),
+        (0xA690, "M", "ꚑ"),
+        (0xA691, "V"),
+        (0xA692, "M", "ꚓ"),
+        (0xA693, "V"),
+        (0xA694, "M", "ꚕ"),
+        (0xA695, "V"),
+        (0xA696, "M", "ꚗ"),
+        (0xA697, "V"),
+        (0xA698, "M", "ꚙ"),
+        (0xA699, "V"),
+        (0xA69A, "M", "ꚛ"),
+        (0xA69B, "V"),
+        (0xA69C, "M", "ъ"),
+        (0xA69D, "M", "ь"),
+        (0xA69E, "V"),
+        (0xA6F8, "X"),
+        (0xA700, "V"),
+        (0xA722, "M", "ꜣ"),
+        (0xA723, "V"),
+        (0xA724, "M", "ꜥ"),
+        (0xA725, "V"),
+        (0xA726, "M", "ꜧ"),
+        (0xA727, "V"),
+        (0xA728, "M", "ꜩ"),
+        (0xA729, "V"),
+        (0xA72A, "M", "ꜫ"),
+        (0xA72B, "V"),
+        (0xA72C, "M", "ꜭ"),
+        (0xA72D, "V"),
+        (0xA72E, "M", "ꜯ"),
+        (0xA72F, "V"),
+        (0xA732, "M", "ꜳ"),
+        (0xA733, "V"),
+        (0xA734, "M", "ꜵ"),
+        (0xA735, "V"),
+        (0xA736, "M", "ꜷ"),
+        (0xA737, "V"),
+        (0xA738, "M", "ꜹ"),
+        (0xA739, "V"),
+        (0xA73A, "M", "ꜻ"),
+        (0xA73B, "V"),
+        (0xA73C, "M", "ꜽ"),
+        (0xA73D, "V"),
+        (0xA73E, "M", "ꜿ"),
+        (0xA73F, "V"),
+        (0xA740, "M", "ꝁ"),
+        (0xA741, "V"),
+        (0xA742, "M", "ꝃ"),
+        (0xA743, "V"),
+        (0xA744, "M", "ꝅ"),
+        (0xA745, "V"),
+        (0xA746, "M", "ꝇ"),
+        (0xA747, "V"),
+        (0xA748, "M", "ꝉ"),
+        (0xA749, "V"),
+        (0xA74A, "M", "ꝋ"),
+        (0xA74B, "V"),
+        (0xA74C, "M", "ꝍ"),
+        (0xA74D, "V"),
+        (0xA74E, "M", "ꝏ"),
+        (0xA74F, "V"),
+        (0xA750, "M", "ꝑ"),
+        (0xA751, "V"),
+        (0xA752, "M", "ꝓ"),
+        (0xA753, "V"),
+        (0xA754, "M", "ꝕ"),
+        (0xA755, "V"),
+        (0xA756, "M", "ꝗ"),
+        (0xA757, "V"),
+    ]
+
+
+def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xA758, "M", "ꝙ"),
+        (0xA759, "V"),
+        (0xA75A, "M", "ꝛ"),
+        (0xA75B, "V"),
+        (0xA75C, "M", "ꝝ"),
+        (0xA75D, "V"),
+        (0xA75E, "M", "ꝟ"),
+        (0xA75F, "V"),
+        (0xA760, "M", "ꝡ"),
+        (0xA761, "V"),
+        (0xA762, "M", "ꝣ"),
+        (0xA763, "V"),
+        (0xA764, "M", "ꝥ"),
+        (0xA765, "V"),
+        (0xA766, "M", "ꝧ"),
+        (0xA767, "V"),
+        (0xA768, "M", "ꝩ"),
+        (0xA769, "V"),
+        (0xA76A, "M", "ꝫ"),
+        (0xA76B, "V"),
+        (0xA76C, "M", "ꝭ"),
+        (0xA76D, "V"),
+        (0xA76E, "M", "ꝯ"),
+        (0xA76F, "V"),
+        (0xA770, "M", "ꝯ"),
+        (0xA771, "V"),
+        (0xA779, "M", "ꝺ"),
+        (0xA77A, "V"),
+        (0xA77B, "M", "ꝼ"),
+        (0xA77C, "V"),
+        (0xA77D, "M", "ᵹ"),
+        (0xA77E, "M", "ꝿ"),
+        (0xA77F, "V"),
+        (0xA780, "M", "ꞁ"),
+        (0xA781, "V"),
+        (0xA782, "M", "ꞃ"),
+        (0xA783, "V"),
+        (0xA784, "M", "ꞅ"),
+        (0xA785, "V"),
+        (0xA786, "M", "ꞇ"),
+        (0xA787, "V"),
+        (0xA78B, "M", "ꞌ"),
+        (0xA78C, "V"),
+        (0xA78D, "M", "ɥ"),
+        (0xA78E, "V"),
+        (0xA790, "M", "ꞑ"),
+        (0xA791, "V"),
+        (0xA792, "M", "ꞓ"),
+        (0xA793, "V"),
+        (0xA796, "M", "ꞗ"),
+        (0xA797, "V"),
+        (0xA798, "M", "ꞙ"),
+        (0xA799, "V"),
+        (0xA79A, "M", "ꞛ"),
+        (0xA79B, "V"),
+        (0xA79C, "M", "ꞝ"),
+        (0xA79D, "V"),
+        (0xA79E, "M", "ꞟ"),
+        (0xA79F, "V"),
+        (0xA7A0, "M", "ꞡ"),
+        (0xA7A1, "V"),
+        (0xA7A2, "M", "ꞣ"),
+        (0xA7A3, "V"),
+        (0xA7A4, "M", "ꞥ"),
+        (0xA7A5, "V"),
+        (0xA7A6, "M", "ꞧ"),
+        (0xA7A7, "V"),
+        (0xA7A8, "M", "ꞩ"),
+        (0xA7A9, "V"),
+        (0xA7AA, "M", "ɦ"),
+        (0xA7AB, "M", "ɜ"),
+        (0xA7AC, "M", "ɡ"),
+        (0xA7AD, "M", "ɬ"),
+        (0xA7AE, "M", "ɪ"),
+        (0xA7AF, "V"),
+        (0xA7B0, "M", "ʞ"),
+        (0xA7B1, "M", "ʇ"),
+        (0xA7B2, "M", "ʝ"),
+        (0xA7B3, "M", "ꭓ"),
+        (0xA7B4, "M", "ꞵ"),
+        (0xA7B5, "V"),
+        (0xA7B6, "M", "ꞷ"),
+        (0xA7B7, "V"),
+        (0xA7B8, "M", "ꞹ"),
+        (0xA7B9, "V"),
+        (0xA7BA, "M", "ꞻ"),
+        (0xA7BB, "V"),
+        (0xA7BC, "M", "ꞽ"),
+        (0xA7BD, "V"),
+        (0xA7BE, "M", "ꞿ"),
+        (0xA7BF, "V"),
+        (0xA7C0, "M", "ꟁ"),
+        (0xA7C1, "V"),
+        (0xA7C2, "M", "ꟃ"),
+        (0xA7C3, "V"),
+        (0xA7C4, "M", "ꞔ"),
+        (0xA7C5, "M", "ʂ"),
+        (0xA7C6, "M", "ᶎ"),
+        (0xA7C7, "M", "ꟈ"),
+        (0xA7C8, "V"),
+    ]
+
+
+def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xA7C9, "M", "ꟊ"),
+        (0xA7CA, "V"),
+        (0xA7CB, "M", "ɤ"),
+        (0xA7CC, "M", "ꟍ"),
+        (0xA7CD, "V"),
+        (0xA7CE, "X"),
+        (0xA7D0, "M", "ꟑ"),
+        (0xA7D1, "V"),
+        (0xA7D2, "X"),
+        (0xA7D3, "V"),
+        (0xA7D4, "X"),
+        (0xA7D5, "V"),
+        (0xA7D6, "M", "ꟗ"),
+        (0xA7D7, "V"),
+        (0xA7D8, "M", "ꟙ"),
+        (0xA7D9, "V"),
+        (0xA7DA, "M", "ꟛ"),
+        (0xA7DB, "V"),
+        (0xA7DC, "M", "ƛ"),
+        (0xA7DD, "X"),
+        (0xA7F2, "M", "c"),
+        (0xA7F3, "M", "f"),
+        (0xA7F4, "M", "q"),
+        (0xA7F5, "M", "ꟶ"),
+        (0xA7F6, "V"),
+        (0xA7F8, "M", "ħ"),
+        (0xA7F9, "M", "œ"),
+        (0xA7FA, "V"),
+        (0xA82D, "X"),
+        (0xA830, "V"),
+        (0xA83A, "X"),
+        (0xA840, "V"),
+        (0xA878, "X"),
+        (0xA880, "V"),
+        (0xA8C6, "X"),
+        (0xA8CE, "V"),
+        (0xA8DA, "X"),
+        (0xA8E0, "V"),
+        (0xA954, "X"),
+        (0xA95F, "V"),
+        (0xA97D, "X"),
+        (0xA980, "V"),
+        (0xA9CE, "X"),
+        (0xA9CF, "V"),
+        (0xA9DA, "X"),
+        (0xA9DE, "V"),
+        (0xA9FF, "X"),
+        (0xAA00, "V"),
+        (0xAA37, "X"),
+        (0xAA40, "V"),
+        (0xAA4E, "X"),
+        (0xAA50, "V"),
+        (0xAA5A, "X"),
+        (0xAA5C, "V"),
+        (0xAAC3, "X"),
+        (0xAADB, "V"),
+        (0xAAF7, "X"),
+        (0xAB01, "V"),
+        (0xAB07, "X"),
+        (0xAB09, "V"),
+        (0xAB0F, "X"),
+        (0xAB11, "V"),
+        (0xAB17, "X"),
+        (0xAB20, "V"),
+        (0xAB27, "X"),
+        (0xAB28, "V"),
+        (0xAB2F, "X"),
+        (0xAB30, "V"),
+        (0xAB5C, "M", "ꜧ"),
+        (0xAB5D, "M", "ꬷ"),
+        (0xAB5E, "M", "ɫ"),
+        (0xAB5F, "M", "ꭒ"),
+        (0xAB60, "V"),
+        (0xAB69, "M", "ʍ"),
+        (0xAB6A, "V"),
+        (0xAB6C, "X"),
+        (0xAB70, "M", "Ꭰ"),
+        (0xAB71, "M", "Ꭱ"),
+        (0xAB72, "M", "Ꭲ"),
+        (0xAB73, "M", "Ꭳ"),
+        (0xAB74, "M", "Ꭴ"),
+        (0xAB75, "M", "Ꭵ"),
+        (0xAB76, "M", "Ꭶ"),
+        (0xAB77, "M", "Ꭷ"),
+        (0xAB78, "M", "Ꭸ"),
+        (0xAB79, "M", "Ꭹ"),
+        (0xAB7A, "M", "Ꭺ"),
+        (0xAB7B, "M", "Ꭻ"),
+        (0xAB7C, "M", "Ꭼ"),
+        (0xAB7D, "M", "Ꭽ"),
+        (0xAB7E, "M", "Ꭾ"),
+        (0xAB7F, "M", "Ꭿ"),
+        (0xAB80, "M", "Ꮀ"),
+        (0xAB81, "M", "Ꮁ"),
+        (0xAB82, "M", "Ꮂ"),
+        (0xAB83, "M", "Ꮃ"),
+        (0xAB84, "M", "Ꮄ"),
+        (0xAB85, "M", "Ꮅ"),
+        (0xAB86, "M", "Ꮆ"),
+        (0xAB87, "M", "Ꮇ"),
+    ]
+
+
+def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xAB88, "M", "Ꮈ"),
+        (0xAB89, "M", "Ꮉ"),
+        (0xAB8A, "M", "Ꮊ"),
+        (0xAB8B, "M", "Ꮋ"),
+        (0xAB8C, "M", "Ꮌ"),
+        (0xAB8D, "M", "Ꮍ"),
+        (0xAB8E, "M", "Ꮎ"),
+        (0xAB8F, "M", "Ꮏ"),
+        (0xAB90, "M", "Ꮐ"),
+        (0xAB91, "M", "Ꮑ"),
+        (0xAB92, "M", "Ꮒ"),
+        (0xAB93, "M", "Ꮓ"),
+        (0xAB94, "M", "Ꮔ"),
+        (0xAB95, "M", "Ꮕ"),
+        (0xAB96, "M", "Ꮖ"),
+        (0xAB97, "M", "Ꮗ"),
+        (0xAB98, "M", "Ꮘ"),
+        (0xAB99, "M", "Ꮙ"),
+        (0xAB9A, "M", "Ꮚ"),
+        (0xAB9B, "M", "Ꮛ"),
+        (0xAB9C, "M", "Ꮜ"),
+        (0xAB9D, "M", "Ꮝ"),
+        (0xAB9E, "M", "Ꮞ"),
+        (0xAB9F, "M", "Ꮟ"),
+        (0xABA0, "M", "Ꮠ"),
+        (0xABA1, "M", "Ꮡ"),
+        (0xABA2, "M", "Ꮢ"),
+        (0xABA3, "M", "Ꮣ"),
+        (0xABA4, "M", "Ꮤ"),
+        (0xABA5, "M", "Ꮥ"),
+        (0xABA6, "M", "Ꮦ"),
+        (0xABA7, "M", "Ꮧ"),
+        (0xABA8, "M", "Ꮨ"),
+        (0xABA9, "M", "Ꮩ"),
+        (0xABAA, "M", "Ꮪ"),
+        (0xABAB, "M", "Ꮫ"),
+        (0xABAC, "M", "Ꮬ"),
+        (0xABAD, "M", "Ꮭ"),
+        (0xABAE, "M", "Ꮮ"),
+        (0xABAF, "M", "Ꮯ"),
+        (0xABB0, "M", "Ꮰ"),
+        (0xABB1, "M", "Ꮱ"),
+        (0xABB2, "M", "Ꮲ"),
+        (0xABB3, "M", "Ꮳ"),
+        (0xABB4, "M", "Ꮴ"),
+        (0xABB5, "M", "Ꮵ"),
+        (0xABB6, "M", "Ꮶ"),
+        (0xABB7, "M", "Ꮷ"),
+        (0xABB8, "M", "Ꮸ"),
+        (0xABB9, "M", "Ꮹ"),
+        (0xABBA, "M", "Ꮺ"),
+        (0xABBB, "M", "Ꮻ"),
+        (0xABBC, "M", "Ꮼ"),
+        (0xABBD, "M", "Ꮽ"),
+        (0xABBE, "M", "Ꮾ"),
+        (0xABBF, "M", "Ꮿ"),
+        (0xABC0, "V"),
+        (0xABEE, "X"),
+        (0xABF0, "V"),
+        (0xABFA, "X"),
+        (0xAC00, "V"),
+        (0xD7A4, "X"),
+        (0xD7B0, "V"),
+        (0xD7C7, "X"),
+        (0xD7CB, "V"),
+        (0xD7FC, "X"),
+        (0xF900, "M", "豈"),
+        (0xF901, "M", "更"),
+        (0xF902, "M", "車"),
+        (0xF903, "M", "賈"),
+        (0xF904, "M", "滑"),
+        (0xF905, "M", "串"),
+        (0xF906, "M", "句"),
+        (0xF907, "M", "龜"),
+        (0xF909, "M", "契"),
+        (0xF90A, "M", "金"),
+        (0xF90B, "M", "喇"),
+        (0xF90C, "M", "奈"),
+        (0xF90D, "M", "懶"),
+        (0xF90E, "M", "癩"),
+        (0xF90F, "M", "羅"),
+        (0xF910, "M", "蘿"),
+        (0xF911, "M", "螺"),
+        (0xF912, "M", "裸"),
+        (0xF913, "M", "邏"),
+        (0xF914, "M", "樂"),
+        (0xF915, "M", "洛"),
+        (0xF916, "M", "烙"),
+        (0xF917, "M", "珞"),
+        (0xF918, "M", "落"),
+        (0xF919, "M", "酪"),
+        (0xF91A, "M", "駱"),
+        (0xF91B, "M", "亂"),
+        (0xF91C, "M", "卵"),
+        (0xF91D, "M", "欄"),
+        (0xF91E, "M", "爛"),
+        (0xF91F, "M", "蘭"),
+        (0xF920, "M", "鸞"),
+        (0xF921, "M", "嵐"),
+        (0xF922, "M", "濫"),
+    ]
+
+
+def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xF923, "M", "藍"),
+        (0xF924, "M", "襤"),
+        (0xF925, "M", "拉"),
+        (0xF926, "M", "臘"),
+        (0xF927, "M", "蠟"),
+        (0xF928, "M", "廊"),
+        (0xF929, "M", "朗"),
+        (0xF92A, "M", "浪"),
+        (0xF92B, "M", "狼"),
+        (0xF92C, "M", "郎"),
+        (0xF92D, "M", "來"),
+        (0xF92E, "M", "冷"),
+        (0xF92F, "M", "勞"),
+        (0xF930, "M", "擄"),
+        (0xF931, "M", "櫓"),
+        (0xF932, "M", "爐"),
+        (0xF933, "M", "盧"),
+        (0xF934, "M", "老"),
+        (0xF935, "M", "蘆"),
+        (0xF936, "M", "虜"),
+        (0xF937, "M", "路"),
+        (0xF938, "M", "露"),
+        (0xF939, "M", "魯"),
+        (0xF93A, "M", "鷺"),
+        (0xF93B, "M", "碌"),
+        (0xF93C, "M", "祿"),
+        (0xF93D, "M", "綠"),
+        (0xF93E, "M", "菉"),
+        (0xF93F, "M", "錄"),
+        (0xF940, "M", "鹿"),
+        (0xF941, "M", "論"),
+        (0xF942, "M", "壟"),
+        (0xF943, "M", "弄"),
+        (0xF944, "M", "籠"),
+        (0xF945, "M", "聾"),
+        (0xF946, "M", "牢"),
+        (0xF947, "M", "磊"),
+        (0xF948, "M", "賂"),
+        (0xF949, "M", "雷"),
+        (0xF94A, "M", "壘"),
+        (0xF94B, "M", "屢"),
+        (0xF94C, "M", "樓"),
+        (0xF94D, "M", "淚"),
+        (0xF94E, "M", "漏"),
+        (0xF94F, "M", "累"),
+        (0xF950, "M", "縷"),
+        (0xF951, "M", "陋"),
+        (0xF952, "M", "勒"),
+        (0xF953, "M", "肋"),
+        (0xF954, "M", "凜"),
+        (0xF955, "M", "凌"),
+        (0xF956, "M", "稜"),
+        (0xF957, "M", "綾"),
+        (0xF958, "M", "菱"),
+        (0xF959, "M", "陵"),
+        (0xF95A, "M", "讀"),
+        (0xF95B, "M", "拏"),
+        (0xF95C, "M", "樂"),
+        (0xF95D, "M", "諾"),
+        (0xF95E, "M", "丹"),
+        (0xF95F, "M", "寧"),
+        (0xF960, "M", "怒"),
+        (0xF961, "M", "率"),
+        (0xF962, "M", "異"),
+        (0xF963, "M", "北"),
+        (0xF964, "M", "磻"),
+        (0xF965, "M", "便"),
+        (0xF966, "M", "復"),
+        (0xF967, "M", "不"),
+        (0xF968, "M", "泌"),
+        (0xF969, "M", "數"),
+        (0xF96A, "M", "索"),
+        (0xF96B, "M", "參"),
+        (0xF96C, "M", "塞"),
+        (0xF96D, "M", "省"),
+        (0xF96E, "M", "葉"),
+        (0xF96F, "M", "說"),
+        (0xF970, "M", "殺"),
+        (0xF971, "M", "辰"),
+        (0xF972, "M", "沈"),
+        (0xF973, "M", "拾"),
+        (0xF974, "M", "若"),
+        (0xF975, "M", "掠"),
+        (0xF976, "M", "略"),
+        (0xF977, "M", "亮"),
+        (0xF978, "M", "兩"),
+        (0xF979, "M", "凉"),
+        (0xF97A, "M", "梁"),
+        (0xF97B, "M", "糧"),
+        (0xF97C, "M", "良"),
+        (0xF97D, "M", "諒"),
+        (0xF97E, "M", "量"),
+        (0xF97F, "M", "勵"),
+        (0xF980, "M", "呂"),
+        (0xF981, "M", "女"),
+        (0xF982, "M", "廬"),
+        (0xF983, "M", "旅"),
+        (0xF984, "M", "濾"),
+        (0xF985, "M", "礪"),
+        (0xF986, "M", "閭"),
+    ]
+
+
+def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xF987, "M", "驪"),
+        (0xF988, "M", "麗"),
+        (0xF989, "M", "黎"),
+        (0xF98A, "M", "力"),
+        (0xF98B, "M", "曆"),
+        (0xF98C, "M", "歷"),
+        (0xF98D, "M", "轢"),
+        (0xF98E, "M", "年"),
+        (0xF98F, "M", "憐"),
+        (0xF990, "M", "戀"),
+        (0xF991, "M", "撚"),
+        (0xF992, "M", "漣"),
+        (0xF993, "M", "煉"),
+        (0xF994, "M", "璉"),
+        (0xF995, "M", "秊"),
+        (0xF996, "M", "練"),
+        (0xF997, "M", "聯"),
+        (0xF998, "M", "輦"),
+        (0xF999, "M", "蓮"),
+        (0xF99A, "M", "連"),
+        (0xF99B, "M", "鍊"),
+        (0xF99C, "M", "列"),
+        (0xF99D, "M", "劣"),
+        (0xF99E, "M", "咽"),
+        (0xF99F, "M", "烈"),
+        (0xF9A0, "M", "裂"),
+        (0xF9A1, "M", "說"),
+        (0xF9A2, "M", "廉"),
+        (0xF9A3, "M", "念"),
+        (0xF9A4, "M", "捻"),
+        (0xF9A5, "M", "殮"),
+        (0xF9A6, "M", "簾"),
+        (0xF9A7, "M", "獵"),
+        (0xF9A8, "M", "令"),
+        (0xF9A9, "M", "囹"),
+        (0xF9AA, "M", "寧"),
+        (0xF9AB, "M", "嶺"),
+        (0xF9AC, "M", "怜"),
+        (0xF9AD, "M", "玲"),
+        (0xF9AE, "M", "瑩"),
+        (0xF9AF, "M", "羚"),
+        (0xF9B0, "M", "聆"),
+        (0xF9B1, "M", "鈴"),
+        (0xF9B2, "M", "零"),
+        (0xF9B3, "M", "靈"),
+        (0xF9B4, "M", "領"),
+        (0xF9B5, "M", "例"),
+        (0xF9B6, "M", "禮"),
+        (0xF9B7, "M", "醴"),
+        (0xF9B8, "M", "隸"),
+        (0xF9B9, "M", "惡"),
+        (0xF9BA, "M", "了"),
+        (0xF9BB, "M", "僚"),
+        (0xF9BC, "M", "寮"),
+        (0xF9BD, "M", "尿"),
+        (0xF9BE, "M", "料"),
+        (0xF9BF, "M", "樂"),
+        (0xF9C0, "M", "燎"),
+        (0xF9C1, "M", "療"),
+        (0xF9C2, "M", "蓼"),
+        (0xF9C3, "M", "遼"),
+        (0xF9C4, "M", "龍"),
+        (0xF9C5, "M", "暈"),
+        (0xF9C6, "M", "阮"),
+        (0xF9C7, "M", "劉"),
+        (0xF9C8, "M", "杻"),
+        (0xF9C9, "M", "柳"),
+        (0xF9CA, "M", "流"),
+        (0xF9CB, "M", "溜"),
+        (0xF9CC, "M", "琉"),
+        (0xF9CD, "M", "留"),
+        (0xF9CE, "M", "硫"),
+        (0xF9CF, "M", "紐"),
+        (0xF9D0, "M", "類"),
+        (0xF9D1, "M", "六"),
+        (0xF9D2, "M", "戮"),
+        (0xF9D3, "M", "陸"),
+        (0xF9D4, "M", "倫"),
+        (0xF9D5, "M", "崙"),
+        (0xF9D6, "M", "淪"),
+        (0xF9D7, "M", "輪"),
+        (0xF9D8, "M", "律"),
+        (0xF9D9, "M", "慄"),
+        (0xF9DA, "M", "栗"),
+        (0xF9DB, "M", "率"),
+        (0xF9DC, "M", "隆"),
+        (0xF9DD, "M", "利"),
+        (0xF9DE, "M", "吏"),
+        (0xF9DF, "M", "履"),
+        (0xF9E0, "M", "易"),
+        (0xF9E1, "M", "李"),
+        (0xF9E2, "M", "梨"),
+        (0xF9E3, "M", "泥"),
+        (0xF9E4, "M", "理"),
+        (0xF9E5, "M", "痢"),
+        (0xF9E6, "M", "罹"),
+        (0xF9E7, "M", "裏"),
+        (0xF9E8, "M", "裡"),
+        (0xF9E9, "M", "里"),
+        (0xF9EA, "M", "離"),
+    ]
+
+
+def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xF9EB, "M", "匿"),
+        (0xF9EC, "M", "溺"),
+        (0xF9ED, "M", "吝"),
+        (0xF9EE, "M", "燐"),
+        (0xF9EF, "M", "璘"),
+        (0xF9F0, "M", "藺"),
+        (0xF9F1, "M", "隣"),
+        (0xF9F2, "M", "鱗"),
+        (0xF9F3, "M", "麟"),
+        (0xF9F4, "M", "林"),
+        (0xF9F5, "M", "淋"),
+        (0xF9F6, "M", "臨"),
+        (0xF9F7, "M", "立"),
+        (0xF9F8, "M", "笠"),
+        (0xF9F9, "M", "粒"),
+        (0xF9FA, "M", "狀"),
+        (0xF9FB, "M", "炙"),
+        (0xF9FC, "M", "識"),
+        (0xF9FD, "M", "什"),
+        (0xF9FE, "M", "茶"),
+        (0xF9FF, "M", "刺"),
+        (0xFA00, "M", "切"),
+        (0xFA01, "M", "度"),
+        (0xFA02, "M", "拓"),
+        (0xFA03, "M", "糖"),
+        (0xFA04, "M", "宅"),
+        (0xFA05, "M", "洞"),
+        (0xFA06, "M", "暴"),
+        (0xFA07, "M", "輻"),
+        (0xFA08, "M", "行"),
+        (0xFA09, "M", "降"),
+        (0xFA0A, "M", "見"),
+        (0xFA0B, "M", "廓"),
+        (0xFA0C, "M", "兀"),
+        (0xFA0D, "M", "嗀"),
+        (0xFA0E, "V"),
+        (0xFA10, "M", "塚"),
+        (0xFA11, "V"),
+        (0xFA12, "M", "晴"),
+        (0xFA13, "V"),
+        (0xFA15, "M", "凞"),
+        (0xFA16, "M", "猪"),
+        (0xFA17, "M", "益"),
+        (0xFA18, "M", "礼"),
+        (0xFA19, "M", "神"),
+        (0xFA1A, "M", "祥"),
+        (0xFA1B, "M", "福"),
+        (0xFA1C, "M", "靖"),
+        (0xFA1D, "M", "精"),
+        (0xFA1E, "M", "羽"),
+        (0xFA1F, "V"),
+        (0xFA20, "M", "蘒"),
+        (0xFA21, "V"),
+        (0xFA22, "M", "諸"),
+        (0xFA23, "V"),
+        (0xFA25, "M", "逸"),
+        (0xFA26, "M", "都"),
+        (0xFA27, "V"),
+        (0xFA2A, "M", "飯"),
+        (0xFA2B, "M", "飼"),
+        (0xFA2C, "M", "館"),
+        (0xFA2D, "M", "鶴"),
+        (0xFA2E, "M", "郞"),
+        (0xFA2F, "M", "隷"),
+        (0xFA30, "M", "侮"),
+        (0xFA31, "M", "僧"),
+        (0xFA32, "M", "免"),
+        (0xFA33, "M", "勉"),
+        (0xFA34, "M", "勤"),
+        (0xFA35, "M", "卑"),
+        (0xFA36, "M", "喝"),
+        (0xFA37, "M", "嘆"),
+        (0xFA38, "M", "器"),
+        (0xFA39, "M", "塀"),
+        (0xFA3A, "M", "墨"),
+        (0xFA3B, "M", "層"),
+        (0xFA3C, "M", "屮"),
+        (0xFA3D, "M", "悔"),
+        (0xFA3E, "M", "慨"),
+        (0xFA3F, "M", "憎"),
+        (0xFA40, "M", "懲"),
+        (0xFA41, "M", "敏"),
+        (0xFA42, "M", "既"),
+        (0xFA43, "M", "暑"),
+        (0xFA44, "M", "梅"),
+        (0xFA45, "M", "海"),
+        (0xFA46, "M", "渚"),
+        (0xFA47, "M", "漢"),
+        (0xFA48, "M", "煮"),
+        (0xFA49, "M", "爫"),
+        (0xFA4A, "M", "琢"),
+        (0xFA4B, "M", "碑"),
+        (0xFA4C, "M", "社"),
+        (0xFA4D, "M", "祉"),
+        (0xFA4E, "M", "祈"),
+        (0xFA4F, "M", "祐"),
+        (0xFA50, "M", "祖"),
+        (0xFA51, "M", "祝"),
+        (0xFA52, "M", "禍"),
+        (0xFA53, "M", "禎"),
+    ]
+
+
+def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFA54, "M", "穀"),
+        (0xFA55, "M", "突"),
+        (0xFA56, "M", "節"),
+        (0xFA57, "M", "練"),
+        (0xFA58, "M", "縉"),
+        (0xFA59, "M", "繁"),
+        (0xFA5A, "M", "署"),
+        (0xFA5B, "M", "者"),
+        (0xFA5C, "M", "臭"),
+        (0xFA5D, "M", "艹"),
+        (0xFA5F, "M", "著"),
+        (0xFA60, "M", "褐"),
+        (0xFA61, "M", "視"),
+        (0xFA62, "M", "謁"),
+        (0xFA63, "M", "謹"),
+        (0xFA64, "M", "賓"),
+        (0xFA65, "M", "贈"),
+        (0xFA66, "M", "辶"),
+        (0xFA67, "M", "逸"),
+        (0xFA68, "M", "難"),
+        (0xFA69, "M", "響"),
+        (0xFA6A, "M", "頻"),
+        (0xFA6B, "M", "恵"),
+        (0xFA6C, "M", "𤋮"),
+        (0xFA6D, "M", "舘"),
+        (0xFA6E, "X"),
+        (0xFA70, "M", "並"),
+        (0xFA71, "M", "况"),
+        (0xFA72, "M", "全"),
+        (0xFA73, "M", "侀"),
+        (0xFA74, "M", "充"),
+        (0xFA75, "M", "冀"),
+        (0xFA76, "M", "勇"),
+        (0xFA77, "M", "勺"),
+        (0xFA78, "M", "喝"),
+        (0xFA79, "M", "啕"),
+        (0xFA7A, "M", "喙"),
+        (0xFA7B, "M", "嗢"),
+        (0xFA7C, "M", "塚"),
+        (0xFA7D, "M", "墳"),
+        (0xFA7E, "M", "奄"),
+        (0xFA7F, "M", "奔"),
+        (0xFA80, "M", "婢"),
+        (0xFA81, "M", "嬨"),
+        (0xFA82, "M", "廒"),
+        (0xFA83, "M", "廙"),
+        (0xFA84, "M", "彩"),
+        (0xFA85, "M", "徭"),
+        (0xFA86, "M", "惘"),
+        (0xFA87, "M", "慎"),
+        (0xFA88, "M", "愈"),
+        (0xFA89, "M", "憎"),
+        (0xFA8A, "M", "慠"),
+        (0xFA8B, "M", "懲"),
+        (0xFA8C, "M", "戴"),
+        (0xFA8D, "M", "揄"),
+        (0xFA8E, "M", "搜"),
+        (0xFA8F, "M", "摒"),
+        (0xFA90, "M", "敖"),
+        (0xFA91, "M", "晴"),
+        (0xFA92, "M", "朗"),
+        (0xFA93, "M", "望"),
+        (0xFA94, "M", "杖"),
+        (0xFA95, "M", "歹"),
+        (0xFA96, "M", "殺"),
+        (0xFA97, "M", "流"),
+        (0xFA98, "M", "滛"),
+        (0xFA99, "M", "滋"),
+        (0xFA9A, "M", "漢"),
+        (0xFA9B, "M", "瀞"),
+        (0xFA9C, "M", "煮"),
+        (0xFA9D, "M", "瞧"),
+        (0xFA9E, "M", "爵"),
+        (0xFA9F, "M", "犯"),
+        (0xFAA0, "M", "猪"),
+        (0xFAA1, "M", "瑱"),
+        (0xFAA2, "M", "甆"),
+        (0xFAA3, "M", "画"),
+        (0xFAA4, "M", "瘝"),
+        (0xFAA5, "M", "瘟"),
+        (0xFAA6, "M", "益"),
+        (0xFAA7, "M", "盛"),
+        (0xFAA8, "M", "直"),
+        (0xFAA9, "M", "睊"),
+        (0xFAAA, "M", "着"),
+        (0xFAAB, "M", "磌"),
+        (0xFAAC, "M", "窱"),
+        (0xFAAD, "M", "節"),
+        (0xFAAE, "M", "类"),
+        (0xFAAF, "M", "絛"),
+        (0xFAB0, "M", "練"),
+        (0xFAB1, "M", "缾"),
+        (0xFAB2, "M", "者"),
+        (0xFAB3, "M", "荒"),
+        (0xFAB4, "M", "華"),
+        (0xFAB5, "M", "蝹"),
+        (0xFAB6, "M", "襁"),
+        (0xFAB7, "M", "覆"),
+        (0xFAB8, "M", "視"),
+        (0xFAB9, "M", "調"),
+    ]
+
+
+def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFABA, "M", "諸"),
+        (0xFABB, "M", "請"),
+        (0xFABC, "M", "謁"),
+        (0xFABD, "M", "諾"),
+        (0xFABE, "M", "諭"),
+        (0xFABF, "M", "謹"),
+        (0xFAC0, "M", "變"),
+        (0xFAC1, "M", "贈"),
+        (0xFAC2, "M", "輸"),
+        (0xFAC3, "M", "遲"),
+        (0xFAC4, "M", "醙"),
+        (0xFAC5, "M", "鉶"),
+        (0xFAC6, "M", "陼"),
+        (0xFAC7, "M", "難"),
+        (0xFAC8, "M", "靖"),
+        (0xFAC9, "M", "韛"),
+        (0xFACA, "M", "響"),
+        (0xFACB, "M", "頋"),
+        (0xFACC, "M", "頻"),
+        (0xFACD, "M", "鬒"),
+        (0xFACE, "M", "龜"),
+        (0xFACF, "M", "𢡊"),
+        (0xFAD0, "M", "𢡄"),
+        (0xFAD1, "M", "𣏕"),
+        (0xFAD2, "M", "㮝"),
+        (0xFAD3, "M", "䀘"),
+        (0xFAD4, "M", "䀹"),
+        (0xFAD5, "M", "𥉉"),
+        (0xFAD6, "M", "𥳐"),
+        (0xFAD7, "M", "𧻓"),
+        (0xFAD8, "M", "齃"),
+        (0xFAD9, "M", "龎"),
+        (0xFADA, "X"),
+        (0xFB00, "M", "ff"),
+        (0xFB01, "M", "fi"),
+        (0xFB02, "M", "fl"),
+        (0xFB03, "M", "ffi"),
+        (0xFB04, "M", "ffl"),
+        (0xFB05, "M", "st"),
+        (0xFB07, "X"),
+        (0xFB13, "M", "մն"),
+        (0xFB14, "M", "մե"),
+        (0xFB15, "M", "մի"),
+        (0xFB16, "M", "վն"),
+        (0xFB17, "M", "մխ"),
+        (0xFB18, "X"),
+        (0xFB1D, "M", "יִ"),
+        (0xFB1E, "V"),
+        (0xFB1F, "M", "ײַ"),
+        (0xFB20, "M", "ע"),
+        (0xFB21, "M", "א"),
+        (0xFB22, "M", "ד"),
+        (0xFB23, "M", "ה"),
+        (0xFB24, "M", "כ"),
+        (0xFB25, "M", "ל"),
+        (0xFB26, "M", "ם"),
+        (0xFB27, "M", "ר"),
+        (0xFB28, "M", "ת"),
+        (0xFB29, "M", "+"),
+        (0xFB2A, "M", "שׁ"),
+        (0xFB2B, "M", "שׂ"),
+        (0xFB2C, "M", "שּׁ"),
+        (0xFB2D, "M", "שּׂ"),
+        (0xFB2E, "M", "אַ"),
+        (0xFB2F, "M", "אָ"),
+        (0xFB30, "M", "אּ"),
+        (0xFB31, "M", "בּ"),
+        (0xFB32, "M", "גּ"),
+        (0xFB33, "M", "דּ"),
+        (0xFB34, "M", "הּ"),
+        (0xFB35, "M", "וּ"),
+        (0xFB36, "M", "זּ"),
+        (0xFB37, "X"),
+        (0xFB38, "M", "טּ"),
+        (0xFB39, "M", "יּ"),
+        (0xFB3A, "M", "ךּ"),
+        (0xFB3B, "M", "כּ"),
+        (0xFB3C, "M", "לּ"),
+        (0xFB3D, "X"),
+        (0xFB3E, "M", "מּ"),
+        (0xFB3F, "X"),
+        (0xFB40, "M", "נּ"),
+        (0xFB41, "M", "סּ"),
+        (0xFB42, "X"),
+        (0xFB43, "M", "ףּ"),
+        (0xFB44, "M", "פּ"),
+        (0xFB45, "X"),
+        (0xFB46, "M", "צּ"),
+        (0xFB47, "M", "קּ"),
+        (0xFB48, "M", "רּ"),
+        (0xFB49, "M", "שּ"),
+        (0xFB4A, "M", "תּ"),
+        (0xFB4B, "M", "וֹ"),
+        (0xFB4C, "M", "בֿ"),
+        (0xFB4D, "M", "כֿ"),
+        (0xFB4E, "M", "פֿ"),
+        (0xFB4F, "M", "אל"),
+        (0xFB50, "M", "ٱ"),
+        (0xFB52, "M", "ٻ"),
+        (0xFB56, "M", "پ"),
+    ]
+
+
+def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFB5A, "M", "ڀ"),
+        (0xFB5E, "M", "ٺ"),
+        (0xFB62, "M", "ٿ"),
+        (0xFB66, "M", "ٹ"),
+        (0xFB6A, "M", "ڤ"),
+        (0xFB6E, "M", "ڦ"),
+        (0xFB72, "M", "ڄ"),
+        (0xFB76, "M", "ڃ"),
+        (0xFB7A, "M", "چ"),
+        (0xFB7E, "M", "ڇ"),
+        (0xFB82, "M", "ڍ"),
+        (0xFB84, "M", "ڌ"),
+        (0xFB86, "M", "ڎ"),
+        (0xFB88, "M", "ڈ"),
+        (0xFB8A, "M", "ژ"),
+        (0xFB8C, "M", "ڑ"),
+        (0xFB8E, "M", "ک"),
+        (0xFB92, "M", "گ"),
+        (0xFB96, "M", "ڳ"),
+        (0xFB9A, "M", "ڱ"),
+        (0xFB9E, "M", "ں"),
+        (0xFBA0, "M", "ڻ"),
+        (0xFBA4, "M", "ۀ"),
+        (0xFBA6, "M", "ہ"),
+        (0xFBAA, "M", "ھ"),
+        (0xFBAE, "M", "ے"),
+        (0xFBB0, "M", "ۓ"),
+        (0xFBB2, "V"),
+        (0xFBC3, "X"),
+        (0xFBD3, "M", "ڭ"),
+        (0xFBD7, "M", "ۇ"),
+        (0xFBD9, "M", "ۆ"),
+        (0xFBDB, "M", "ۈ"),
+        (0xFBDD, "M", "ۇٴ"),
+        (0xFBDE, "M", "ۋ"),
+        (0xFBE0, "M", "ۅ"),
+        (0xFBE2, "M", "ۉ"),
+        (0xFBE4, "M", "ې"),
+        (0xFBE8, "M", "ى"),
+        (0xFBEA, "M", "ئا"),
+        (0xFBEC, "M", "ئە"),
+        (0xFBEE, "M", "ئو"),
+        (0xFBF0, "M", "ئۇ"),
+        (0xFBF2, "M", "ئۆ"),
+        (0xFBF4, "M", "ئۈ"),
+        (0xFBF6, "M", "ئې"),
+        (0xFBF9, "M", "ئى"),
+        (0xFBFC, "M", "ی"),
+        (0xFC00, "M", "ئج"),
+        (0xFC01, "M", "ئح"),
+        (0xFC02, "M", "ئم"),
+        (0xFC03, "M", "ئى"),
+        (0xFC04, "M", "ئي"),
+        (0xFC05, "M", "بج"),
+        (0xFC06, "M", "بح"),
+        (0xFC07, "M", "بخ"),
+        (0xFC08, "M", "بم"),
+        (0xFC09, "M", "بى"),
+        (0xFC0A, "M", "بي"),
+        (0xFC0B, "M", "تج"),
+        (0xFC0C, "M", "تح"),
+        (0xFC0D, "M", "تخ"),
+        (0xFC0E, "M", "تم"),
+        (0xFC0F, "M", "تى"),
+        (0xFC10, "M", "تي"),
+        (0xFC11, "M", "ثج"),
+        (0xFC12, "M", "ثم"),
+        (0xFC13, "M", "ثى"),
+        (0xFC14, "M", "ثي"),
+        (0xFC15, "M", "جح"),
+        (0xFC16, "M", "جم"),
+        (0xFC17, "M", "حج"),
+        (0xFC18, "M", "حم"),
+        (0xFC19, "M", "خج"),
+        (0xFC1A, "M", "خح"),
+        (0xFC1B, "M", "خم"),
+        (0xFC1C, "M", "سج"),
+        (0xFC1D, "M", "سح"),
+        (0xFC1E, "M", "سخ"),
+        (0xFC1F, "M", "سم"),
+        (0xFC20, "M", "صح"),
+        (0xFC21, "M", "صم"),
+        (0xFC22, "M", "ضج"),
+        (0xFC23, "M", "ضح"),
+        (0xFC24, "M", "ضخ"),
+        (0xFC25, "M", "ضم"),
+        (0xFC26, "M", "طح"),
+        (0xFC27, "M", "طم"),
+        (0xFC28, "M", "ظم"),
+        (0xFC29, "M", "عج"),
+        (0xFC2A, "M", "عم"),
+        (0xFC2B, "M", "غج"),
+        (0xFC2C, "M", "غم"),
+        (0xFC2D, "M", "فج"),
+        (0xFC2E, "M", "فح"),
+        (0xFC2F, "M", "فخ"),
+        (0xFC30, "M", "فم"),
+        (0xFC31, "M", "فى"),
+        (0xFC32, "M", "في"),
+        (0xFC33, "M", "قح"),
+    ]
+
+
+def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFC34, "M", "قم"),
+        (0xFC35, "M", "قى"),
+        (0xFC36, "M", "قي"),
+        (0xFC37, "M", "كا"),
+        (0xFC38, "M", "كج"),
+        (0xFC39, "M", "كح"),
+        (0xFC3A, "M", "كخ"),
+        (0xFC3B, "M", "كل"),
+        (0xFC3C, "M", "كم"),
+        (0xFC3D, "M", "كى"),
+        (0xFC3E, "M", "كي"),
+        (0xFC3F, "M", "لج"),
+        (0xFC40, "M", "لح"),
+        (0xFC41, "M", "لخ"),
+        (0xFC42, "M", "لم"),
+        (0xFC43, "M", "لى"),
+        (0xFC44, "M", "لي"),
+        (0xFC45, "M", "مج"),
+        (0xFC46, "M", "مح"),
+        (0xFC47, "M", "مخ"),
+        (0xFC48, "M", "مم"),
+        (0xFC49, "M", "مى"),
+        (0xFC4A, "M", "مي"),
+        (0xFC4B, "M", "نج"),
+        (0xFC4C, "M", "نح"),
+        (0xFC4D, "M", "نخ"),
+        (0xFC4E, "M", "نم"),
+        (0xFC4F, "M", "نى"),
+        (0xFC50, "M", "ني"),
+        (0xFC51, "M", "هج"),
+        (0xFC52, "M", "هم"),
+        (0xFC53, "M", "هى"),
+        (0xFC54, "M", "هي"),
+        (0xFC55, "M", "يج"),
+        (0xFC56, "M", "يح"),
+        (0xFC57, "M", "يخ"),
+        (0xFC58, "M", "يم"),
+        (0xFC59, "M", "يى"),
+        (0xFC5A, "M", "يي"),
+        (0xFC5B, "M", "ذٰ"),
+        (0xFC5C, "M", "رٰ"),
+        (0xFC5D, "M", "ىٰ"),
+        (0xFC5E, "M", " ٌّ"),
+        (0xFC5F, "M", " ٍّ"),
+        (0xFC60, "M", " َّ"),
+        (0xFC61, "M", " ُّ"),
+        (0xFC62, "M", " ِّ"),
+        (0xFC63, "M", " ّٰ"),
+        (0xFC64, "M", "ئر"),
+        (0xFC65, "M", "ئز"),
+        (0xFC66, "M", "ئم"),
+        (0xFC67, "M", "ئن"),
+        (0xFC68, "M", "ئى"),
+        (0xFC69, "M", "ئي"),
+        (0xFC6A, "M", "بر"),
+        (0xFC6B, "M", "بز"),
+        (0xFC6C, "M", "بم"),
+        (0xFC6D, "M", "بن"),
+        (0xFC6E, "M", "بى"),
+        (0xFC6F, "M", "بي"),
+        (0xFC70, "M", "تر"),
+        (0xFC71, "M", "تز"),
+        (0xFC72, "M", "تم"),
+        (0xFC73, "M", "تن"),
+        (0xFC74, "M", "تى"),
+        (0xFC75, "M", "تي"),
+        (0xFC76, "M", "ثر"),
+        (0xFC77, "M", "ثز"),
+        (0xFC78, "M", "ثم"),
+        (0xFC79, "M", "ثن"),
+        (0xFC7A, "M", "ثى"),
+        (0xFC7B, "M", "ثي"),
+        (0xFC7C, "M", "فى"),
+        (0xFC7D, "M", "في"),
+        (0xFC7E, "M", "قى"),
+        (0xFC7F, "M", "قي"),
+        (0xFC80, "M", "كا"),
+        (0xFC81, "M", "كل"),
+        (0xFC82, "M", "كم"),
+        (0xFC83, "M", "كى"),
+        (0xFC84, "M", "كي"),
+        (0xFC85, "M", "لم"),
+        (0xFC86, "M", "لى"),
+        (0xFC87, "M", "لي"),
+        (0xFC88, "M", "ما"),
+        (0xFC89, "M", "مم"),
+        (0xFC8A, "M", "نر"),
+        (0xFC8B, "M", "نز"),
+        (0xFC8C, "M", "نم"),
+        (0xFC8D, "M", "نن"),
+        (0xFC8E, "M", "نى"),
+        (0xFC8F, "M", "ني"),
+        (0xFC90, "M", "ىٰ"),
+        (0xFC91, "M", "ير"),
+        (0xFC92, "M", "يز"),
+        (0xFC93, "M", "يم"),
+        (0xFC94, "M", "ين"),
+        (0xFC95, "M", "يى"),
+        (0xFC96, "M", "يي"),
+        (0xFC97, "M", "ئج"),
+    ]
+
+
+def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFC98, "M", "ئح"),
+        (0xFC99, "M", "ئخ"),
+        (0xFC9A, "M", "ئم"),
+        (0xFC9B, "M", "ئه"),
+        (0xFC9C, "M", "بج"),
+        (0xFC9D, "M", "بح"),
+        (0xFC9E, "M", "بخ"),
+        (0xFC9F, "M", "بم"),
+        (0xFCA0, "M", "به"),
+        (0xFCA1, "M", "تج"),
+        (0xFCA2, "M", "تح"),
+        (0xFCA3, "M", "تخ"),
+        (0xFCA4, "M", "تم"),
+        (0xFCA5, "M", "ته"),
+        (0xFCA6, "M", "ثم"),
+        (0xFCA7, "M", "جح"),
+        (0xFCA8, "M", "جم"),
+        (0xFCA9, "M", "حج"),
+        (0xFCAA, "M", "حم"),
+        (0xFCAB, "M", "خج"),
+        (0xFCAC, "M", "خم"),
+        (0xFCAD, "M", "سج"),
+        (0xFCAE, "M", "سح"),
+        (0xFCAF, "M", "سخ"),
+        (0xFCB0, "M", "سم"),
+        (0xFCB1, "M", "صح"),
+        (0xFCB2, "M", "صخ"),
+        (0xFCB3, "M", "صم"),
+        (0xFCB4, "M", "ضج"),
+        (0xFCB5, "M", "ضح"),
+        (0xFCB6, "M", "ضخ"),
+        (0xFCB7, "M", "ضم"),
+        (0xFCB8, "M", "طح"),
+        (0xFCB9, "M", "ظم"),
+        (0xFCBA, "M", "عج"),
+        (0xFCBB, "M", "عم"),
+        (0xFCBC, "M", "غج"),
+        (0xFCBD, "M", "غم"),
+        (0xFCBE, "M", "فج"),
+        (0xFCBF, "M", "فح"),
+        (0xFCC0, "M", "فخ"),
+        (0xFCC1, "M", "فم"),
+        (0xFCC2, "M", "قح"),
+        (0xFCC3, "M", "قم"),
+        (0xFCC4, "M", "كج"),
+        (0xFCC5, "M", "كح"),
+        (0xFCC6, "M", "كخ"),
+        (0xFCC7, "M", "كل"),
+        (0xFCC8, "M", "كم"),
+        (0xFCC9, "M", "لج"),
+        (0xFCCA, "M", "لح"),
+        (0xFCCB, "M", "لخ"),
+        (0xFCCC, "M", "لم"),
+        (0xFCCD, "M", "له"),
+        (0xFCCE, "M", "مج"),
+        (0xFCCF, "M", "مح"),
+        (0xFCD0, "M", "مخ"),
+        (0xFCD1, "M", "مم"),
+        (0xFCD2, "M", "نج"),
+        (0xFCD3, "M", "نح"),
+        (0xFCD4, "M", "نخ"),
+        (0xFCD5, "M", "نم"),
+        (0xFCD6, "M", "نه"),
+        (0xFCD7, "M", "هج"),
+        (0xFCD8, "M", "هم"),
+        (0xFCD9, "M", "هٰ"),
+        (0xFCDA, "M", "يج"),
+        (0xFCDB, "M", "يح"),
+        (0xFCDC, "M", "يخ"),
+        (0xFCDD, "M", "يم"),
+        (0xFCDE, "M", "يه"),
+        (0xFCDF, "M", "ئم"),
+        (0xFCE0, "M", "ئه"),
+        (0xFCE1, "M", "بم"),
+        (0xFCE2, "M", "به"),
+        (0xFCE3, "M", "تم"),
+        (0xFCE4, "M", "ته"),
+        (0xFCE5, "M", "ثم"),
+        (0xFCE6, "M", "ثه"),
+        (0xFCE7, "M", "سم"),
+        (0xFCE8, "M", "سه"),
+        (0xFCE9, "M", "شم"),
+        (0xFCEA, "M", "شه"),
+        (0xFCEB, "M", "كل"),
+        (0xFCEC, "M", "كم"),
+        (0xFCED, "M", "لم"),
+        (0xFCEE, "M", "نم"),
+        (0xFCEF, "M", "نه"),
+        (0xFCF0, "M", "يم"),
+        (0xFCF1, "M", "يه"),
+        (0xFCF2, "M", "ـَّ"),
+        (0xFCF3, "M", "ـُّ"),
+        (0xFCF4, "M", "ـِّ"),
+        (0xFCF5, "M", "طى"),
+        (0xFCF6, "M", "طي"),
+        (0xFCF7, "M", "عى"),
+        (0xFCF8, "M", "عي"),
+        (0xFCF9, "M", "غى"),
+        (0xFCFA, "M", "غي"),
+        (0xFCFB, "M", "سى"),
+    ]
+
+
+def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFCFC, "M", "سي"),
+        (0xFCFD, "M", "شى"),
+        (0xFCFE, "M", "شي"),
+        (0xFCFF, "M", "حى"),
+        (0xFD00, "M", "حي"),
+        (0xFD01, "M", "جى"),
+        (0xFD02, "M", "جي"),
+        (0xFD03, "M", "خى"),
+        (0xFD04, "M", "خي"),
+        (0xFD05, "M", "صى"),
+        (0xFD06, "M", "صي"),
+        (0xFD07, "M", "ضى"),
+        (0xFD08, "M", "ضي"),
+        (0xFD09, "M", "شج"),
+        (0xFD0A, "M", "شح"),
+        (0xFD0B, "M", "شخ"),
+        (0xFD0C, "M", "شم"),
+        (0xFD0D, "M", "شر"),
+        (0xFD0E, "M", "سر"),
+        (0xFD0F, "M", "صر"),
+        (0xFD10, "M", "ضر"),
+        (0xFD11, "M", "طى"),
+        (0xFD12, "M", "طي"),
+        (0xFD13, "M", "عى"),
+        (0xFD14, "M", "عي"),
+        (0xFD15, "M", "غى"),
+        (0xFD16, "M", "غي"),
+        (0xFD17, "M", "سى"),
+        (0xFD18, "M", "سي"),
+        (0xFD19, "M", "شى"),
+        (0xFD1A, "M", "شي"),
+        (0xFD1B, "M", "حى"),
+        (0xFD1C, "M", "حي"),
+        (0xFD1D, "M", "جى"),
+        (0xFD1E, "M", "جي"),
+        (0xFD1F, "M", "خى"),
+        (0xFD20, "M", "خي"),
+        (0xFD21, "M", "صى"),
+        (0xFD22, "M", "صي"),
+        (0xFD23, "M", "ضى"),
+        (0xFD24, "M", "ضي"),
+        (0xFD25, "M", "شج"),
+        (0xFD26, "M", "شح"),
+        (0xFD27, "M", "شخ"),
+        (0xFD28, "M", "شم"),
+        (0xFD29, "M", "شر"),
+        (0xFD2A, "M", "سر"),
+        (0xFD2B, "M", "صر"),
+        (0xFD2C, "M", "ضر"),
+        (0xFD2D, "M", "شج"),
+        (0xFD2E, "M", "شح"),
+        (0xFD2F, "M", "شخ"),
+        (0xFD30, "M", "شم"),
+        (0xFD31, "M", "سه"),
+        (0xFD32, "M", "شه"),
+        (0xFD33, "M", "طم"),
+        (0xFD34, "M", "سج"),
+        (0xFD35, "M", "سح"),
+        (0xFD36, "M", "سخ"),
+        (0xFD37, "M", "شج"),
+        (0xFD38, "M", "شح"),
+        (0xFD39, "M", "شخ"),
+        (0xFD3A, "M", "طم"),
+        (0xFD3B, "M", "ظم"),
+        (0xFD3C, "M", "اً"),
+        (0xFD3E, "V"),
+        (0xFD50, "M", "تجم"),
+        (0xFD51, "M", "تحج"),
+        (0xFD53, "M", "تحم"),
+        (0xFD54, "M", "تخم"),
+        (0xFD55, "M", "تمج"),
+        (0xFD56, "M", "تمح"),
+        (0xFD57, "M", "تمخ"),
+        (0xFD58, "M", "جمح"),
+        (0xFD5A, "M", "حمي"),
+        (0xFD5B, "M", "حمى"),
+        (0xFD5C, "M", "سحج"),
+        (0xFD5D, "M", "سجح"),
+        (0xFD5E, "M", "سجى"),
+        (0xFD5F, "M", "سمح"),
+        (0xFD61, "M", "سمج"),
+        (0xFD62, "M", "سمم"),
+        (0xFD64, "M", "صحح"),
+        (0xFD66, "M", "صمم"),
+        (0xFD67, "M", "شحم"),
+        (0xFD69, "M", "شجي"),
+        (0xFD6A, "M", "شمخ"),
+        (0xFD6C, "M", "شمم"),
+        (0xFD6E, "M", "ضحى"),
+        (0xFD6F, "M", "ضخم"),
+        (0xFD71, "M", "طمح"),
+        (0xFD73, "M", "طمم"),
+        (0xFD74, "M", "طمي"),
+        (0xFD75, "M", "عجم"),
+        (0xFD76, "M", "عمم"),
+        (0xFD78, "M", "عمى"),
+        (0xFD79, "M", "غمم"),
+        (0xFD7A, "M", "غمي"),
+        (0xFD7B, "M", "غمى"),
+        (0xFD7C, "M", "فخم"),
+    ]
+
+
+def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFD7E, "M", "قمح"),
+        (0xFD7F, "M", "قمم"),
+        (0xFD80, "M", "لحم"),
+        (0xFD81, "M", "لحي"),
+        (0xFD82, "M", "لحى"),
+        (0xFD83, "M", "لجج"),
+        (0xFD85, "M", "لخم"),
+        (0xFD87, "M", "لمح"),
+        (0xFD89, "M", "محج"),
+        (0xFD8A, "M", "محم"),
+        (0xFD8B, "M", "محي"),
+        (0xFD8C, "M", "مجح"),
+        (0xFD8D, "M", "مجم"),
+        (0xFD8E, "M", "مخج"),
+        (0xFD8F, "M", "مخم"),
+        (0xFD90, "X"),
+        (0xFD92, "M", "مجخ"),
+        (0xFD93, "M", "همج"),
+        (0xFD94, "M", "همم"),
+        (0xFD95, "M", "نحم"),
+        (0xFD96, "M", "نحى"),
+        (0xFD97, "M", "نجم"),
+        (0xFD99, "M", "نجى"),
+        (0xFD9A, "M", "نمي"),
+        (0xFD9B, "M", "نمى"),
+        (0xFD9C, "M", "يمم"),
+        (0xFD9E, "M", "بخي"),
+        (0xFD9F, "M", "تجي"),
+        (0xFDA0, "M", "تجى"),
+        (0xFDA1, "M", "تخي"),
+        (0xFDA2, "M", "تخى"),
+        (0xFDA3, "M", "تمي"),
+        (0xFDA4, "M", "تمى"),
+        (0xFDA5, "M", "جمي"),
+        (0xFDA6, "M", "جحى"),
+        (0xFDA7, "M", "جمى"),
+        (0xFDA8, "M", "سخى"),
+        (0xFDA9, "M", "صحي"),
+        (0xFDAA, "M", "شحي"),
+        (0xFDAB, "M", "ضحي"),
+        (0xFDAC, "M", "لجي"),
+        (0xFDAD, "M", "لمي"),
+        (0xFDAE, "M", "يحي"),
+        (0xFDAF, "M", "يجي"),
+        (0xFDB0, "M", "يمي"),
+        (0xFDB1, "M", "ممي"),
+        (0xFDB2, "M", "قمي"),
+        (0xFDB3, "M", "نحي"),
+        (0xFDB4, "M", "قمح"),
+        (0xFDB5, "M", "لحم"),
+        (0xFDB6, "M", "عمي"),
+        (0xFDB7, "M", "كمي"),
+        (0xFDB8, "M", "نجح"),
+        (0xFDB9, "M", "مخي"),
+        (0xFDBA, "M", "لجم"),
+        (0xFDBB, "M", "كمم"),
+        (0xFDBC, "M", "لجم"),
+        (0xFDBD, "M", "نجح"),
+        (0xFDBE, "M", "جحي"),
+        (0xFDBF, "M", "حجي"),
+        (0xFDC0, "M", "مجي"),
+        (0xFDC1, "M", "فمي"),
+        (0xFDC2, "M", "بحي"),
+        (0xFDC3, "M", "كمم"),
+        (0xFDC4, "M", "عجم"),
+        (0xFDC5, "M", "صمم"),
+        (0xFDC6, "M", "سخي"),
+        (0xFDC7, "M", "نجي"),
+        (0xFDC8, "X"),
+        (0xFDCF, "V"),
+        (0xFDD0, "X"),
+        (0xFDF0, "M", "صلے"),
+        (0xFDF1, "M", "قلے"),
+        (0xFDF2, "M", "الله"),
+        (0xFDF3, "M", "اكبر"),
+        (0xFDF4, "M", "محمد"),
+        (0xFDF5, "M", "صلعم"),
+        (0xFDF6, "M", "رسول"),
+        (0xFDF7, "M", "عليه"),
+        (0xFDF8, "M", "وسلم"),
+        (0xFDF9, "M", "صلى"),
+        (0xFDFA, "M", "صلى الله عليه وسلم"),
+        (0xFDFB, "M", "جل جلاله"),
+        (0xFDFC, "M", "ریال"),
+        (0xFDFD, "V"),
+        (0xFE00, "I"),
+        (0xFE10, "M", ","),
+        (0xFE11, "M", "、"),
+        (0xFE12, "X"),
+        (0xFE13, "M", ":"),
+        (0xFE14, "M", ";"),
+        (0xFE15, "M", "!"),
+        (0xFE16, "M", "?"),
+        (0xFE17, "M", "〖"),
+        (0xFE18, "M", "〗"),
+        (0xFE19, "X"),
+        (0xFE20, "V"),
+        (0xFE30, "X"),
+        (0xFE31, "M", "—"),
+        (0xFE32, "M", "–"),
+    ]
+
+
+def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFE33, "M", "_"),
+        (0xFE35, "M", "("),
+        (0xFE36, "M", ")"),
+        (0xFE37, "M", "{"),
+        (0xFE38, "M", "}"),
+        (0xFE39, "M", "〔"),
+        (0xFE3A, "M", "〕"),
+        (0xFE3B, "M", "【"),
+        (0xFE3C, "M", "】"),
+        (0xFE3D, "M", "《"),
+        (0xFE3E, "M", "》"),
+        (0xFE3F, "M", "〈"),
+        (0xFE40, "M", "〉"),
+        (0xFE41, "M", "「"),
+        (0xFE42, "M", "」"),
+        (0xFE43, "M", "『"),
+        (0xFE44, "M", "』"),
+        (0xFE45, "V"),
+        (0xFE47, "M", "["),
+        (0xFE48, "M", "]"),
+        (0xFE49, "M", " ̅"),
+        (0xFE4D, "M", "_"),
+        (0xFE50, "M", ","),
+        (0xFE51, "M", "、"),
+        (0xFE52, "X"),
+        (0xFE54, "M", ";"),
+        (0xFE55, "M", ":"),
+        (0xFE56, "M", "?"),
+        (0xFE57, "M", "!"),
+        (0xFE58, "M", "—"),
+        (0xFE59, "M", "("),
+        (0xFE5A, "M", ")"),
+        (0xFE5B, "M", "{"),
+        (0xFE5C, "M", "}"),
+        (0xFE5D, "M", "〔"),
+        (0xFE5E, "M", "〕"),
+        (0xFE5F, "M", "#"),
+        (0xFE60, "M", "&"),
+        (0xFE61, "M", "*"),
+        (0xFE62, "M", "+"),
+        (0xFE63, "M", "-"),
+        (0xFE64, "M", "<"),
+        (0xFE65, "M", ">"),
+        (0xFE66, "M", "="),
+        (0xFE67, "X"),
+        (0xFE68, "M", "\\"),
+        (0xFE69, "M", "$"),
+        (0xFE6A, "M", "%"),
+        (0xFE6B, "M", "@"),
+        (0xFE6C, "X"),
+        (0xFE70, "M", " ً"),
+        (0xFE71, "M", "ـً"),
+        (0xFE72, "M", " ٌ"),
+        (0xFE73, "V"),
+        (0xFE74, "M", " ٍ"),
+        (0xFE75, "X"),
+        (0xFE76, "M", " َ"),
+        (0xFE77, "M", "ـَ"),
+        (0xFE78, "M", " ُ"),
+        (0xFE79, "M", "ـُ"),
+        (0xFE7A, "M", " ِ"),
+        (0xFE7B, "M", "ـِ"),
+        (0xFE7C, "M", " ّ"),
+        (0xFE7D, "M", "ـّ"),
+        (0xFE7E, "M", " ْ"),
+        (0xFE7F, "M", "ـْ"),
+        (0xFE80, "M", "ء"),
+        (0xFE81, "M", "آ"),
+        (0xFE83, "M", "أ"),
+        (0xFE85, "M", "ؤ"),
+        (0xFE87, "M", "إ"),
+        (0xFE89, "M", "ئ"),
+        (0xFE8D, "M", "ا"),
+        (0xFE8F, "M", "ب"),
+        (0xFE93, "M", "ة"),
+        (0xFE95, "M", "ت"),
+        (0xFE99, "M", "ث"),
+        (0xFE9D, "M", "ج"),
+        (0xFEA1, "M", "ح"),
+        (0xFEA5, "M", "خ"),
+        (0xFEA9, "M", "د"),
+        (0xFEAB, "M", "ذ"),
+        (0xFEAD, "M", "ر"),
+        (0xFEAF, "M", "ز"),
+        (0xFEB1, "M", "س"),
+        (0xFEB5, "M", "ش"),
+        (0xFEB9, "M", "ص"),
+        (0xFEBD, "M", "ض"),
+        (0xFEC1, "M", "ط"),
+        (0xFEC5, "M", "ظ"),
+        (0xFEC9, "M", "ع"),
+        (0xFECD, "M", "غ"),
+        (0xFED1, "M", "ف"),
+        (0xFED5, "M", "ق"),
+        (0xFED9, "M", "ك"),
+        (0xFEDD, "M", "ل"),
+        (0xFEE1, "M", "م"),
+        (0xFEE5, "M", "ن"),
+        (0xFEE9, "M", "ه"),
+        (0xFEED, "M", "و"),
+    ]
+
+
+def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFEEF, "M", "ى"),
+        (0xFEF1, "M", "ي"),
+        (0xFEF5, "M", "لآ"),
+        (0xFEF7, "M", "لأ"),
+        (0xFEF9, "M", "لإ"),
+        (0xFEFB, "M", "لا"),
+        (0xFEFD, "X"),
+        (0xFEFF, "I"),
+        (0xFF00, "X"),
+        (0xFF01, "M", "!"),
+        (0xFF02, "M", '"'),
+        (0xFF03, "M", "#"),
+        (0xFF04, "M", "$"),
+        (0xFF05, "M", "%"),
+        (0xFF06, "M", "&"),
+        (0xFF07, "M", "'"),
+        (0xFF08, "M", "("),
+        (0xFF09, "M", ")"),
+        (0xFF0A, "M", "*"),
+        (0xFF0B, "M", "+"),
+        (0xFF0C, "M", ","),
+        (0xFF0D, "M", "-"),
+        (0xFF0E, "M", "."),
+        (0xFF0F, "M", "/"),
+        (0xFF10, "M", "0"),
+        (0xFF11, "M", "1"),
+        (0xFF12, "M", "2"),
+        (0xFF13, "M", "3"),
+        (0xFF14, "M", "4"),
+        (0xFF15, "M", "5"),
+        (0xFF16, "M", "6"),
+        (0xFF17, "M", "7"),
+        (0xFF18, "M", "8"),
+        (0xFF19, "M", "9"),
+        (0xFF1A, "M", ":"),
+        (0xFF1B, "M", ";"),
+        (0xFF1C, "M", "<"),
+        (0xFF1D, "M", "="),
+        (0xFF1E, "M", ">"),
+        (0xFF1F, "M", "?"),
+        (0xFF20, "M", "@"),
+        (0xFF21, "M", "a"),
+        (0xFF22, "M", "b"),
+        (0xFF23, "M", "c"),
+        (0xFF24, "M", "d"),
+        (0xFF25, "M", "e"),
+        (0xFF26, "M", "f"),
+        (0xFF27, "M", "g"),
+        (0xFF28, "M", "h"),
+        (0xFF29, "M", "i"),
+        (0xFF2A, "M", "j"),
+        (0xFF2B, "M", "k"),
+        (0xFF2C, "M", "l"),
+        (0xFF2D, "M", "m"),
+        (0xFF2E, "M", "n"),
+        (0xFF2F, "M", "o"),
+        (0xFF30, "M", "p"),
+        (0xFF31, "M", "q"),
+        (0xFF32, "M", "r"),
+        (0xFF33, "M", "s"),
+        (0xFF34, "M", "t"),
+        (0xFF35, "M", "u"),
+        (0xFF36, "M", "v"),
+        (0xFF37, "M", "w"),
+        (0xFF38, "M", "x"),
+        (0xFF39, "M", "y"),
+        (0xFF3A, "M", "z"),
+        (0xFF3B, "M", "["),
+        (0xFF3C, "M", "\\"),
+        (0xFF3D, "M", "]"),
+        (0xFF3E, "M", "^"),
+        (0xFF3F, "M", "_"),
+        (0xFF40, "M", "`"),
+        (0xFF41, "M", "a"),
+        (0xFF42, "M", "b"),
+        (0xFF43, "M", "c"),
+        (0xFF44, "M", "d"),
+        (0xFF45, "M", "e"),
+        (0xFF46, "M", "f"),
+        (0xFF47, "M", "g"),
+        (0xFF48, "M", "h"),
+        (0xFF49, "M", "i"),
+        (0xFF4A, "M", "j"),
+        (0xFF4B, "M", "k"),
+        (0xFF4C, "M", "l"),
+        (0xFF4D, "M", "m"),
+        (0xFF4E, "M", "n"),
+        (0xFF4F, "M", "o"),
+        (0xFF50, "M", "p"),
+        (0xFF51, "M", "q"),
+        (0xFF52, "M", "r"),
+        (0xFF53, "M", "s"),
+        (0xFF54, "M", "t"),
+        (0xFF55, "M", "u"),
+        (0xFF56, "M", "v"),
+        (0xFF57, "M", "w"),
+        (0xFF58, "M", "x"),
+        (0xFF59, "M", "y"),
+        (0xFF5A, "M", "z"),
+        (0xFF5B, "M", "{"),
+    ]
+
+
+def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFF5C, "M", "|"),
+        (0xFF5D, "M", "}"),
+        (0xFF5E, "M", "~"),
+        (0xFF5F, "M", "⦅"),
+        (0xFF60, "M", "⦆"),
+        (0xFF61, "M", "."),
+        (0xFF62, "M", "「"),
+        (0xFF63, "M", "」"),
+        (0xFF64, "M", "、"),
+        (0xFF65, "M", "・"),
+        (0xFF66, "M", "ヲ"),
+        (0xFF67, "M", "ァ"),
+        (0xFF68, "M", "ィ"),
+        (0xFF69, "M", "ゥ"),
+        (0xFF6A, "M", "ェ"),
+        (0xFF6B, "M", "ォ"),
+        (0xFF6C, "M", "ャ"),
+        (0xFF6D, "M", "ュ"),
+        (0xFF6E, "M", "ョ"),
+        (0xFF6F, "M", "ッ"),
+        (0xFF70, "M", "ー"),
+        (0xFF71, "M", "ア"),
+        (0xFF72, "M", "イ"),
+        (0xFF73, "M", "ウ"),
+        (0xFF74, "M", "エ"),
+        (0xFF75, "M", "オ"),
+        (0xFF76, "M", "カ"),
+        (0xFF77, "M", "キ"),
+        (0xFF78, "M", "ク"),
+        (0xFF79, "M", "ケ"),
+        (0xFF7A, "M", "コ"),
+        (0xFF7B, "M", "サ"),
+        (0xFF7C, "M", "シ"),
+        (0xFF7D, "M", "ス"),
+        (0xFF7E, "M", "セ"),
+        (0xFF7F, "M", "ソ"),
+        (0xFF80, "M", "タ"),
+        (0xFF81, "M", "チ"),
+        (0xFF82, "M", "ツ"),
+        (0xFF83, "M", "テ"),
+        (0xFF84, "M", "ト"),
+        (0xFF85, "M", "ナ"),
+        (0xFF86, "M", "ニ"),
+        (0xFF87, "M", "ヌ"),
+        (0xFF88, "M", "ネ"),
+        (0xFF89, "M", "ノ"),
+        (0xFF8A, "M", "ハ"),
+        (0xFF8B, "M", "ヒ"),
+        (0xFF8C, "M", "フ"),
+        (0xFF8D, "M", "ヘ"),
+        (0xFF8E, "M", "ホ"),
+        (0xFF8F, "M", "マ"),
+        (0xFF90, "M", "ミ"),
+        (0xFF91, "M", "ム"),
+        (0xFF92, "M", "メ"),
+        (0xFF93, "M", "モ"),
+        (0xFF94, "M", "ヤ"),
+        (0xFF95, "M", "ユ"),
+        (0xFF96, "M", "ヨ"),
+        (0xFF97, "M", "ラ"),
+        (0xFF98, "M", "リ"),
+        (0xFF99, "M", "ル"),
+        (0xFF9A, "M", "レ"),
+        (0xFF9B, "M", "ロ"),
+        (0xFF9C, "M", "ワ"),
+        (0xFF9D, "M", "ン"),
+        (0xFF9E, "M", "゙"),
+        (0xFF9F, "M", "゚"),
+        (0xFFA0, "I"),
+        (0xFFA1, "M", "ᄀ"),
+        (0xFFA2, "M", "ᄁ"),
+        (0xFFA3, "M", "ᆪ"),
+        (0xFFA4, "M", "ᄂ"),
+        (0xFFA5, "M", "ᆬ"),
+        (0xFFA6, "M", "ᆭ"),
+        (0xFFA7, "M", "ᄃ"),
+        (0xFFA8, "M", "ᄄ"),
+        (0xFFA9, "M", "ᄅ"),
+        (0xFFAA, "M", "ᆰ"),
+        (0xFFAB, "M", "ᆱ"),
+        (0xFFAC, "M", "ᆲ"),
+        (0xFFAD, "M", "ᆳ"),
+        (0xFFAE, "M", "ᆴ"),
+        (0xFFAF, "M", "ᆵ"),
+        (0xFFB0, "M", "ᄚ"),
+        (0xFFB1, "M", "ᄆ"),
+        (0xFFB2, "M", "ᄇ"),
+        (0xFFB3, "M", "ᄈ"),
+        (0xFFB4, "M", "ᄡ"),
+        (0xFFB5, "M", "ᄉ"),
+        (0xFFB6, "M", "ᄊ"),
+        (0xFFB7, "M", "ᄋ"),
+        (0xFFB8, "M", "ᄌ"),
+        (0xFFB9, "M", "ᄍ"),
+        (0xFFBA, "M", "ᄎ"),
+        (0xFFBB, "M", "ᄏ"),
+        (0xFFBC, "M", "ᄐ"),
+        (0xFFBD, "M", "ᄑ"),
+        (0xFFBE, "M", "ᄒ"),
+        (0xFFBF, "X"),
+    ]
+
+
+def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0xFFC2, "M", "ᅡ"),
+        (0xFFC3, "M", "ᅢ"),
+        (0xFFC4, "M", "ᅣ"),
+        (0xFFC5, "M", "ᅤ"),
+        (0xFFC6, "M", "ᅥ"),
+        (0xFFC7, "M", "ᅦ"),
+        (0xFFC8, "X"),
+        (0xFFCA, "M", "ᅧ"),
+        (0xFFCB, "M", "ᅨ"),
+        (0xFFCC, "M", "ᅩ"),
+        (0xFFCD, "M", "ᅪ"),
+        (0xFFCE, "M", "ᅫ"),
+        (0xFFCF, "M", "ᅬ"),
+        (0xFFD0, "X"),
+        (0xFFD2, "M", "ᅭ"),
+        (0xFFD3, "M", "ᅮ"),
+        (0xFFD4, "M", "ᅯ"),
+        (0xFFD5, "M", "ᅰ"),
+        (0xFFD6, "M", "ᅱ"),
+        (0xFFD7, "M", "ᅲ"),
+        (0xFFD8, "X"),
+        (0xFFDA, "M", "ᅳ"),
+        (0xFFDB, "M", "ᅴ"),
+        (0xFFDC, "M", "ᅵ"),
+        (0xFFDD, "X"),
+        (0xFFE0, "M", "¢"),
+        (0xFFE1, "M", "£"),
+        (0xFFE2, "M", "¬"),
+        (0xFFE3, "M", " ̄"),
+        (0xFFE4, "M", "¦"),
+        (0xFFE5, "M", "¥"),
+        (0xFFE6, "M", "₩"),
+        (0xFFE7, "X"),
+        (0xFFE8, "M", "│"),
+        (0xFFE9, "M", "←"),
+        (0xFFEA, "M", "↑"),
+        (0xFFEB, "M", "→"),
+        (0xFFEC, "M", "↓"),
+        (0xFFED, "M", "■"),
+        (0xFFEE, "M", "○"),
+        (0xFFEF, "X"),
+        (0x10000, "V"),
+        (0x1000C, "X"),
+        (0x1000D, "V"),
+        (0x10027, "X"),
+        (0x10028, "V"),
+        (0x1003B, "X"),
+        (0x1003C, "V"),
+        (0x1003E, "X"),
+        (0x1003F, "V"),
+        (0x1004E, "X"),
+        (0x10050, "V"),
+        (0x1005E, "X"),
+        (0x10080, "V"),
+        (0x100FB, "X"),
+        (0x10100, "V"),
+        (0x10103, "X"),
+        (0x10107, "V"),
+        (0x10134, "X"),
+        (0x10137, "V"),
+        (0x1018F, "X"),
+        (0x10190, "V"),
+        (0x1019D, "X"),
+        (0x101A0, "V"),
+        (0x101A1, "X"),
+        (0x101D0, "V"),
+        (0x101FE, "X"),
+        (0x10280, "V"),
+        (0x1029D, "X"),
+        (0x102A0, "V"),
+        (0x102D1, "X"),
+        (0x102E0, "V"),
+        (0x102FC, "X"),
+        (0x10300, "V"),
+        (0x10324, "X"),
+        (0x1032D, "V"),
+        (0x1034B, "X"),
+        (0x10350, "V"),
+        (0x1037B, "X"),
+        (0x10380, "V"),
+        (0x1039E, "X"),
+        (0x1039F, "V"),
+        (0x103C4, "X"),
+        (0x103C8, "V"),
+        (0x103D6, "X"),
+        (0x10400, "M", "𐐨"),
+        (0x10401, "M", "𐐩"),
+        (0x10402, "M", "𐐪"),
+        (0x10403, "M", "𐐫"),
+        (0x10404, "M", "𐐬"),
+        (0x10405, "M", "𐐭"),
+        (0x10406, "M", "𐐮"),
+        (0x10407, "M", "𐐯"),
+        (0x10408, "M", "𐐰"),
+        (0x10409, "M", "𐐱"),
+        (0x1040A, "M", "𐐲"),
+        (0x1040B, "M", "𐐳"),
+        (0x1040C, "M", "𐐴"),
+        (0x1040D, "M", "𐐵"),
+        (0x1040E, "M", "𐐶"),
+    ]
+
+
+def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1040F, "M", "𐐷"),
+        (0x10410, "M", "𐐸"),
+        (0x10411, "M", "𐐹"),
+        (0x10412, "M", "𐐺"),
+        (0x10413, "M", "𐐻"),
+        (0x10414, "M", "𐐼"),
+        (0x10415, "M", "𐐽"),
+        (0x10416, "M", "𐐾"),
+        (0x10417, "M", "𐐿"),
+        (0x10418, "M", "𐑀"),
+        (0x10419, "M", "𐑁"),
+        (0x1041A, "M", "𐑂"),
+        (0x1041B, "M", "𐑃"),
+        (0x1041C, "M", "𐑄"),
+        (0x1041D, "M", "𐑅"),
+        (0x1041E, "M", "𐑆"),
+        (0x1041F, "M", "𐑇"),
+        (0x10420, "M", "𐑈"),
+        (0x10421, "M", "𐑉"),
+        (0x10422, "M", "𐑊"),
+        (0x10423, "M", "𐑋"),
+        (0x10424, "M", "𐑌"),
+        (0x10425, "M", "𐑍"),
+        (0x10426, "M", "𐑎"),
+        (0x10427, "M", "𐑏"),
+        (0x10428, "V"),
+        (0x1049E, "X"),
+        (0x104A0, "V"),
+        (0x104AA, "X"),
+        (0x104B0, "M", "𐓘"),
+        (0x104B1, "M", "𐓙"),
+        (0x104B2, "M", "𐓚"),
+        (0x104B3, "M", "𐓛"),
+        (0x104B4, "M", "𐓜"),
+        (0x104B5, "M", "𐓝"),
+        (0x104B6, "M", "𐓞"),
+        (0x104B7, "M", "𐓟"),
+        (0x104B8, "M", "𐓠"),
+        (0x104B9, "M", "𐓡"),
+        (0x104BA, "M", "𐓢"),
+        (0x104BB, "M", "𐓣"),
+        (0x104BC, "M", "𐓤"),
+        (0x104BD, "M", "𐓥"),
+        (0x104BE, "M", "𐓦"),
+        (0x104BF, "M", "𐓧"),
+        (0x104C0, "M", "𐓨"),
+        (0x104C1, "M", "𐓩"),
+        (0x104C2, "M", "𐓪"),
+        (0x104C3, "M", "𐓫"),
+        (0x104C4, "M", "𐓬"),
+        (0x104C5, "M", "𐓭"),
+        (0x104C6, "M", "𐓮"),
+        (0x104C7, "M", "𐓯"),
+        (0x104C8, "M", "𐓰"),
+        (0x104C9, "M", "𐓱"),
+        (0x104CA, "M", "𐓲"),
+        (0x104CB, "M", "𐓳"),
+        (0x104CC, "M", "𐓴"),
+        (0x104CD, "M", "𐓵"),
+        (0x104CE, "M", "𐓶"),
+        (0x104CF, "M", "𐓷"),
+        (0x104D0, "M", "𐓸"),
+        (0x104D1, "M", "𐓹"),
+        (0x104D2, "M", "𐓺"),
+        (0x104D3, "M", "𐓻"),
+        (0x104D4, "X"),
+        (0x104D8, "V"),
+        (0x104FC, "X"),
+        (0x10500, "V"),
+        (0x10528, "X"),
+        (0x10530, "V"),
+        (0x10564, "X"),
+        (0x1056F, "V"),
+        (0x10570, "M", "𐖗"),
+        (0x10571, "M", "𐖘"),
+        (0x10572, "M", "𐖙"),
+        (0x10573, "M", "𐖚"),
+        (0x10574, "M", "𐖛"),
+        (0x10575, "M", "𐖜"),
+        (0x10576, "M", "𐖝"),
+        (0x10577, "M", "𐖞"),
+        (0x10578, "M", "𐖟"),
+        (0x10579, "M", "𐖠"),
+        (0x1057A, "M", "𐖡"),
+        (0x1057B, "X"),
+        (0x1057C, "M", "𐖣"),
+        (0x1057D, "M", "𐖤"),
+        (0x1057E, "M", "𐖥"),
+        (0x1057F, "M", "𐖦"),
+        (0x10580, "M", "𐖧"),
+        (0x10581, "M", "𐖨"),
+        (0x10582, "M", "𐖩"),
+        (0x10583, "M", "𐖪"),
+        (0x10584, "M", "𐖫"),
+        (0x10585, "M", "𐖬"),
+        (0x10586, "M", "𐖭"),
+        (0x10587, "M", "𐖮"),
+        (0x10588, "M", "𐖯"),
+        (0x10589, "M", "𐖰"),
+        (0x1058A, "M", "𐖱"),
+    ]
+
+
+def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1058B, "X"),
+        (0x1058C, "M", "𐖳"),
+        (0x1058D, "M", "𐖴"),
+        (0x1058E, "M", "𐖵"),
+        (0x1058F, "M", "𐖶"),
+        (0x10590, "M", "𐖷"),
+        (0x10591, "M", "𐖸"),
+        (0x10592, "M", "𐖹"),
+        (0x10593, "X"),
+        (0x10594, "M", "𐖻"),
+        (0x10595, "M", "𐖼"),
+        (0x10596, "X"),
+        (0x10597, "V"),
+        (0x105A2, "X"),
+        (0x105A3, "V"),
+        (0x105B2, "X"),
+        (0x105B3, "V"),
+        (0x105BA, "X"),
+        (0x105BB, "V"),
+        (0x105BD, "X"),
+        (0x105C0, "V"),
+        (0x105F4, "X"),
+        (0x10600, "V"),
+        (0x10737, "X"),
+        (0x10740, "V"),
+        (0x10756, "X"),
+        (0x10760, "V"),
+        (0x10768, "X"),
+        (0x10780, "V"),
+        (0x10781, "M", "ː"),
+        (0x10782, "M", "ˑ"),
+        (0x10783, "M", "æ"),
+        (0x10784, "M", "ʙ"),
+        (0x10785, "M", "ɓ"),
+        (0x10786, "X"),
+        (0x10787, "M", "ʣ"),
+        (0x10788, "M", "ꭦ"),
+        (0x10789, "M", "ʥ"),
+        (0x1078A, "M", "ʤ"),
+        (0x1078B, "M", "ɖ"),
+        (0x1078C, "M", "ɗ"),
+        (0x1078D, "M", "ᶑ"),
+        (0x1078E, "M", "ɘ"),
+        (0x1078F, "M", "ɞ"),
+        (0x10790, "M", "ʩ"),
+        (0x10791, "M", "ɤ"),
+        (0x10792, "M", "ɢ"),
+        (0x10793, "M", "ɠ"),
+        (0x10794, "M", "ʛ"),
+        (0x10795, "M", "ħ"),
+        (0x10796, "M", "ʜ"),
+        (0x10797, "M", "ɧ"),
+        (0x10798, "M", "ʄ"),
+        (0x10799, "M", "ʪ"),
+        (0x1079A, "M", "ʫ"),
+        (0x1079B, "M", "ɬ"),
+        (0x1079C, "M", "𝼄"),
+        (0x1079D, "M", "ꞎ"),
+        (0x1079E, "M", "ɮ"),
+        (0x1079F, "M", "𝼅"),
+        (0x107A0, "M", "ʎ"),
+        (0x107A1, "M", "𝼆"),
+        (0x107A2, "M", "ø"),
+        (0x107A3, "M", "ɶ"),
+        (0x107A4, "M", "ɷ"),
+        (0x107A5, "M", "q"),
+        (0x107A6, "M", "ɺ"),
+        (0x107A7, "M", "𝼈"),
+        (0x107A8, "M", "ɽ"),
+        (0x107A9, "M", "ɾ"),
+        (0x107AA, "M", "ʀ"),
+        (0x107AB, "M", "ʨ"),
+        (0x107AC, "M", "ʦ"),
+        (0x107AD, "M", "ꭧ"),
+        (0x107AE, "M", "ʧ"),
+        (0x107AF, "M", "ʈ"),
+        (0x107B0, "M", "ⱱ"),
+        (0x107B1, "X"),
+        (0x107B2, "M", "ʏ"),
+        (0x107B3, "M", "ʡ"),
+        (0x107B4, "M", "ʢ"),
+        (0x107B5, "M", "ʘ"),
+        (0x107B6, "M", "ǀ"),
+        (0x107B7, "M", "ǁ"),
+        (0x107B8, "M", "ǂ"),
+        (0x107B9, "M", "𝼊"),
+        (0x107BA, "M", "𝼞"),
+        (0x107BB, "X"),
+        (0x10800, "V"),
+        (0x10806, "X"),
+        (0x10808, "V"),
+        (0x10809, "X"),
+        (0x1080A, "V"),
+        (0x10836, "X"),
+        (0x10837, "V"),
+        (0x10839, "X"),
+        (0x1083C, "V"),
+        (0x1083D, "X"),
+        (0x1083F, "V"),
+        (0x10856, "X"),
+    ]
+
+
+def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x10857, "V"),
+        (0x1089F, "X"),
+        (0x108A7, "V"),
+        (0x108B0, "X"),
+        (0x108E0, "V"),
+        (0x108F3, "X"),
+        (0x108F4, "V"),
+        (0x108F6, "X"),
+        (0x108FB, "V"),
+        (0x1091C, "X"),
+        (0x1091F, "V"),
+        (0x1093A, "X"),
+        (0x1093F, "V"),
+        (0x10940, "X"),
+        (0x10980, "V"),
+        (0x109B8, "X"),
+        (0x109BC, "V"),
+        (0x109D0, "X"),
+        (0x109D2, "V"),
+        (0x10A04, "X"),
+        (0x10A05, "V"),
+        (0x10A07, "X"),
+        (0x10A0C, "V"),
+        (0x10A14, "X"),
+        (0x10A15, "V"),
+        (0x10A18, "X"),
+        (0x10A19, "V"),
+        (0x10A36, "X"),
+        (0x10A38, "V"),
+        (0x10A3B, "X"),
+        (0x10A3F, "V"),
+        (0x10A49, "X"),
+        (0x10A50, "V"),
+        (0x10A59, "X"),
+        (0x10A60, "V"),
+        (0x10AA0, "X"),
+        (0x10AC0, "V"),
+        (0x10AE7, "X"),
+        (0x10AEB, "V"),
+        (0x10AF7, "X"),
+        (0x10B00, "V"),
+        (0x10B36, "X"),
+        (0x10B39, "V"),
+        (0x10B56, "X"),
+        (0x10B58, "V"),
+        (0x10B73, "X"),
+        (0x10B78, "V"),
+        (0x10B92, "X"),
+        (0x10B99, "V"),
+        (0x10B9D, "X"),
+        (0x10BA9, "V"),
+        (0x10BB0, "X"),
+        (0x10C00, "V"),
+        (0x10C49, "X"),
+        (0x10C80, "M", "𐳀"),
+        (0x10C81, "M", "𐳁"),
+        (0x10C82, "M", "𐳂"),
+        (0x10C83, "M", "𐳃"),
+        (0x10C84, "M", "𐳄"),
+        (0x10C85, "M", "𐳅"),
+        (0x10C86, "M", "𐳆"),
+        (0x10C87, "M", "𐳇"),
+        (0x10C88, "M", "𐳈"),
+        (0x10C89, "M", "𐳉"),
+        (0x10C8A, "M", "𐳊"),
+        (0x10C8B, "M", "𐳋"),
+        (0x10C8C, "M", "𐳌"),
+        (0x10C8D, "M", "𐳍"),
+        (0x10C8E, "M", "𐳎"),
+        (0x10C8F, "M", "𐳏"),
+        (0x10C90, "M", "𐳐"),
+        (0x10C91, "M", "𐳑"),
+        (0x10C92, "M", "𐳒"),
+        (0x10C93, "M", "𐳓"),
+        (0x10C94, "M", "𐳔"),
+        (0x10C95, "M", "𐳕"),
+        (0x10C96, "M", "𐳖"),
+        (0x10C97, "M", "𐳗"),
+        (0x10C98, "M", "𐳘"),
+        (0x10C99, "M", "𐳙"),
+        (0x10C9A, "M", "𐳚"),
+        (0x10C9B, "M", "𐳛"),
+        (0x10C9C, "M", "𐳜"),
+        (0x10C9D, "M", "𐳝"),
+        (0x10C9E, "M", "𐳞"),
+        (0x10C9F, "M", "𐳟"),
+        (0x10CA0, "M", "𐳠"),
+        (0x10CA1, "M", "𐳡"),
+        (0x10CA2, "M", "𐳢"),
+        (0x10CA3, "M", "𐳣"),
+        (0x10CA4, "M", "𐳤"),
+        (0x10CA5, "M", "𐳥"),
+        (0x10CA6, "M", "𐳦"),
+        (0x10CA7, "M", "𐳧"),
+        (0x10CA8, "M", "𐳨"),
+        (0x10CA9, "M", "𐳩"),
+        (0x10CAA, "M", "𐳪"),
+        (0x10CAB, "M", "𐳫"),
+        (0x10CAC, "M", "𐳬"),
+        (0x10CAD, "M", "𐳭"),
+    ]
+
+
+def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x10CAE, "M", "𐳮"),
+        (0x10CAF, "M", "𐳯"),
+        (0x10CB0, "M", "𐳰"),
+        (0x10CB1, "M", "𐳱"),
+        (0x10CB2, "M", "𐳲"),
+        (0x10CB3, "X"),
+        (0x10CC0, "V"),
+        (0x10CF3, "X"),
+        (0x10CFA, "V"),
+        (0x10D28, "X"),
+        (0x10D30, "V"),
+        (0x10D3A, "X"),
+        (0x10D40, "V"),
+        (0x10D50, "M", "𐵰"),
+        (0x10D51, "M", "𐵱"),
+        (0x10D52, "M", "𐵲"),
+        (0x10D53, "M", "𐵳"),
+        (0x10D54, "M", "𐵴"),
+        (0x10D55, "M", "𐵵"),
+        (0x10D56, "M", "𐵶"),
+        (0x10D57, "M", "𐵷"),
+        (0x10D58, "M", "𐵸"),
+        (0x10D59, "M", "𐵹"),
+        (0x10D5A, "M", "𐵺"),
+        (0x10D5B, "M", "𐵻"),
+        (0x10D5C, "M", "𐵼"),
+        (0x10D5D, "M", "𐵽"),
+        (0x10D5E, "M", "𐵾"),
+        (0x10D5F, "M", "𐵿"),
+        (0x10D60, "M", "𐶀"),
+        (0x10D61, "M", "𐶁"),
+        (0x10D62, "M", "𐶂"),
+        (0x10D63, "M", "𐶃"),
+        (0x10D64, "M", "𐶄"),
+        (0x10D65, "M", "𐶅"),
+        (0x10D66, "X"),
+        (0x10D69, "V"),
+        (0x10D86, "X"),
+        (0x10D8E, "V"),
+        (0x10D90, "X"),
+        (0x10E60, "V"),
+        (0x10E7F, "X"),
+        (0x10E80, "V"),
+        (0x10EAA, "X"),
+        (0x10EAB, "V"),
+        (0x10EAE, "X"),
+        (0x10EB0, "V"),
+        (0x10EB2, "X"),
+        (0x10EC2, "V"),
+        (0x10EC5, "X"),
+        (0x10EFC, "V"),
+        (0x10F28, "X"),
+        (0x10F30, "V"),
+        (0x10F5A, "X"),
+        (0x10F70, "V"),
+        (0x10F8A, "X"),
+        (0x10FB0, "V"),
+        (0x10FCC, "X"),
+        (0x10FE0, "V"),
+        (0x10FF7, "X"),
+        (0x11000, "V"),
+        (0x1104E, "X"),
+        (0x11052, "V"),
+        (0x11076, "X"),
+        (0x1107F, "V"),
+        (0x110BD, "X"),
+        (0x110BE, "V"),
+        (0x110C3, "X"),
+        (0x110D0, "V"),
+        (0x110E9, "X"),
+        (0x110F0, "V"),
+        (0x110FA, "X"),
+        (0x11100, "V"),
+        (0x11135, "X"),
+        (0x11136, "V"),
+        (0x11148, "X"),
+        (0x11150, "V"),
+        (0x11177, "X"),
+        (0x11180, "V"),
+        (0x111E0, "X"),
+        (0x111E1, "V"),
+        (0x111F5, "X"),
+        (0x11200, "V"),
+        (0x11212, "X"),
+        (0x11213, "V"),
+        (0x11242, "X"),
+        (0x11280, "V"),
+        (0x11287, "X"),
+        (0x11288, "V"),
+        (0x11289, "X"),
+        (0x1128A, "V"),
+        (0x1128E, "X"),
+        (0x1128F, "V"),
+        (0x1129E, "X"),
+        (0x1129F, "V"),
+        (0x112AA, "X"),
+        (0x112B0, "V"),
+        (0x112EB, "X"),
+        (0x112F0, "V"),
+        (0x112FA, "X"),
+    ]
+
+
+def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x11300, "V"),
+        (0x11304, "X"),
+        (0x11305, "V"),
+        (0x1130D, "X"),
+        (0x1130F, "V"),
+        (0x11311, "X"),
+        (0x11313, "V"),
+        (0x11329, "X"),
+        (0x1132A, "V"),
+        (0x11331, "X"),
+        (0x11332, "V"),
+        (0x11334, "X"),
+        (0x11335, "V"),
+        (0x1133A, "X"),
+        (0x1133B, "V"),
+        (0x11345, "X"),
+        (0x11347, "V"),
+        (0x11349, "X"),
+        (0x1134B, "V"),
+        (0x1134E, "X"),
+        (0x11350, "V"),
+        (0x11351, "X"),
+        (0x11357, "V"),
+        (0x11358, "X"),
+        (0x1135D, "V"),
+        (0x11364, "X"),
+        (0x11366, "V"),
+        (0x1136D, "X"),
+        (0x11370, "V"),
+        (0x11375, "X"),
+        (0x11380, "V"),
+        (0x1138A, "X"),
+        (0x1138B, "V"),
+        (0x1138C, "X"),
+        (0x1138E, "V"),
+        (0x1138F, "X"),
+        (0x11390, "V"),
+        (0x113B6, "X"),
+        (0x113B7, "V"),
+        (0x113C1, "X"),
+        (0x113C2, "V"),
+        (0x113C3, "X"),
+        (0x113C5, "V"),
+        (0x113C6, "X"),
+        (0x113C7, "V"),
+        (0x113CB, "X"),
+        (0x113CC, "V"),
+        (0x113D6, "X"),
+        (0x113D7, "V"),
+        (0x113D9, "X"),
+        (0x113E1, "V"),
+        (0x113E3, "X"),
+        (0x11400, "V"),
+        (0x1145C, "X"),
+        (0x1145D, "V"),
+        (0x11462, "X"),
+        (0x11480, "V"),
+        (0x114C8, "X"),
+        (0x114D0, "V"),
+        (0x114DA, "X"),
+        (0x11580, "V"),
+        (0x115B6, "X"),
+        (0x115B8, "V"),
+        (0x115DE, "X"),
+        (0x11600, "V"),
+        (0x11645, "X"),
+        (0x11650, "V"),
+        (0x1165A, "X"),
+        (0x11660, "V"),
+        (0x1166D, "X"),
+        (0x11680, "V"),
+        (0x116BA, "X"),
+        (0x116C0, "V"),
+        (0x116CA, "X"),
+        (0x116D0, "V"),
+        (0x116E4, "X"),
+        (0x11700, "V"),
+        (0x1171B, "X"),
+        (0x1171D, "V"),
+        (0x1172C, "X"),
+        (0x11730, "V"),
+        (0x11747, "X"),
+        (0x11800, "V"),
+        (0x1183C, "X"),
+        (0x118A0, "M", "𑣀"),
+        (0x118A1, "M", "𑣁"),
+        (0x118A2, "M", "𑣂"),
+        (0x118A3, "M", "𑣃"),
+        (0x118A4, "M", "𑣄"),
+        (0x118A5, "M", "𑣅"),
+        (0x118A6, "M", "𑣆"),
+        (0x118A7, "M", "𑣇"),
+        (0x118A8, "M", "𑣈"),
+        (0x118A9, "M", "𑣉"),
+        (0x118AA, "M", "𑣊"),
+        (0x118AB, "M", "𑣋"),
+        (0x118AC, "M", "𑣌"),
+        (0x118AD, "M", "𑣍"),
+        (0x118AE, "M", "𑣎"),
+        (0x118AF, "M", "𑣏"),
+    ]
+
+
+def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x118B0, "M", "𑣐"),
+        (0x118B1, "M", "𑣑"),
+        (0x118B2, "M", "𑣒"),
+        (0x118B3, "M", "𑣓"),
+        (0x118B4, "M", "𑣔"),
+        (0x118B5, "M", "𑣕"),
+        (0x118B6, "M", "𑣖"),
+        (0x118B7, "M", "𑣗"),
+        (0x118B8, "M", "𑣘"),
+        (0x118B9, "M", "𑣙"),
+        (0x118BA, "M", "𑣚"),
+        (0x118BB, "M", "𑣛"),
+        (0x118BC, "M", "𑣜"),
+        (0x118BD, "M", "𑣝"),
+        (0x118BE, "M", "𑣞"),
+        (0x118BF, "M", "𑣟"),
+        (0x118C0, "V"),
+        (0x118F3, "X"),
+        (0x118FF, "V"),
+        (0x11907, "X"),
+        (0x11909, "V"),
+        (0x1190A, "X"),
+        (0x1190C, "V"),
+        (0x11914, "X"),
+        (0x11915, "V"),
+        (0x11917, "X"),
+        (0x11918, "V"),
+        (0x11936, "X"),
+        (0x11937, "V"),
+        (0x11939, "X"),
+        (0x1193B, "V"),
+        (0x11947, "X"),
+        (0x11950, "V"),
+        (0x1195A, "X"),
+        (0x119A0, "V"),
+        (0x119A8, "X"),
+        (0x119AA, "V"),
+        (0x119D8, "X"),
+        (0x119DA, "V"),
+        (0x119E5, "X"),
+        (0x11A00, "V"),
+        (0x11A48, "X"),
+        (0x11A50, "V"),
+        (0x11AA3, "X"),
+        (0x11AB0, "V"),
+        (0x11AF9, "X"),
+        (0x11B00, "V"),
+        (0x11B0A, "X"),
+        (0x11BC0, "V"),
+        (0x11BE2, "X"),
+        (0x11BF0, "V"),
+        (0x11BFA, "X"),
+        (0x11C00, "V"),
+        (0x11C09, "X"),
+        (0x11C0A, "V"),
+        (0x11C37, "X"),
+        (0x11C38, "V"),
+        (0x11C46, "X"),
+        (0x11C50, "V"),
+        (0x11C6D, "X"),
+        (0x11C70, "V"),
+        (0x11C90, "X"),
+        (0x11C92, "V"),
+        (0x11CA8, "X"),
+        (0x11CA9, "V"),
+        (0x11CB7, "X"),
+        (0x11D00, "V"),
+        (0x11D07, "X"),
+        (0x11D08, "V"),
+        (0x11D0A, "X"),
+        (0x11D0B, "V"),
+        (0x11D37, "X"),
+        (0x11D3A, "V"),
+        (0x11D3B, "X"),
+        (0x11D3C, "V"),
+        (0x11D3E, "X"),
+        (0x11D3F, "V"),
+        (0x11D48, "X"),
+        (0x11D50, "V"),
+        (0x11D5A, "X"),
+        (0x11D60, "V"),
+        (0x11D66, "X"),
+        (0x11D67, "V"),
+        (0x11D69, "X"),
+        (0x11D6A, "V"),
+        (0x11D8F, "X"),
+        (0x11D90, "V"),
+        (0x11D92, "X"),
+        (0x11D93, "V"),
+        (0x11D99, "X"),
+        (0x11DA0, "V"),
+        (0x11DAA, "X"),
+        (0x11EE0, "V"),
+        (0x11EF9, "X"),
+        (0x11F00, "V"),
+        (0x11F11, "X"),
+        (0x11F12, "V"),
+        (0x11F3B, "X"),
+        (0x11F3E, "V"),
+        (0x11F5B, "X"),
+    ]
+
+
+def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x11FB0, "V"),
+        (0x11FB1, "X"),
+        (0x11FC0, "V"),
+        (0x11FF2, "X"),
+        (0x11FFF, "V"),
+        (0x1239A, "X"),
+        (0x12400, "V"),
+        (0x1246F, "X"),
+        (0x12470, "V"),
+        (0x12475, "X"),
+        (0x12480, "V"),
+        (0x12544, "X"),
+        (0x12F90, "V"),
+        (0x12FF3, "X"),
+        (0x13000, "V"),
+        (0x13430, "X"),
+        (0x13440, "V"),
+        (0x13456, "X"),
+        (0x13460, "V"),
+        (0x143FB, "X"),
+        (0x14400, "V"),
+        (0x14647, "X"),
+        (0x16100, "V"),
+        (0x1613A, "X"),
+        (0x16800, "V"),
+        (0x16A39, "X"),
+        (0x16A40, "V"),
+        (0x16A5F, "X"),
+        (0x16A60, "V"),
+        (0x16A6A, "X"),
+        (0x16A6E, "V"),
+        (0x16ABF, "X"),
+        (0x16AC0, "V"),
+        (0x16ACA, "X"),
+        (0x16AD0, "V"),
+        (0x16AEE, "X"),
+        (0x16AF0, "V"),
+        (0x16AF6, "X"),
+        (0x16B00, "V"),
+        (0x16B46, "X"),
+        (0x16B50, "V"),
+        (0x16B5A, "X"),
+        (0x16B5B, "V"),
+        (0x16B62, "X"),
+        (0x16B63, "V"),
+        (0x16B78, "X"),
+        (0x16B7D, "V"),
+        (0x16B90, "X"),
+        (0x16D40, "V"),
+        (0x16D7A, "X"),
+        (0x16E40, "M", "𖹠"),
+        (0x16E41, "M", "𖹡"),
+        (0x16E42, "M", "𖹢"),
+        (0x16E43, "M", "𖹣"),
+        (0x16E44, "M", "𖹤"),
+        (0x16E45, "M", "𖹥"),
+        (0x16E46, "M", "𖹦"),
+        (0x16E47, "M", "𖹧"),
+        (0x16E48, "M", "𖹨"),
+        (0x16E49, "M", "𖹩"),
+        (0x16E4A, "M", "𖹪"),
+        (0x16E4B, "M", "𖹫"),
+        (0x16E4C, "M", "𖹬"),
+        (0x16E4D, "M", "𖹭"),
+        (0x16E4E, "M", "𖹮"),
+        (0x16E4F, "M", "𖹯"),
+        (0x16E50, "M", "𖹰"),
+        (0x16E51, "M", "𖹱"),
+        (0x16E52, "M", "𖹲"),
+        (0x16E53, "M", "𖹳"),
+        (0x16E54, "M", "𖹴"),
+        (0x16E55, "M", "𖹵"),
+        (0x16E56, "M", "𖹶"),
+        (0x16E57, "M", "𖹷"),
+        (0x16E58, "M", "𖹸"),
+        (0x16E59, "M", "𖹹"),
+        (0x16E5A, "M", "𖹺"),
+        (0x16E5B, "M", "𖹻"),
+        (0x16E5C, "M", "𖹼"),
+        (0x16E5D, "M", "𖹽"),
+        (0x16E5E, "M", "𖹾"),
+        (0x16E5F, "M", "𖹿"),
+        (0x16E60, "V"),
+        (0x16E9B, "X"),
+        (0x16F00, "V"),
+        (0x16F4B, "X"),
+        (0x16F4F, "V"),
+        (0x16F88, "X"),
+        (0x16F8F, "V"),
+        (0x16FA0, "X"),
+        (0x16FE0, "V"),
+        (0x16FE5, "X"),
+        (0x16FF0, "V"),
+        (0x16FF2, "X"),
+        (0x17000, "V"),
+        (0x187F8, "X"),
+        (0x18800, "V"),
+        (0x18CD6, "X"),
+        (0x18CFF, "V"),
+        (0x18D09, "X"),
+    ]
+
+
+def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1AFF0, "V"),
+        (0x1AFF4, "X"),
+        (0x1AFF5, "V"),
+        (0x1AFFC, "X"),
+        (0x1AFFD, "V"),
+        (0x1AFFF, "X"),
+        (0x1B000, "V"),
+        (0x1B123, "X"),
+        (0x1B132, "V"),
+        (0x1B133, "X"),
+        (0x1B150, "V"),
+        (0x1B153, "X"),
+        (0x1B155, "V"),
+        (0x1B156, "X"),
+        (0x1B164, "V"),
+        (0x1B168, "X"),
+        (0x1B170, "V"),
+        (0x1B2FC, "X"),
+        (0x1BC00, "V"),
+        (0x1BC6B, "X"),
+        (0x1BC70, "V"),
+        (0x1BC7D, "X"),
+        (0x1BC80, "V"),
+        (0x1BC89, "X"),
+        (0x1BC90, "V"),
+        (0x1BC9A, "X"),
+        (0x1BC9C, "V"),
+        (0x1BCA0, "I"),
+        (0x1BCA4, "X"),
+        (0x1CC00, "V"),
+        (0x1CCD6, "M", "a"),
+        (0x1CCD7, "M", "b"),
+        (0x1CCD8, "M", "c"),
+        (0x1CCD9, "M", "d"),
+        (0x1CCDA, "M", "e"),
+        (0x1CCDB, "M", "f"),
+        (0x1CCDC, "M", "g"),
+        (0x1CCDD, "M", "h"),
+        (0x1CCDE, "M", "i"),
+        (0x1CCDF, "M", "j"),
+        (0x1CCE0, "M", "k"),
+        (0x1CCE1, "M", "l"),
+        (0x1CCE2, "M", "m"),
+        (0x1CCE3, "M", "n"),
+        (0x1CCE4, "M", "o"),
+        (0x1CCE5, "M", "p"),
+        (0x1CCE6, "M", "q"),
+        (0x1CCE7, "M", "r"),
+        (0x1CCE8, "M", "s"),
+        (0x1CCE9, "M", "t"),
+        (0x1CCEA, "M", "u"),
+        (0x1CCEB, "M", "v"),
+        (0x1CCEC, "M", "w"),
+        (0x1CCED, "M", "x"),
+        (0x1CCEE, "M", "y"),
+        (0x1CCEF, "M", "z"),
+        (0x1CCF0, "M", "0"),
+        (0x1CCF1, "M", "1"),
+        (0x1CCF2, "M", "2"),
+        (0x1CCF3, "M", "3"),
+        (0x1CCF4, "M", "4"),
+        (0x1CCF5, "M", "5"),
+        (0x1CCF6, "M", "6"),
+        (0x1CCF7, "M", "7"),
+        (0x1CCF8, "M", "8"),
+        (0x1CCF9, "M", "9"),
+        (0x1CCFA, "X"),
+        (0x1CD00, "V"),
+        (0x1CEB4, "X"),
+        (0x1CF00, "V"),
+        (0x1CF2E, "X"),
+        (0x1CF30, "V"),
+        (0x1CF47, "X"),
+        (0x1CF50, "V"),
+        (0x1CFC4, "X"),
+        (0x1D000, "V"),
+        (0x1D0F6, "X"),
+        (0x1D100, "V"),
+        (0x1D127, "X"),
+        (0x1D129, "V"),
+        (0x1D15E, "M", "𝅗𝅥"),
+        (0x1D15F, "M", "𝅘𝅥"),
+        (0x1D160, "M", "𝅘𝅥𝅮"),
+        (0x1D161, "M", "𝅘𝅥𝅯"),
+        (0x1D162, "M", "𝅘𝅥𝅰"),
+        (0x1D163, "M", "𝅘𝅥𝅱"),
+        (0x1D164, "M", "𝅘𝅥𝅲"),
+        (0x1D165, "V"),
+        (0x1D173, "I"),
+        (0x1D17B, "V"),
+        (0x1D1BB, "M", "𝆹𝅥"),
+        (0x1D1BC, "M", "𝆺𝅥"),
+        (0x1D1BD, "M", "𝆹𝅥𝅮"),
+        (0x1D1BE, "M", "𝆺𝅥𝅮"),
+        (0x1D1BF, "M", "𝆹𝅥𝅯"),
+        (0x1D1C0, "M", "𝆺𝅥𝅯"),
+        (0x1D1C1, "V"),
+        (0x1D1EB, "X"),
+        (0x1D200, "V"),
+        (0x1D246, "X"),
+    ]
+
+
+def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D2C0, "V"),
+        (0x1D2D4, "X"),
+        (0x1D2E0, "V"),
+        (0x1D2F4, "X"),
+        (0x1D300, "V"),
+        (0x1D357, "X"),
+        (0x1D360, "V"),
+        (0x1D379, "X"),
+        (0x1D400, "M", "a"),
+        (0x1D401, "M", "b"),
+        (0x1D402, "M", "c"),
+        (0x1D403, "M", "d"),
+        (0x1D404, "M", "e"),
+        (0x1D405, "M", "f"),
+        (0x1D406, "M", "g"),
+        (0x1D407, "M", "h"),
+        (0x1D408, "M", "i"),
+        (0x1D409, "M", "j"),
+        (0x1D40A, "M", "k"),
+        (0x1D40B, "M", "l"),
+        (0x1D40C, "M", "m"),
+        (0x1D40D, "M", "n"),
+        (0x1D40E, "M", "o"),
+        (0x1D40F, "M", "p"),
+        (0x1D410, "M", "q"),
+        (0x1D411, "M", "r"),
+        (0x1D412, "M", "s"),
+        (0x1D413, "M", "t"),
+        (0x1D414, "M", "u"),
+        (0x1D415, "M", "v"),
+        (0x1D416, "M", "w"),
+        (0x1D417, "M", "x"),
+        (0x1D418, "M", "y"),
+        (0x1D419, "M", "z"),
+        (0x1D41A, "M", "a"),
+        (0x1D41B, "M", "b"),
+        (0x1D41C, "M", "c"),
+        (0x1D41D, "M", "d"),
+        (0x1D41E, "M", "e"),
+        (0x1D41F, "M", "f"),
+        (0x1D420, "M", "g"),
+        (0x1D421, "M", "h"),
+        (0x1D422, "M", "i"),
+        (0x1D423, "M", "j"),
+        (0x1D424, "M", "k"),
+        (0x1D425, "M", "l"),
+        (0x1D426, "M", "m"),
+        (0x1D427, "M", "n"),
+        (0x1D428, "M", "o"),
+        (0x1D429, "M", "p"),
+        (0x1D42A, "M", "q"),
+        (0x1D42B, "M", "r"),
+        (0x1D42C, "M", "s"),
+        (0x1D42D, "M", "t"),
+        (0x1D42E, "M", "u"),
+        (0x1D42F, "M", "v"),
+        (0x1D430, "M", "w"),
+        (0x1D431, "M", "x"),
+        (0x1D432, "M", "y"),
+        (0x1D433, "M", "z"),
+        (0x1D434, "M", "a"),
+        (0x1D435, "M", "b"),
+        (0x1D436, "M", "c"),
+        (0x1D437, "M", "d"),
+        (0x1D438, "M", "e"),
+        (0x1D439, "M", "f"),
+        (0x1D43A, "M", "g"),
+        (0x1D43B, "M", "h"),
+        (0x1D43C, "M", "i"),
+        (0x1D43D, "M", "j"),
+        (0x1D43E, "M", "k"),
+        (0x1D43F, "M", "l"),
+        (0x1D440, "M", "m"),
+        (0x1D441, "M", "n"),
+        (0x1D442, "M", "o"),
+        (0x1D443, "M", "p"),
+        (0x1D444, "M", "q"),
+        (0x1D445, "M", "r"),
+        (0x1D446, "M", "s"),
+        (0x1D447, "M", "t"),
+        (0x1D448, "M", "u"),
+        (0x1D449, "M", "v"),
+        (0x1D44A, "M", "w"),
+        (0x1D44B, "M", "x"),
+        (0x1D44C, "M", "y"),
+        (0x1D44D, "M", "z"),
+        (0x1D44E, "M", "a"),
+        (0x1D44F, "M", "b"),
+        (0x1D450, "M", "c"),
+        (0x1D451, "M", "d"),
+        (0x1D452, "M", "e"),
+        (0x1D453, "M", "f"),
+        (0x1D454, "M", "g"),
+        (0x1D455, "X"),
+        (0x1D456, "M", "i"),
+        (0x1D457, "M", "j"),
+        (0x1D458, "M", "k"),
+        (0x1D459, "M", "l"),
+        (0x1D45A, "M", "m"),
+        (0x1D45B, "M", "n"),
+    ]
+
+
+def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D45C, "M", "o"),
+        (0x1D45D, "M", "p"),
+        (0x1D45E, "M", "q"),
+        (0x1D45F, "M", "r"),
+        (0x1D460, "M", "s"),
+        (0x1D461, "M", "t"),
+        (0x1D462, "M", "u"),
+        (0x1D463, "M", "v"),
+        (0x1D464, "M", "w"),
+        (0x1D465, "M", "x"),
+        (0x1D466, "M", "y"),
+        (0x1D467, "M", "z"),
+        (0x1D468, "M", "a"),
+        (0x1D469, "M", "b"),
+        (0x1D46A, "M", "c"),
+        (0x1D46B, "M", "d"),
+        (0x1D46C, "M", "e"),
+        (0x1D46D, "M", "f"),
+        (0x1D46E, "M", "g"),
+        (0x1D46F, "M", "h"),
+        (0x1D470, "M", "i"),
+        (0x1D471, "M", "j"),
+        (0x1D472, "M", "k"),
+        (0x1D473, "M", "l"),
+        (0x1D474, "M", "m"),
+        (0x1D475, "M", "n"),
+        (0x1D476, "M", "o"),
+        (0x1D477, "M", "p"),
+        (0x1D478, "M", "q"),
+        (0x1D479, "M", "r"),
+        (0x1D47A, "M", "s"),
+        (0x1D47B, "M", "t"),
+        (0x1D47C, "M", "u"),
+        (0x1D47D, "M", "v"),
+        (0x1D47E, "M", "w"),
+        (0x1D47F, "M", "x"),
+        (0x1D480, "M", "y"),
+        (0x1D481, "M", "z"),
+        (0x1D482, "M", "a"),
+        (0x1D483, "M", "b"),
+        (0x1D484, "M", "c"),
+        (0x1D485, "M", "d"),
+        (0x1D486, "M", "e"),
+        (0x1D487, "M", "f"),
+        (0x1D488, "M", "g"),
+        (0x1D489, "M", "h"),
+        (0x1D48A, "M", "i"),
+        (0x1D48B, "M", "j"),
+        (0x1D48C, "M", "k"),
+        (0x1D48D, "M", "l"),
+        (0x1D48E, "M", "m"),
+        (0x1D48F, "M", "n"),
+        (0x1D490, "M", "o"),
+        (0x1D491, "M", "p"),
+        (0x1D492, "M", "q"),
+        (0x1D493, "M", "r"),
+        (0x1D494, "M", "s"),
+        (0x1D495, "M", "t"),
+        (0x1D496, "M", "u"),
+        (0x1D497, "M", "v"),
+        (0x1D498, "M", "w"),
+        (0x1D499, "M", "x"),
+        (0x1D49A, "M", "y"),
+        (0x1D49B, "M", "z"),
+        (0x1D49C, "M", "a"),
+        (0x1D49D, "X"),
+        (0x1D49E, "M", "c"),
+        (0x1D49F, "M", "d"),
+        (0x1D4A0, "X"),
+        (0x1D4A2, "M", "g"),
+        (0x1D4A3, "X"),
+        (0x1D4A5, "M", "j"),
+        (0x1D4A6, "M", "k"),
+        (0x1D4A7, "X"),
+        (0x1D4A9, "M", "n"),
+        (0x1D4AA, "M", "o"),
+        (0x1D4AB, "M", "p"),
+        (0x1D4AC, "M", "q"),
+        (0x1D4AD, "X"),
+        (0x1D4AE, "M", "s"),
+        (0x1D4AF, "M", "t"),
+        (0x1D4B0, "M", "u"),
+        (0x1D4B1, "M", "v"),
+        (0x1D4B2, "M", "w"),
+        (0x1D4B3, "M", "x"),
+        (0x1D4B4, "M", "y"),
+        (0x1D4B5, "M", "z"),
+        (0x1D4B6, "M", "a"),
+        (0x1D4B7, "M", "b"),
+        (0x1D4B8, "M", "c"),
+        (0x1D4B9, "M", "d"),
+        (0x1D4BA, "X"),
+        (0x1D4BB, "M", "f"),
+        (0x1D4BC, "X"),
+        (0x1D4BD, "M", "h"),
+        (0x1D4BE, "M", "i"),
+        (0x1D4BF, "M", "j"),
+        (0x1D4C0, "M", "k"),
+        (0x1D4C1, "M", "l"),
+        (0x1D4C2, "M", "m"),
+    ]
+
+
+def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D4C3, "M", "n"),
+        (0x1D4C4, "X"),
+        (0x1D4C5, "M", "p"),
+        (0x1D4C6, "M", "q"),
+        (0x1D4C7, "M", "r"),
+        (0x1D4C8, "M", "s"),
+        (0x1D4C9, "M", "t"),
+        (0x1D4CA, "M", "u"),
+        (0x1D4CB, "M", "v"),
+        (0x1D4CC, "M", "w"),
+        (0x1D4CD, "M", "x"),
+        (0x1D4CE, "M", "y"),
+        (0x1D4CF, "M", "z"),
+        (0x1D4D0, "M", "a"),
+        (0x1D4D1, "M", "b"),
+        (0x1D4D2, "M", "c"),
+        (0x1D4D3, "M", "d"),
+        (0x1D4D4, "M", "e"),
+        (0x1D4D5, "M", "f"),
+        (0x1D4D6, "M", "g"),
+        (0x1D4D7, "M", "h"),
+        (0x1D4D8, "M", "i"),
+        (0x1D4D9, "M", "j"),
+        (0x1D4DA, "M", "k"),
+        (0x1D4DB, "M", "l"),
+        (0x1D4DC, "M", "m"),
+        (0x1D4DD, "M", "n"),
+        (0x1D4DE, "M", "o"),
+        (0x1D4DF, "M", "p"),
+        (0x1D4E0, "M", "q"),
+        (0x1D4E1, "M", "r"),
+        (0x1D4E2, "M", "s"),
+        (0x1D4E3, "M", "t"),
+        (0x1D4E4, "M", "u"),
+        (0x1D4E5, "M", "v"),
+        (0x1D4E6, "M", "w"),
+        (0x1D4E7, "M", "x"),
+        (0x1D4E8, "M", "y"),
+        (0x1D4E9, "M", "z"),
+        (0x1D4EA, "M", "a"),
+        (0x1D4EB, "M", "b"),
+        (0x1D4EC, "M", "c"),
+        (0x1D4ED, "M", "d"),
+        (0x1D4EE, "M", "e"),
+        (0x1D4EF, "M", "f"),
+        (0x1D4F0, "M", "g"),
+        (0x1D4F1, "M", "h"),
+        (0x1D4F2, "M", "i"),
+        (0x1D4F3, "M", "j"),
+        (0x1D4F4, "M", "k"),
+        (0x1D4F5, "M", "l"),
+        (0x1D4F6, "M", "m"),
+        (0x1D4F7, "M", "n"),
+        (0x1D4F8, "M", "o"),
+        (0x1D4F9, "M", "p"),
+        (0x1D4FA, "M", "q"),
+        (0x1D4FB, "M", "r"),
+        (0x1D4FC, "M", "s"),
+        (0x1D4FD, "M", "t"),
+        (0x1D4FE, "M", "u"),
+        (0x1D4FF, "M", "v"),
+        (0x1D500, "M", "w"),
+        (0x1D501, "M", "x"),
+        (0x1D502, "M", "y"),
+        (0x1D503, "M", "z"),
+        (0x1D504, "M", "a"),
+        (0x1D505, "M", "b"),
+        (0x1D506, "X"),
+        (0x1D507, "M", "d"),
+        (0x1D508, "M", "e"),
+        (0x1D509, "M", "f"),
+        (0x1D50A, "M", "g"),
+        (0x1D50B, "X"),
+        (0x1D50D, "M", "j"),
+        (0x1D50E, "M", "k"),
+        (0x1D50F, "M", "l"),
+        (0x1D510, "M", "m"),
+        (0x1D511, "M", "n"),
+        (0x1D512, "M", "o"),
+        (0x1D513, "M", "p"),
+        (0x1D514, "M", "q"),
+        (0x1D515, "X"),
+        (0x1D516, "M", "s"),
+        (0x1D517, "M", "t"),
+        (0x1D518, "M", "u"),
+        (0x1D519, "M", "v"),
+        (0x1D51A, "M", "w"),
+        (0x1D51B, "M", "x"),
+        (0x1D51C, "M", "y"),
+        (0x1D51D, "X"),
+        (0x1D51E, "M", "a"),
+        (0x1D51F, "M", "b"),
+        (0x1D520, "M", "c"),
+        (0x1D521, "M", "d"),
+        (0x1D522, "M", "e"),
+        (0x1D523, "M", "f"),
+        (0x1D524, "M", "g"),
+        (0x1D525, "M", "h"),
+        (0x1D526, "M", "i"),
+        (0x1D527, "M", "j"),
+    ]
+
+
+def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D528, "M", "k"),
+        (0x1D529, "M", "l"),
+        (0x1D52A, "M", "m"),
+        (0x1D52B, "M", "n"),
+        (0x1D52C, "M", "o"),
+        (0x1D52D, "M", "p"),
+        (0x1D52E, "M", "q"),
+        (0x1D52F, "M", "r"),
+        (0x1D530, "M", "s"),
+        (0x1D531, "M", "t"),
+        (0x1D532, "M", "u"),
+        (0x1D533, "M", "v"),
+        (0x1D534, "M", "w"),
+        (0x1D535, "M", "x"),
+        (0x1D536, "M", "y"),
+        (0x1D537, "M", "z"),
+        (0x1D538, "M", "a"),
+        (0x1D539, "M", "b"),
+        (0x1D53A, "X"),
+        (0x1D53B, "M", "d"),
+        (0x1D53C, "M", "e"),
+        (0x1D53D, "M", "f"),
+        (0x1D53E, "M", "g"),
+        (0x1D53F, "X"),
+        (0x1D540, "M", "i"),
+        (0x1D541, "M", "j"),
+        (0x1D542, "M", "k"),
+        (0x1D543, "M", "l"),
+        (0x1D544, "M", "m"),
+        (0x1D545, "X"),
+        (0x1D546, "M", "o"),
+        (0x1D547, "X"),
+        (0x1D54A, "M", "s"),
+        (0x1D54B, "M", "t"),
+        (0x1D54C, "M", "u"),
+        (0x1D54D, "M", "v"),
+        (0x1D54E, "M", "w"),
+        (0x1D54F, "M", "x"),
+        (0x1D550, "M", "y"),
+        (0x1D551, "X"),
+        (0x1D552, "M", "a"),
+        (0x1D553, "M", "b"),
+        (0x1D554, "M", "c"),
+        (0x1D555, "M", "d"),
+        (0x1D556, "M", "e"),
+        (0x1D557, "M", "f"),
+        (0x1D558, "M", "g"),
+        (0x1D559, "M", "h"),
+        (0x1D55A, "M", "i"),
+        (0x1D55B, "M", "j"),
+        (0x1D55C, "M", "k"),
+        (0x1D55D, "M", "l"),
+        (0x1D55E, "M", "m"),
+        (0x1D55F, "M", "n"),
+        (0x1D560, "M", "o"),
+        (0x1D561, "M", "p"),
+        (0x1D562, "M", "q"),
+        (0x1D563, "M", "r"),
+        (0x1D564, "M", "s"),
+        (0x1D565, "M", "t"),
+        (0x1D566, "M", "u"),
+        (0x1D567, "M", "v"),
+        (0x1D568, "M", "w"),
+        (0x1D569, "M", "x"),
+        (0x1D56A, "M", "y"),
+        (0x1D56B, "M", "z"),
+        (0x1D56C, "M", "a"),
+        (0x1D56D, "M", "b"),
+        (0x1D56E, "M", "c"),
+        (0x1D56F, "M", "d"),
+        (0x1D570, "M", "e"),
+        (0x1D571, "M", "f"),
+        (0x1D572, "M", "g"),
+        (0x1D573, "M", "h"),
+        (0x1D574, "M", "i"),
+        (0x1D575, "M", "j"),
+        (0x1D576, "M", "k"),
+        (0x1D577, "M", "l"),
+        (0x1D578, "M", "m"),
+        (0x1D579, "M", "n"),
+        (0x1D57A, "M", "o"),
+        (0x1D57B, "M", "p"),
+        (0x1D57C, "M", "q"),
+        (0x1D57D, "M", "r"),
+        (0x1D57E, "M", "s"),
+        (0x1D57F, "M", "t"),
+        (0x1D580, "M", "u"),
+        (0x1D581, "M", "v"),
+        (0x1D582, "M", "w"),
+        (0x1D583, "M", "x"),
+        (0x1D584, "M", "y"),
+        (0x1D585, "M", "z"),
+        (0x1D586, "M", "a"),
+        (0x1D587, "M", "b"),
+        (0x1D588, "M", "c"),
+        (0x1D589, "M", "d"),
+        (0x1D58A, "M", "e"),
+        (0x1D58B, "M", "f"),
+        (0x1D58C, "M", "g"),
+        (0x1D58D, "M", "h"),
+    ]
+
+
+def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D58E, "M", "i"),
+        (0x1D58F, "M", "j"),
+        (0x1D590, "M", "k"),
+        (0x1D591, "M", "l"),
+        (0x1D592, "M", "m"),
+        (0x1D593, "M", "n"),
+        (0x1D594, "M", "o"),
+        (0x1D595, "M", "p"),
+        (0x1D596, "M", "q"),
+        (0x1D597, "M", "r"),
+        (0x1D598, "M", "s"),
+        (0x1D599, "M", "t"),
+        (0x1D59A, "M", "u"),
+        (0x1D59B, "M", "v"),
+        (0x1D59C, "M", "w"),
+        (0x1D59D, "M", "x"),
+        (0x1D59E, "M", "y"),
+        (0x1D59F, "M", "z"),
+        (0x1D5A0, "M", "a"),
+        (0x1D5A1, "M", "b"),
+        (0x1D5A2, "M", "c"),
+        (0x1D5A3, "M", "d"),
+        (0x1D5A4, "M", "e"),
+        (0x1D5A5, "M", "f"),
+        (0x1D5A6, "M", "g"),
+        (0x1D5A7, "M", "h"),
+        (0x1D5A8, "M", "i"),
+        (0x1D5A9, "M", "j"),
+        (0x1D5AA, "M", "k"),
+        (0x1D5AB, "M", "l"),
+        (0x1D5AC, "M", "m"),
+        (0x1D5AD, "M", "n"),
+        (0x1D5AE, "M", "o"),
+        (0x1D5AF, "M", "p"),
+        (0x1D5B0, "M", "q"),
+        (0x1D5B1, "M", "r"),
+        (0x1D5B2, "M", "s"),
+        (0x1D5B3, "M", "t"),
+        (0x1D5B4, "M", "u"),
+        (0x1D5B5, "M", "v"),
+        (0x1D5B6, "M", "w"),
+        (0x1D5B7, "M", "x"),
+        (0x1D5B8, "M", "y"),
+        (0x1D5B9, "M", "z"),
+        (0x1D5BA, "M", "a"),
+        (0x1D5BB, "M", "b"),
+        (0x1D5BC, "M", "c"),
+        (0x1D5BD, "M", "d"),
+        (0x1D5BE, "M", "e"),
+        (0x1D5BF, "M", "f"),
+        (0x1D5C0, "M", "g"),
+        (0x1D5C1, "M", "h"),
+        (0x1D5C2, "M", "i"),
+        (0x1D5C3, "M", "j"),
+        (0x1D5C4, "M", "k"),
+        (0x1D5C5, "M", "l"),
+        (0x1D5C6, "M", "m"),
+        (0x1D5C7, "M", "n"),
+        (0x1D5C8, "M", "o"),
+        (0x1D5C9, "M", "p"),
+        (0x1D5CA, "M", "q"),
+        (0x1D5CB, "M", "r"),
+        (0x1D5CC, "M", "s"),
+        (0x1D5CD, "M", "t"),
+        (0x1D5CE, "M", "u"),
+        (0x1D5CF, "M", "v"),
+        (0x1D5D0, "M", "w"),
+        (0x1D5D1, "M", "x"),
+        (0x1D5D2, "M", "y"),
+        (0x1D5D3, "M", "z"),
+        (0x1D5D4, "M", "a"),
+        (0x1D5D5, "M", "b"),
+        (0x1D5D6, "M", "c"),
+        (0x1D5D7, "M", "d"),
+        (0x1D5D8, "M", "e"),
+        (0x1D5D9, "M", "f"),
+        (0x1D5DA, "M", "g"),
+        (0x1D5DB, "M", "h"),
+        (0x1D5DC, "M", "i"),
+        (0x1D5DD, "M", "j"),
+        (0x1D5DE, "M", "k"),
+        (0x1D5DF, "M", "l"),
+        (0x1D5E0, "M", "m"),
+        (0x1D5E1, "M", "n"),
+        (0x1D5E2, "M", "o"),
+        (0x1D5E3, "M", "p"),
+        (0x1D5E4, "M", "q"),
+        (0x1D5E5, "M", "r"),
+        (0x1D5E6, "M", "s"),
+        (0x1D5E7, "M", "t"),
+        (0x1D5E8, "M", "u"),
+        (0x1D5E9, "M", "v"),
+        (0x1D5EA, "M", "w"),
+        (0x1D5EB, "M", "x"),
+        (0x1D5EC, "M", "y"),
+        (0x1D5ED, "M", "z"),
+        (0x1D5EE, "M", "a"),
+        (0x1D5EF, "M", "b"),
+        (0x1D5F0, "M", "c"),
+        (0x1D5F1, "M", "d"),
+    ]
+
+
+def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D5F2, "M", "e"),
+        (0x1D5F3, "M", "f"),
+        (0x1D5F4, "M", "g"),
+        (0x1D5F5, "M", "h"),
+        (0x1D5F6, "M", "i"),
+        (0x1D5F7, "M", "j"),
+        (0x1D5F8, "M", "k"),
+        (0x1D5F9, "M", "l"),
+        (0x1D5FA, "M", "m"),
+        (0x1D5FB, "M", "n"),
+        (0x1D5FC, "M", "o"),
+        (0x1D5FD, "M", "p"),
+        (0x1D5FE, "M", "q"),
+        (0x1D5FF, "M", "r"),
+        (0x1D600, "M", "s"),
+        (0x1D601, "M", "t"),
+        (0x1D602, "M", "u"),
+        (0x1D603, "M", "v"),
+        (0x1D604, "M", "w"),
+        (0x1D605, "M", "x"),
+        (0x1D606, "M", "y"),
+        (0x1D607, "M", "z"),
+        (0x1D608, "M", "a"),
+        (0x1D609, "M", "b"),
+        (0x1D60A, "M", "c"),
+        (0x1D60B, "M", "d"),
+        (0x1D60C, "M", "e"),
+        (0x1D60D, "M", "f"),
+        (0x1D60E, "M", "g"),
+        (0x1D60F, "M", "h"),
+        (0x1D610, "M", "i"),
+        (0x1D611, "M", "j"),
+        (0x1D612, "M", "k"),
+        (0x1D613, "M", "l"),
+        (0x1D614, "M", "m"),
+        (0x1D615, "M", "n"),
+        (0x1D616, "M", "o"),
+        (0x1D617, "M", "p"),
+        (0x1D618, "M", "q"),
+        (0x1D619, "M", "r"),
+        (0x1D61A, "M", "s"),
+        (0x1D61B, "M", "t"),
+        (0x1D61C, "M", "u"),
+        (0x1D61D, "M", "v"),
+        (0x1D61E, "M", "w"),
+        (0x1D61F, "M", "x"),
+        (0x1D620, "M", "y"),
+        (0x1D621, "M", "z"),
+        (0x1D622, "M", "a"),
+        (0x1D623, "M", "b"),
+        (0x1D624, "M", "c"),
+        (0x1D625, "M", "d"),
+        (0x1D626, "M", "e"),
+        (0x1D627, "M", "f"),
+        (0x1D628, "M", "g"),
+        (0x1D629, "M", "h"),
+        (0x1D62A, "M", "i"),
+        (0x1D62B, "M", "j"),
+        (0x1D62C, "M", "k"),
+        (0x1D62D, "M", "l"),
+        (0x1D62E, "M", "m"),
+        (0x1D62F, "M", "n"),
+        (0x1D630, "M", "o"),
+        (0x1D631, "M", "p"),
+        (0x1D632, "M", "q"),
+        (0x1D633, "M", "r"),
+        (0x1D634, "M", "s"),
+        (0x1D635, "M", "t"),
+        (0x1D636, "M", "u"),
+        (0x1D637, "M", "v"),
+        (0x1D638, "M", "w"),
+        (0x1D639, "M", "x"),
+        (0x1D63A, "M", "y"),
+        (0x1D63B, "M", "z"),
+        (0x1D63C, "M", "a"),
+        (0x1D63D, "M", "b"),
+        (0x1D63E, "M", "c"),
+        (0x1D63F, "M", "d"),
+        (0x1D640, "M", "e"),
+        (0x1D641, "M", "f"),
+        (0x1D642, "M", "g"),
+        (0x1D643, "M", "h"),
+        (0x1D644, "M", "i"),
+        (0x1D645, "M", "j"),
+        (0x1D646, "M", "k"),
+        (0x1D647, "M", "l"),
+        (0x1D648, "M", "m"),
+        (0x1D649, "M", "n"),
+        (0x1D64A, "M", "o"),
+        (0x1D64B, "M", "p"),
+        (0x1D64C, "M", "q"),
+        (0x1D64D, "M", "r"),
+        (0x1D64E, "M", "s"),
+        (0x1D64F, "M", "t"),
+        (0x1D650, "M", "u"),
+        (0x1D651, "M", "v"),
+        (0x1D652, "M", "w"),
+        (0x1D653, "M", "x"),
+        (0x1D654, "M", "y"),
+        (0x1D655, "M", "z"),
+    ]
+
+
+def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D656, "M", "a"),
+        (0x1D657, "M", "b"),
+        (0x1D658, "M", "c"),
+        (0x1D659, "M", "d"),
+        (0x1D65A, "M", "e"),
+        (0x1D65B, "M", "f"),
+        (0x1D65C, "M", "g"),
+        (0x1D65D, "M", "h"),
+        (0x1D65E, "M", "i"),
+        (0x1D65F, "M", "j"),
+        (0x1D660, "M", "k"),
+        (0x1D661, "M", "l"),
+        (0x1D662, "M", "m"),
+        (0x1D663, "M", "n"),
+        (0x1D664, "M", "o"),
+        (0x1D665, "M", "p"),
+        (0x1D666, "M", "q"),
+        (0x1D667, "M", "r"),
+        (0x1D668, "M", "s"),
+        (0x1D669, "M", "t"),
+        (0x1D66A, "M", "u"),
+        (0x1D66B, "M", "v"),
+        (0x1D66C, "M", "w"),
+        (0x1D66D, "M", "x"),
+        (0x1D66E, "M", "y"),
+        (0x1D66F, "M", "z"),
+        (0x1D670, "M", "a"),
+        (0x1D671, "M", "b"),
+        (0x1D672, "M", "c"),
+        (0x1D673, "M", "d"),
+        (0x1D674, "M", "e"),
+        (0x1D675, "M", "f"),
+        (0x1D676, "M", "g"),
+        (0x1D677, "M", "h"),
+        (0x1D678, "M", "i"),
+        (0x1D679, "M", "j"),
+        (0x1D67A, "M", "k"),
+        (0x1D67B, "M", "l"),
+        (0x1D67C, "M", "m"),
+        (0x1D67D, "M", "n"),
+        (0x1D67E, "M", "o"),
+        (0x1D67F, "M", "p"),
+        (0x1D680, "M", "q"),
+        (0x1D681, "M", "r"),
+        (0x1D682, "M", "s"),
+        (0x1D683, "M", "t"),
+        (0x1D684, "M", "u"),
+        (0x1D685, "M", "v"),
+        (0x1D686, "M", "w"),
+        (0x1D687, "M", "x"),
+        (0x1D688, "M", "y"),
+        (0x1D689, "M", "z"),
+        (0x1D68A, "M", "a"),
+        (0x1D68B, "M", "b"),
+        (0x1D68C, "M", "c"),
+        (0x1D68D, "M", "d"),
+        (0x1D68E, "M", "e"),
+        (0x1D68F, "M", "f"),
+        (0x1D690, "M", "g"),
+        (0x1D691, "M", "h"),
+        (0x1D692, "M", "i"),
+        (0x1D693, "M", "j"),
+        (0x1D694, "M", "k"),
+        (0x1D695, "M", "l"),
+        (0x1D696, "M", "m"),
+        (0x1D697, "M", "n"),
+        (0x1D698, "M", "o"),
+        (0x1D699, "M", "p"),
+        (0x1D69A, "M", "q"),
+        (0x1D69B, "M", "r"),
+        (0x1D69C, "M", "s"),
+        (0x1D69D, "M", "t"),
+        (0x1D69E, "M", "u"),
+        (0x1D69F, "M", "v"),
+        (0x1D6A0, "M", "w"),
+        (0x1D6A1, "M", "x"),
+        (0x1D6A2, "M", "y"),
+        (0x1D6A3, "M", "z"),
+        (0x1D6A4, "M", "ı"),
+        (0x1D6A5, "M", "ȷ"),
+        (0x1D6A6, "X"),
+        (0x1D6A8, "M", "α"),
+        (0x1D6A9, "M", "β"),
+        (0x1D6AA, "M", "γ"),
+        (0x1D6AB, "M", "δ"),
+        (0x1D6AC, "M", "ε"),
+        (0x1D6AD, "M", "ζ"),
+        (0x1D6AE, "M", "η"),
+        (0x1D6AF, "M", "θ"),
+        (0x1D6B0, "M", "ι"),
+        (0x1D6B1, "M", "κ"),
+        (0x1D6B2, "M", "λ"),
+        (0x1D6B3, "M", "μ"),
+        (0x1D6B4, "M", "ν"),
+        (0x1D6B5, "M", "ξ"),
+        (0x1D6B6, "M", "ο"),
+        (0x1D6B7, "M", "π"),
+        (0x1D6B8, "M", "ρ"),
+        (0x1D6B9, "M", "θ"),
+        (0x1D6BA, "M", "σ"),
+    ]
+
+
+def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D6BB, "M", "τ"),
+        (0x1D6BC, "M", "υ"),
+        (0x1D6BD, "M", "φ"),
+        (0x1D6BE, "M", "χ"),
+        (0x1D6BF, "M", "ψ"),
+        (0x1D6C0, "M", "ω"),
+        (0x1D6C1, "M", "∇"),
+        (0x1D6C2, "M", "α"),
+        (0x1D6C3, "M", "β"),
+        (0x1D6C4, "M", "γ"),
+        (0x1D6C5, "M", "δ"),
+        (0x1D6C6, "M", "ε"),
+        (0x1D6C7, "M", "ζ"),
+        (0x1D6C8, "M", "η"),
+        (0x1D6C9, "M", "θ"),
+        (0x1D6CA, "M", "ι"),
+        (0x1D6CB, "M", "κ"),
+        (0x1D6CC, "M", "λ"),
+        (0x1D6CD, "M", "μ"),
+        (0x1D6CE, "M", "ν"),
+        (0x1D6CF, "M", "ξ"),
+        (0x1D6D0, "M", "ο"),
+        (0x1D6D1, "M", "π"),
+        (0x1D6D2, "M", "ρ"),
+        (0x1D6D3, "M", "σ"),
+        (0x1D6D5, "M", "τ"),
+        (0x1D6D6, "M", "υ"),
+        (0x1D6D7, "M", "φ"),
+        (0x1D6D8, "M", "χ"),
+        (0x1D6D9, "M", "ψ"),
+        (0x1D6DA, "M", "ω"),
+        (0x1D6DB, "M", "∂"),
+        (0x1D6DC, "M", "ε"),
+        (0x1D6DD, "M", "θ"),
+        (0x1D6DE, "M", "κ"),
+        (0x1D6DF, "M", "φ"),
+        (0x1D6E0, "M", "ρ"),
+        (0x1D6E1, "M", "π"),
+        (0x1D6E2, "M", "α"),
+        (0x1D6E3, "M", "β"),
+        (0x1D6E4, "M", "γ"),
+        (0x1D6E5, "M", "δ"),
+        (0x1D6E6, "M", "ε"),
+        (0x1D6E7, "M", "ζ"),
+        (0x1D6E8, "M", "η"),
+        (0x1D6E9, "M", "θ"),
+        (0x1D6EA, "M", "ι"),
+        (0x1D6EB, "M", "κ"),
+        (0x1D6EC, "M", "λ"),
+        (0x1D6ED, "M", "μ"),
+        (0x1D6EE, "M", "ν"),
+        (0x1D6EF, "M", "ξ"),
+        (0x1D6F0, "M", "ο"),
+        (0x1D6F1, "M", "π"),
+        (0x1D6F2, "M", "ρ"),
+        (0x1D6F3, "M", "θ"),
+        (0x1D6F4, "M", "σ"),
+        (0x1D6F5, "M", "τ"),
+        (0x1D6F6, "M", "υ"),
+        (0x1D6F7, "M", "φ"),
+        (0x1D6F8, "M", "χ"),
+        (0x1D6F9, "M", "ψ"),
+        (0x1D6FA, "M", "ω"),
+        (0x1D6FB, "M", "∇"),
+        (0x1D6FC, "M", "α"),
+        (0x1D6FD, "M", "β"),
+        (0x1D6FE, "M", "γ"),
+        (0x1D6FF, "M", "δ"),
+        (0x1D700, "M", "ε"),
+        (0x1D701, "M", "ζ"),
+        (0x1D702, "M", "η"),
+        (0x1D703, "M", "θ"),
+        (0x1D704, "M", "ι"),
+        (0x1D705, "M", "κ"),
+        (0x1D706, "M", "λ"),
+        (0x1D707, "M", "μ"),
+        (0x1D708, "M", "ν"),
+        (0x1D709, "M", "ξ"),
+        (0x1D70A, "M", "ο"),
+        (0x1D70B, "M", "π"),
+        (0x1D70C, "M", "ρ"),
+        (0x1D70D, "M", "σ"),
+        (0x1D70F, "M", "τ"),
+        (0x1D710, "M", "υ"),
+        (0x1D711, "M", "φ"),
+        (0x1D712, "M", "χ"),
+        (0x1D713, "M", "ψ"),
+        (0x1D714, "M", "ω"),
+        (0x1D715, "M", "∂"),
+        (0x1D716, "M", "ε"),
+        (0x1D717, "M", "θ"),
+        (0x1D718, "M", "κ"),
+        (0x1D719, "M", "φ"),
+        (0x1D71A, "M", "ρ"),
+        (0x1D71B, "M", "π"),
+        (0x1D71C, "M", "α"),
+        (0x1D71D, "M", "β"),
+        (0x1D71E, "M", "γ"),
+        (0x1D71F, "M", "δ"),
+        (0x1D720, "M", "ε"),
+    ]
+
+
+def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D721, "M", "ζ"),
+        (0x1D722, "M", "η"),
+        (0x1D723, "M", "θ"),
+        (0x1D724, "M", "ι"),
+        (0x1D725, "M", "κ"),
+        (0x1D726, "M", "λ"),
+        (0x1D727, "M", "μ"),
+        (0x1D728, "M", "ν"),
+        (0x1D729, "M", "ξ"),
+        (0x1D72A, "M", "ο"),
+        (0x1D72B, "M", "π"),
+        (0x1D72C, "M", "ρ"),
+        (0x1D72D, "M", "θ"),
+        (0x1D72E, "M", "σ"),
+        (0x1D72F, "M", "τ"),
+        (0x1D730, "M", "υ"),
+        (0x1D731, "M", "φ"),
+        (0x1D732, "M", "χ"),
+        (0x1D733, "M", "ψ"),
+        (0x1D734, "M", "ω"),
+        (0x1D735, "M", "∇"),
+        (0x1D736, "M", "α"),
+        (0x1D737, "M", "β"),
+        (0x1D738, "M", "γ"),
+        (0x1D739, "M", "δ"),
+        (0x1D73A, "M", "ε"),
+        (0x1D73B, "M", "ζ"),
+        (0x1D73C, "M", "η"),
+        (0x1D73D, "M", "θ"),
+        (0x1D73E, "M", "ι"),
+        (0x1D73F, "M", "κ"),
+        (0x1D740, "M", "λ"),
+        (0x1D741, "M", "μ"),
+        (0x1D742, "M", "ν"),
+        (0x1D743, "M", "ξ"),
+        (0x1D744, "M", "ο"),
+        (0x1D745, "M", "π"),
+        (0x1D746, "M", "ρ"),
+        (0x1D747, "M", "σ"),
+        (0x1D749, "M", "τ"),
+        (0x1D74A, "M", "υ"),
+        (0x1D74B, "M", "φ"),
+        (0x1D74C, "M", "χ"),
+        (0x1D74D, "M", "ψ"),
+        (0x1D74E, "M", "ω"),
+        (0x1D74F, "M", "∂"),
+        (0x1D750, "M", "ε"),
+        (0x1D751, "M", "θ"),
+        (0x1D752, "M", "κ"),
+        (0x1D753, "M", "φ"),
+        (0x1D754, "M", "ρ"),
+        (0x1D755, "M", "π"),
+        (0x1D756, "M", "α"),
+        (0x1D757, "M", "β"),
+        (0x1D758, "M", "γ"),
+        (0x1D759, "M", "δ"),
+        (0x1D75A, "M", "ε"),
+        (0x1D75B, "M", "ζ"),
+        (0x1D75C, "M", "η"),
+        (0x1D75D, "M", "θ"),
+        (0x1D75E, "M", "ι"),
+        (0x1D75F, "M", "κ"),
+        (0x1D760, "M", "λ"),
+        (0x1D761, "M", "μ"),
+        (0x1D762, "M", "ν"),
+        (0x1D763, "M", "ξ"),
+        (0x1D764, "M", "ο"),
+        (0x1D765, "M", "π"),
+        (0x1D766, "M", "ρ"),
+        (0x1D767, "M", "θ"),
+        (0x1D768, "M", "σ"),
+        (0x1D769, "M", "τ"),
+        (0x1D76A, "M", "υ"),
+        (0x1D76B, "M", "φ"),
+        (0x1D76C, "M", "χ"),
+        (0x1D76D, "M", "ψ"),
+        (0x1D76E, "M", "ω"),
+        (0x1D76F, "M", "∇"),
+        (0x1D770, "M", "α"),
+        (0x1D771, "M", "β"),
+        (0x1D772, "M", "γ"),
+        (0x1D773, "M", "δ"),
+        (0x1D774, "M", "ε"),
+        (0x1D775, "M", "ζ"),
+        (0x1D776, "M", "η"),
+        (0x1D777, "M", "θ"),
+        (0x1D778, "M", "ι"),
+        (0x1D779, "M", "κ"),
+        (0x1D77A, "M", "λ"),
+        (0x1D77B, "M", "μ"),
+        (0x1D77C, "M", "ν"),
+        (0x1D77D, "M", "ξ"),
+        (0x1D77E, "M", "ο"),
+        (0x1D77F, "M", "π"),
+        (0x1D780, "M", "ρ"),
+        (0x1D781, "M", "σ"),
+        (0x1D783, "M", "τ"),
+        (0x1D784, "M", "υ"),
+        (0x1D785, "M", "φ"),
+        (0x1D786, "M", "χ"),
+    ]
+
+
+def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D787, "M", "ψ"),
+        (0x1D788, "M", "ω"),
+        (0x1D789, "M", "∂"),
+        (0x1D78A, "M", "ε"),
+        (0x1D78B, "M", "θ"),
+        (0x1D78C, "M", "κ"),
+        (0x1D78D, "M", "φ"),
+        (0x1D78E, "M", "ρ"),
+        (0x1D78F, "M", "π"),
+        (0x1D790, "M", "α"),
+        (0x1D791, "M", "β"),
+        (0x1D792, "M", "γ"),
+        (0x1D793, "M", "δ"),
+        (0x1D794, "M", "ε"),
+        (0x1D795, "M", "ζ"),
+        (0x1D796, "M", "η"),
+        (0x1D797, "M", "θ"),
+        (0x1D798, "M", "ι"),
+        (0x1D799, "M", "κ"),
+        (0x1D79A, "M", "λ"),
+        (0x1D79B, "M", "μ"),
+        (0x1D79C, "M", "ν"),
+        (0x1D79D, "M", "ξ"),
+        (0x1D79E, "M", "ο"),
+        (0x1D79F, "M", "π"),
+        (0x1D7A0, "M", "ρ"),
+        (0x1D7A1, "M", "θ"),
+        (0x1D7A2, "M", "σ"),
+        (0x1D7A3, "M", "τ"),
+        (0x1D7A4, "M", "υ"),
+        (0x1D7A5, "M", "φ"),
+        (0x1D7A6, "M", "χ"),
+        (0x1D7A7, "M", "ψ"),
+        (0x1D7A8, "M", "ω"),
+        (0x1D7A9, "M", "∇"),
+        (0x1D7AA, "M", "α"),
+        (0x1D7AB, "M", "β"),
+        (0x1D7AC, "M", "γ"),
+        (0x1D7AD, "M", "δ"),
+        (0x1D7AE, "M", "ε"),
+        (0x1D7AF, "M", "ζ"),
+        (0x1D7B0, "M", "η"),
+        (0x1D7B1, "M", "θ"),
+        (0x1D7B2, "M", "ι"),
+        (0x1D7B3, "M", "κ"),
+        (0x1D7B4, "M", "λ"),
+        (0x1D7B5, "M", "μ"),
+        (0x1D7B6, "M", "ν"),
+        (0x1D7B7, "M", "ξ"),
+        (0x1D7B8, "M", "ο"),
+        (0x1D7B9, "M", "π"),
+        (0x1D7BA, "M", "ρ"),
+        (0x1D7BB, "M", "σ"),
+        (0x1D7BD, "M", "τ"),
+        (0x1D7BE, "M", "υ"),
+        (0x1D7BF, "M", "φ"),
+        (0x1D7C0, "M", "χ"),
+        (0x1D7C1, "M", "ψ"),
+        (0x1D7C2, "M", "ω"),
+        (0x1D7C3, "M", "∂"),
+        (0x1D7C4, "M", "ε"),
+        (0x1D7C5, "M", "θ"),
+        (0x1D7C6, "M", "κ"),
+        (0x1D7C7, "M", "φ"),
+        (0x1D7C8, "M", "ρ"),
+        (0x1D7C9, "M", "π"),
+        (0x1D7CA, "M", "ϝ"),
+        (0x1D7CC, "X"),
+        (0x1D7CE, "M", "0"),
+        (0x1D7CF, "M", "1"),
+        (0x1D7D0, "M", "2"),
+        (0x1D7D1, "M", "3"),
+        (0x1D7D2, "M", "4"),
+        (0x1D7D3, "M", "5"),
+        (0x1D7D4, "M", "6"),
+        (0x1D7D5, "M", "7"),
+        (0x1D7D6, "M", "8"),
+        (0x1D7D7, "M", "9"),
+        (0x1D7D8, "M", "0"),
+        (0x1D7D9, "M", "1"),
+        (0x1D7DA, "M", "2"),
+        (0x1D7DB, "M", "3"),
+        (0x1D7DC, "M", "4"),
+        (0x1D7DD, "M", "5"),
+        (0x1D7DE, "M", "6"),
+        (0x1D7DF, "M", "7"),
+        (0x1D7E0, "M", "8"),
+        (0x1D7E1, "M", "9"),
+        (0x1D7E2, "M", "0"),
+        (0x1D7E3, "M", "1"),
+        (0x1D7E4, "M", "2"),
+        (0x1D7E5, "M", "3"),
+        (0x1D7E6, "M", "4"),
+        (0x1D7E7, "M", "5"),
+        (0x1D7E8, "M", "6"),
+        (0x1D7E9, "M", "7"),
+        (0x1D7EA, "M", "8"),
+        (0x1D7EB, "M", "9"),
+        (0x1D7EC, "M", "0"),
+        (0x1D7ED, "M", "1"),
+    ]
+
+
+def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1D7EE, "M", "2"),
+        (0x1D7EF, "M", "3"),
+        (0x1D7F0, "M", "4"),
+        (0x1D7F1, "M", "5"),
+        (0x1D7F2, "M", "6"),
+        (0x1D7F3, "M", "7"),
+        (0x1D7F4, "M", "8"),
+        (0x1D7F5, "M", "9"),
+        (0x1D7F6, "M", "0"),
+        (0x1D7F7, "M", "1"),
+        (0x1D7F8, "M", "2"),
+        (0x1D7F9, "M", "3"),
+        (0x1D7FA, "M", "4"),
+        (0x1D7FB, "M", "5"),
+        (0x1D7FC, "M", "6"),
+        (0x1D7FD, "M", "7"),
+        (0x1D7FE, "M", "8"),
+        (0x1D7FF, "M", "9"),
+        (0x1D800, "V"),
+        (0x1DA8C, "X"),
+        (0x1DA9B, "V"),
+        (0x1DAA0, "X"),
+        (0x1DAA1, "V"),
+        (0x1DAB0, "X"),
+        (0x1DF00, "V"),
+        (0x1DF1F, "X"),
+        (0x1DF25, "V"),
+        (0x1DF2B, "X"),
+        (0x1E000, "V"),
+        (0x1E007, "X"),
+        (0x1E008, "V"),
+        (0x1E019, "X"),
+        (0x1E01B, "V"),
+        (0x1E022, "X"),
+        (0x1E023, "V"),
+        (0x1E025, "X"),
+        (0x1E026, "V"),
+        (0x1E02B, "X"),
+        (0x1E030, "M", "а"),
+        (0x1E031, "M", "б"),
+        (0x1E032, "M", "в"),
+        (0x1E033, "M", "г"),
+        (0x1E034, "M", "д"),
+        (0x1E035, "M", "е"),
+        (0x1E036, "M", "ж"),
+        (0x1E037, "M", "з"),
+        (0x1E038, "M", "и"),
+        (0x1E039, "M", "к"),
+        (0x1E03A, "M", "л"),
+        (0x1E03B, "M", "м"),
+        (0x1E03C, "M", "о"),
+        (0x1E03D, "M", "п"),
+        (0x1E03E, "M", "р"),
+        (0x1E03F, "M", "с"),
+        (0x1E040, "M", "т"),
+        (0x1E041, "M", "у"),
+        (0x1E042, "M", "ф"),
+        (0x1E043, "M", "х"),
+        (0x1E044, "M", "ц"),
+        (0x1E045, "M", "ч"),
+        (0x1E046, "M", "ш"),
+        (0x1E047, "M", "ы"),
+        (0x1E048, "M", "э"),
+        (0x1E049, "M", "ю"),
+        (0x1E04A, "M", "ꚉ"),
+        (0x1E04B, "M", "ә"),
+        (0x1E04C, "M", "і"),
+        (0x1E04D, "M", "ј"),
+        (0x1E04E, "M", "ө"),
+        (0x1E04F, "M", "ү"),
+        (0x1E050, "M", "ӏ"),
+        (0x1E051, "M", "а"),
+        (0x1E052, "M", "б"),
+        (0x1E053, "M", "в"),
+        (0x1E054, "M", "г"),
+        (0x1E055, "M", "д"),
+        (0x1E056, "M", "е"),
+        (0x1E057, "M", "ж"),
+        (0x1E058, "M", "з"),
+        (0x1E059, "M", "и"),
+        (0x1E05A, "M", "к"),
+        (0x1E05B, "M", "л"),
+        (0x1E05C, "M", "о"),
+        (0x1E05D, "M", "п"),
+        (0x1E05E, "M", "с"),
+        (0x1E05F, "M", "у"),
+        (0x1E060, "M", "ф"),
+        (0x1E061, "M", "х"),
+        (0x1E062, "M", "ц"),
+        (0x1E063, "M", "ч"),
+        (0x1E064, "M", "ш"),
+        (0x1E065, "M", "ъ"),
+        (0x1E066, "M", "ы"),
+        (0x1E067, "M", "ґ"),
+        (0x1E068, "M", "і"),
+        (0x1E069, "M", "ѕ"),
+        (0x1E06A, "M", "џ"),
+        (0x1E06B, "M", "ҫ"),
+        (0x1E06C, "M", "ꙑ"),
+        (0x1E06D, "M", "ұ"),
+    ]
+
+
+def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1E06E, "X"),
+        (0x1E08F, "V"),
+        (0x1E090, "X"),
+        (0x1E100, "V"),
+        (0x1E12D, "X"),
+        (0x1E130, "V"),
+        (0x1E13E, "X"),
+        (0x1E140, "V"),
+        (0x1E14A, "X"),
+        (0x1E14E, "V"),
+        (0x1E150, "X"),
+        (0x1E290, "V"),
+        (0x1E2AF, "X"),
+        (0x1E2C0, "V"),
+        (0x1E2FA, "X"),
+        (0x1E2FF, "V"),
+        (0x1E300, "X"),
+        (0x1E4D0, "V"),
+        (0x1E4FA, "X"),
+        (0x1E5D0, "V"),
+        (0x1E5FB, "X"),
+        (0x1E5FF, "V"),
+        (0x1E600, "X"),
+        (0x1E7E0, "V"),
+        (0x1E7E7, "X"),
+        (0x1E7E8, "V"),
+        (0x1E7EC, "X"),
+        (0x1E7ED, "V"),
+        (0x1E7EF, "X"),
+        (0x1E7F0, "V"),
+        (0x1E7FF, "X"),
+        (0x1E800, "V"),
+        (0x1E8C5, "X"),
+        (0x1E8C7, "V"),
+        (0x1E8D7, "X"),
+        (0x1E900, "M", "𞤢"),
+        (0x1E901, "M", "𞤣"),
+        (0x1E902, "M", "𞤤"),
+        (0x1E903, "M", "𞤥"),
+        (0x1E904, "M", "𞤦"),
+        (0x1E905, "M", "𞤧"),
+        (0x1E906, "M", "𞤨"),
+        (0x1E907, "M", "𞤩"),
+        (0x1E908, "M", "𞤪"),
+        (0x1E909, "M", "𞤫"),
+        (0x1E90A, "M", "𞤬"),
+        (0x1E90B, "M", "𞤭"),
+        (0x1E90C, "M", "𞤮"),
+        (0x1E90D, "M", "𞤯"),
+        (0x1E90E, "M", "𞤰"),
+        (0x1E90F, "M", "𞤱"),
+        (0x1E910, "M", "𞤲"),
+        (0x1E911, "M", "𞤳"),
+        (0x1E912, "M", "𞤴"),
+        (0x1E913, "M", "𞤵"),
+        (0x1E914, "M", "𞤶"),
+        (0x1E915, "M", "𞤷"),
+        (0x1E916, "M", "𞤸"),
+        (0x1E917, "M", "𞤹"),
+        (0x1E918, "M", "𞤺"),
+        (0x1E919, "M", "𞤻"),
+        (0x1E91A, "M", "𞤼"),
+        (0x1E91B, "M", "𞤽"),
+        (0x1E91C, "M", "𞤾"),
+        (0x1E91D, "M", "𞤿"),
+        (0x1E91E, "M", "𞥀"),
+        (0x1E91F, "M", "𞥁"),
+        (0x1E920, "M", "𞥂"),
+        (0x1E921, "M", "𞥃"),
+        (0x1E922, "V"),
+        (0x1E94C, "X"),
+        (0x1E950, "V"),
+        (0x1E95A, "X"),
+        (0x1E95E, "V"),
+        (0x1E960, "X"),
+        (0x1EC71, "V"),
+        (0x1ECB5, "X"),
+        (0x1ED01, "V"),
+        (0x1ED3E, "X"),
+        (0x1EE00, "M", "ا"),
+        (0x1EE01, "M", "ب"),
+        (0x1EE02, "M", "ج"),
+        (0x1EE03, "M", "د"),
+        (0x1EE04, "X"),
+        (0x1EE05, "M", "و"),
+        (0x1EE06, "M", "ز"),
+        (0x1EE07, "M", "ح"),
+        (0x1EE08, "M", "ط"),
+        (0x1EE09, "M", "ي"),
+        (0x1EE0A, "M", "ك"),
+        (0x1EE0B, "M", "ل"),
+        (0x1EE0C, "M", "م"),
+        (0x1EE0D, "M", "ن"),
+        (0x1EE0E, "M", "س"),
+        (0x1EE0F, "M", "ع"),
+        (0x1EE10, "M", "ف"),
+        (0x1EE11, "M", "ص"),
+        (0x1EE12, "M", "ق"),
+        (0x1EE13, "M", "ر"),
+        (0x1EE14, "M", "ش"),
+    ]
+
+
+def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1EE15, "M", "ت"),
+        (0x1EE16, "M", "ث"),
+        (0x1EE17, "M", "خ"),
+        (0x1EE18, "M", "ذ"),
+        (0x1EE19, "M", "ض"),
+        (0x1EE1A, "M", "ظ"),
+        (0x1EE1B, "M", "غ"),
+        (0x1EE1C, "M", "ٮ"),
+        (0x1EE1D, "M", "ں"),
+        (0x1EE1E, "M", "ڡ"),
+        (0x1EE1F, "M", "ٯ"),
+        (0x1EE20, "X"),
+        (0x1EE21, "M", "ب"),
+        (0x1EE22, "M", "ج"),
+        (0x1EE23, "X"),
+        (0x1EE24, "M", "ه"),
+        (0x1EE25, "X"),
+        (0x1EE27, "M", "ح"),
+        (0x1EE28, "X"),
+        (0x1EE29, "M", "ي"),
+        (0x1EE2A, "M", "ك"),
+        (0x1EE2B, "M", "ل"),
+        (0x1EE2C, "M", "م"),
+        (0x1EE2D, "M", "ن"),
+        (0x1EE2E, "M", "س"),
+        (0x1EE2F, "M", "ع"),
+        (0x1EE30, "M", "ف"),
+        (0x1EE31, "M", "ص"),
+        (0x1EE32, "M", "ق"),
+        (0x1EE33, "X"),
+        (0x1EE34, "M", "ش"),
+        (0x1EE35, "M", "ت"),
+        (0x1EE36, "M", "ث"),
+        (0x1EE37, "M", "خ"),
+        (0x1EE38, "X"),
+        (0x1EE39, "M", "ض"),
+        (0x1EE3A, "X"),
+        (0x1EE3B, "M", "غ"),
+        (0x1EE3C, "X"),
+        (0x1EE42, "M", "ج"),
+        (0x1EE43, "X"),
+        (0x1EE47, "M", "ح"),
+        (0x1EE48, "X"),
+        (0x1EE49, "M", "ي"),
+        (0x1EE4A, "X"),
+        (0x1EE4B, "M", "ل"),
+        (0x1EE4C, "X"),
+        (0x1EE4D, "M", "ن"),
+        (0x1EE4E, "M", "س"),
+        (0x1EE4F, "M", "ع"),
+        (0x1EE50, "X"),
+        (0x1EE51, "M", "ص"),
+        (0x1EE52, "M", "ق"),
+        (0x1EE53, "X"),
+        (0x1EE54, "M", "ش"),
+        (0x1EE55, "X"),
+        (0x1EE57, "M", "خ"),
+        (0x1EE58, "X"),
+        (0x1EE59, "M", "ض"),
+        (0x1EE5A, "X"),
+        (0x1EE5B, "M", "غ"),
+        (0x1EE5C, "X"),
+        (0x1EE5D, "M", "ں"),
+        (0x1EE5E, "X"),
+        (0x1EE5F, "M", "ٯ"),
+        (0x1EE60, "X"),
+        (0x1EE61, "M", "ب"),
+        (0x1EE62, "M", "ج"),
+        (0x1EE63, "X"),
+        (0x1EE64, "M", "ه"),
+        (0x1EE65, "X"),
+        (0x1EE67, "M", "ح"),
+        (0x1EE68, "M", "ط"),
+        (0x1EE69, "M", "ي"),
+        (0x1EE6A, "M", "ك"),
+        (0x1EE6B, "X"),
+        (0x1EE6C, "M", "م"),
+        (0x1EE6D, "M", "ن"),
+        (0x1EE6E, "M", "س"),
+        (0x1EE6F, "M", "ع"),
+        (0x1EE70, "M", "ف"),
+        (0x1EE71, "M", "ص"),
+        (0x1EE72, "M", "ق"),
+        (0x1EE73, "X"),
+        (0x1EE74, "M", "ش"),
+        (0x1EE75, "M", "ت"),
+        (0x1EE76, "M", "ث"),
+        (0x1EE77, "M", "خ"),
+        (0x1EE78, "X"),
+        (0x1EE79, "M", "ض"),
+        (0x1EE7A, "M", "ظ"),
+        (0x1EE7B, "M", "غ"),
+        (0x1EE7C, "M", "ٮ"),
+        (0x1EE7D, "X"),
+        (0x1EE7E, "M", "ڡ"),
+        (0x1EE7F, "X"),
+        (0x1EE80, "M", "ا"),
+        (0x1EE81, "M", "ب"),
+        (0x1EE82, "M", "ج"),
+        (0x1EE83, "M", "د"),
+    ]
+
+
+def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1EE84, "M", "ه"),
+        (0x1EE85, "M", "و"),
+        (0x1EE86, "M", "ز"),
+        (0x1EE87, "M", "ح"),
+        (0x1EE88, "M", "ط"),
+        (0x1EE89, "M", "ي"),
+        (0x1EE8A, "X"),
+        (0x1EE8B, "M", "ل"),
+        (0x1EE8C, "M", "م"),
+        (0x1EE8D, "M", "ن"),
+        (0x1EE8E, "M", "س"),
+        (0x1EE8F, "M", "ع"),
+        (0x1EE90, "M", "ف"),
+        (0x1EE91, "M", "ص"),
+        (0x1EE92, "M", "ق"),
+        (0x1EE93, "M", "ر"),
+        (0x1EE94, "M", "ش"),
+        (0x1EE95, "M", "ت"),
+        (0x1EE96, "M", "ث"),
+        (0x1EE97, "M", "خ"),
+        (0x1EE98, "M", "ذ"),
+        (0x1EE99, "M", "ض"),
+        (0x1EE9A, "M", "ظ"),
+        (0x1EE9B, "M", "غ"),
+        (0x1EE9C, "X"),
+        (0x1EEA1, "M", "ب"),
+        (0x1EEA2, "M", "ج"),
+        (0x1EEA3, "M", "د"),
+        (0x1EEA4, "X"),
+        (0x1EEA5, "M", "و"),
+        (0x1EEA6, "M", "ز"),
+        (0x1EEA7, "M", "ح"),
+        (0x1EEA8, "M", "ط"),
+        (0x1EEA9, "M", "ي"),
+        (0x1EEAA, "X"),
+        (0x1EEAB, "M", "ل"),
+        (0x1EEAC, "M", "م"),
+        (0x1EEAD, "M", "ن"),
+        (0x1EEAE, "M", "س"),
+        (0x1EEAF, "M", "ع"),
+        (0x1EEB0, "M", "ف"),
+        (0x1EEB1, "M", "ص"),
+        (0x1EEB2, "M", "ق"),
+        (0x1EEB3, "M", "ر"),
+        (0x1EEB4, "M", "ش"),
+        (0x1EEB5, "M", "ت"),
+        (0x1EEB6, "M", "ث"),
+        (0x1EEB7, "M", "خ"),
+        (0x1EEB8, "M", "ذ"),
+        (0x1EEB9, "M", "ض"),
+        (0x1EEBA, "M", "ظ"),
+        (0x1EEBB, "M", "غ"),
+        (0x1EEBC, "X"),
+        (0x1EEF0, "V"),
+        (0x1EEF2, "X"),
+        (0x1F000, "V"),
+        (0x1F02C, "X"),
+        (0x1F030, "V"),
+        (0x1F094, "X"),
+        (0x1F0A0, "V"),
+        (0x1F0AF, "X"),
+        (0x1F0B1, "V"),
+        (0x1F0C0, "X"),
+        (0x1F0C1, "V"),
+        (0x1F0D0, "X"),
+        (0x1F0D1, "V"),
+        (0x1F0F6, "X"),
+        (0x1F101, "M", "0,"),
+        (0x1F102, "M", "1,"),
+        (0x1F103, "M", "2,"),
+        (0x1F104, "M", "3,"),
+        (0x1F105, "M", "4,"),
+        (0x1F106, "M", "5,"),
+        (0x1F107, "M", "6,"),
+        (0x1F108, "M", "7,"),
+        (0x1F109, "M", "8,"),
+        (0x1F10A, "M", "9,"),
+        (0x1F10B, "V"),
+        (0x1F110, "M", "(a)"),
+        (0x1F111, "M", "(b)"),
+        (0x1F112, "M", "(c)"),
+        (0x1F113, "M", "(d)"),
+        (0x1F114, "M", "(e)"),
+        (0x1F115, "M", "(f)"),
+        (0x1F116, "M", "(g)"),
+        (0x1F117, "M", "(h)"),
+        (0x1F118, "M", "(i)"),
+        (0x1F119, "M", "(j)"),
+        (0x1F11A, "M", "(k)"),
+        (0x1F11B, "M", "(l)"),
+        (0x1F11C, "M", "(m)"),
+        (0x1F11D, "M", "(n)"),
+        (0x1F11E, "M", "(o)"),
+        (0x1F11F, "M", "(p)"),
+        (0x1F120, "M", "(q)"),
+        (0x1F121, "M", "(r)"),
+        (0x1F122, "M", "(s)"),
+        (0x1F123, "M", "(t)"),
+        (0x1F124, "M", "(u)"),
+        (0x1F125, "M", "(v)"),
+    ]
+
+
+def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1F126, "M", "(w)"),
+        (0x1F127, "M", "(x)"),
+        (0x1F128, "M", "(y)"),
+        (0x1F129, "M", "(z)"),
+        (0x1F12A, "M", "〔s〕"),
+        (0x1F12B, "M", "c"),
+        (0x1F12C, "M", "r"),
+        (0x1F12D, "M", "cd"),
+        (0x1F12E, "M", "wz"),
+        (0x1F12F, "V"),
+        (0x1F130, "M", "a"),
+        (0x1F131, "M", "b"),
+        (0x1F132, "M", "c"),
+        (0x1F133, "M", "d"),
+        (0x1F134, "M", "e"),
+        (0x1F135, "M", "f"),
+        (0x1F136, "M", "g"),
+        (0x1F137, "M", "h"),
+        (0x1F138, "M", "i"),
+        (0x1F139, "M", "j"),
+        (0x1F13A, "M", "k"),
+        (0x1F13B, "M", "l"),
+        (0x1F13C, "M", "m"),
+        (0x1F13D, "M", "n"),
+        (0x1F13E, "M", "o"),
+        (0x1F13F, "M", "p"),
+        (0x1F140, "M", "q"),
+        (0x1F141, "M", "r"),
+        (0x1F142, "M", "s"),
+        (0x1F143, "M", "t"),
+        (0x1F144, "M", "u"),
+        (0x1F145, "M", "v"),
+        (0x1F146, "M", "w"),
+        (0x1F147, "M", "x"),
+        (0x1F148, "M", "y"),
+        (0x1F149, "M", "z"),
+        (0x1F14A, "M", "hv"),
+        (0x1F14B, "M", "mv"),
+        (0x1F14C, "M", "sd"),
+        (0x1F14D, "M", "ss"),
+        (0x1F14E, "M", "ppv"),
+        (0x1F14F, "M", "wc"),
+        (0x1F150, "V"),
+        (0x1F16A, "M", "mc"),
+        (0x1F16B, "M", "md"),
+        (0x1F16C, "M", "mr"),
+        (0x1F16D, "V"),
+        (0x1F190, "M", "dj"),
+        (0x1F191, "V"),
+        (0x1F1AE, "X"),
+        (0x1F1E6, "V"),
+        (0x1F200, "M", "ほか"),
+        (0x1F201, "M", "ココ"),
+        (0x1F202, "M", "サ"),
+        (0x1F203, "X"),
+        (0x1F210, "M", "手"),
+        (0x1F211, "M", "字"),
+        (0x1F212, "M", "双"),
+        (0x1F213, "M", "デ"),
+        (0x1F214, "M", "二"),
+        (0x1F215, "M", "多"),
+        (0x1F216, "M", "解"),
+        (0x1F217, "M", "天"),
+        (0x1F218, "M", "交"),
+        (0x1F219, "M", "映"),
+        (0x1F21A, "M", "無"),
+        (0x1F21B, "M", "料"),
+        (0x1F21C, "M", "前"),
+        (0x1F21D, "M", "後"),
+        (0x1F21E, "M", "再"),
+        (0x1F21F, "M", "新"),
+        (0x1F220, "M", "初"),
+        (0x1F221, "M", "終"),
+        (0x1F222, "M", "生"),
+        (0x1F223, "M", "販"),
+        (0x1F224, "M", "声"),
+        (0x1F225, "M", "吹"),
+        (0x1F226, "M", "演"),
+        (0x1F227, "M", "投"),
+        (0x1F228, "M", "捕"),
+        (0x1F229, "M", "一"),
+        (0x1F22A, "M", "三"),
+        (0x1F22B, "M", "遊"),
+        (0x1F22C, "M", "左"),
+        (0x1F22D, "M", "中"),
+        (0x1F22E, "M", "右"),
+        (0x1F22F, "M", "指"),
+        (0x1F230, "M", "走"),
+        (0x1F231, "M", "打"),
+        (0x1F232, "M", "禁"),
+        (0x1F233, "M", "空"),
+        (0x1F234, "M", "合"),
+        (0x1F235, "M", "満"),
+        (0x1F236, "M", "有"),
+        (0x1F237, "M", "月"),
+        (0x1F238, "M", "申"),
+        (0x1F239, "M", "割"),
+        (0x1F23A, "M", "営"),
+        (0x1F23B, "M", "配"),
+        (0x1F23C, "X"),
+    ]
+
+
+def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x1F240, "M", "〔本〕"),
+        (0x1F241, "M", "〔三〕"),
+        (0x1F242, "M", "〔二〕"),
+        (0x1F243, "M", "〔安〕"),
+        (0x1F244, "M", "〔点〕"),
+        (0x1F245, "M", "〔打〕"),
+        (0x1F246, "M", "〔盗〕"),
+        (0x1F247, "M", "〔勝〕"),
+        (0x1F248, "M", "〔敗〕"),
+        (0x1F249, "X"),
+        (0x1F250, "M", "得"),
+        (0x1F251, "M", "可"),
+        (0x1F252, "X"),
+        (0x1F260, "V"),
+        (0x1F266, "X"),
+        (0x1F300, "V"),
+        (0x1F6D8, "X"),
+        (0x1F6DC, "V"),
+        (0x1F6ED, "X"),
+        (0x1F6F0, "V"),
+        (0x1F6FD, "X"),
+        (0x1F700, "V"),
+        (0x1F777, "X"),
+        (0x1F77B, "V"),
+        (0x1F7DA, "X"),
+        (0x1F7E0, "V"),
+        (0x1F7EC, "X"),
+        (0x1F7F0, "V"),
+        (0x1F7F1, "X"),
+        (0x1F800, "V"),
+        (0x1F80C, "X"),
+        (0x1F810, "V"),
+        (0x1F848, "X"),
+        (0x1F850, "V"),
+        (0x1F85A, "X"),
+        (0x1F860, "V"),
+        (0x1F888, "X"),
+        (0x1F890, "V"),
+        (0x1F8AE, "X"),
+        (0x1F8B0, "V"),
+        (0x1F8BC, "X"),
+        (0x1F8C0, "V"),
+        (0x1F8C2, "X"),
+        (0x1F900, "V"),
+        (0x1FA54, "X"),
+        (0x1FA60, "V"),
+        (0x1FA6E, "X"),
+        (0x1FA70, "V"),
+        (0x1FA7D, "X"),
+        (0x1FA80, "V"),
+        (0x1FA8A, "X"),
+        (0x1FA8F, "V"),
+        (0x1FAC7, "X"),
+        (0x1FACE, "V"),
+        (0x1FADD, "X"),
+        (0x1FADF, "V"),
+        (0x1FAEA, "X"),
+        (0x1FAF0, "V"),
+        (0x1FAF9, "X"),
+        (0x1FB00, "V"),
+        (0x1FB93, "X"),
+        (0x1FB94, "V"),
+        (0x1FBF0, "M", "0"),
+        (0x1FBF1, "M", "1"),
+        (0x1FBF2, "M", "2"),
+        (0x1FBF3, "M", "3"),
+        (0x1FBF4, "M", "4"),
+        (0x1FBF5, "M", "5"),
+        (0x1FBF6, "M", "6"),
+        (0x1FBF7, "M", "7"),
+        (0x1FBF8, "M", "8"),
+        (0x1FBF9, "M", "9"),
+        (0x1FBFA, "X"),
+        (0x20000, "V"),
+        (0x2A6E0, "X"),
+        (0x2A700, "V"),
+        (0x2B73A, "X"),
+        (0x2B740, "V"),
+        (0x2B81E, "X"),
+        (0x2B820, "V"),
+        (0x2CEA2, "X"),
+        (0x2CEB0, "V"),
+        (0x2EBE1, "X"),
+        (0x2EBF0, "V"),
+        (0x2EE5E, "X"),
+        (0x2F800, "M", "丽"),
+        (0x2F801, "M", "丸"),
+        (0x2F802, "M", "乁"),
+        (0x2F803, "M", "𠄢"),
+        (0x2F804, "M", "你"),
+        (0x2F805, "M", "侮"),
+        (0x2F806, "M", "侻"),
+        (0x2F807, "M", "倂"),
+        (0x2F808, "M", "偺"),
+        (0x2F809, "M", "備"),
+        (0x2F80A, "M", "僧"),
+        (0x2F80B, "M", "像"),
+        (0x2F80C, "M", "㒞"),
+        (0x2F80D, "M", "𠘺"),
+        (0x2F80E, "M", "免"),
+    ]
+
+
+def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F80F, "M", "兔"),
+        (0x2F810, "M", "兤"),
+        (0x2F811, "M", "具"),
+        (0x2F812, "M", "𠔜"),
+        (0x2F813, "M", "㒹"),
+        (0x2F814, "M", "內"),
+        (0x2F815, "M", "再"),
+        (0x2F816, "M", "𠕋"),
+        (0x2F817, "M", "冗"),
+        (0x2F818, "M", "冤"),
+        (0x2F819, "M", "仌"),
+        (0x2F81A, "M", "冬"),
+        (0x2F81B, "M", "况"),
+        (0x2F81C, "M", "𩇟"),
+        (0x2F81D, "M", "凵"),
+        (0x2F81E, "M", "刃"),
+        (0x2F81F, "M", "㓟"),
+        (0x2F820, "M", "刻"),
+        (0x2F821, "M", "剆"),
+        (0x2F822, "M", "割"),
+        (0x2F823, "M", "剷"),
+        (0x2F824, "M", "㔕"),
+        (0x2F825, "M", "勇"),
+        (0x2F826, "M", "勉"),
+        (0x2F827, "M", "勤"),
+        (0x2F828, "M", "勺"),
+        (0x2F829, "M", "包"),
+        (0x2F82A, "M", "匆"),
+        (0x2F82B, "M", "北"),
+        (0x2F82C, "M", "卉"),
+        (0x2F82D, "M", "卑"),
+        (0x2F82E, "M", "博"),
+        (0x2F82F, "M", "即"),
+        (0x2F830, "M", "卽"),
+        (0x2F831, "M", "卿"),
+        (0x2F834, "M", "𠨬"),
+        (0x2F835, "M", "灰"),
+        (0x2F836, "M", "及"),
+        (0x2F837, "M", "叟"),
+        (0x2F838, "M", "𠭣"),
+        (0x2F839, "M", "叫"),
+        (0x2F83A, "M", "叱"),
+        (0x2F83B, "M", "吆"),
+        (0x2F83C, "M", "咞"),
+        (0x2F83D, "M", "吸"),
+        (0x2F83E, "M", "呈"),
+        (0x2F83F, "M", "周"),
+        (0x2F840, "M", "咢"),
+        (0x2F841, "M", "哶"),
+        (0x2F842, "M", "唐"),
+        (0x2F843, "M", "啓"),
+        (0x2F844, "M", "啣"),
+        (0x2F845, "M", "善"),
+        (0x2F847, "M", "喙"),
+        (0x2F848, "M", "喫"),
+        (0x2F849, "M", "喳"),
+        (0x2F84A, "M", "嗂"),
+        (0x2F84B, "M", "圖"),
+        (0x2F84C, "M", "嘆"),
+        (0x2F84D, "M", "圗"),
+        (0x2F84E, "M", "噑"),
+        (0x2F84F, "M", "噴"),
+        (0x2F850, "M", "切"),
+        (0x2F851, "M", "壮"),
+        (0x2F852, "M", "城"),
+        (0x2F853, "M", "埴"),
+        (0x2F854, "M", "堍"),
+        (0x2F855, "M", "型"),
+        (0x2F856, "M", "堲"),
+        (0x2F857, "M", "報"),
+        (0x2F858, "M", "墬"),
+        (0x2F859, "M", "𡓤"),
+        (0x2F85A, "M", "売"),
+        (0x2F85B, "M", "壷"),
+        (0x2F85C, "M", "夆"),
+        (0x2F85D, "M", "多"),
+        (0x2F85E, "M", "夢"),
+        (0x2F85F, "M", "奢"),
+        (0x2F860, "M", "𡚨"),
+        (0x2F861, "M", "𡛪"),
+        (0x2F862, "M", "姬"),
+        (0x2F863, "M", "娛"),
+        (0x2F864, "M", "娧"),
+        (0x2F865, "M", "姘"),
+        (0x2F866, "M", "婦"),
+        (0x2F867, "M", "㛮"),
+        (0x2F868, "M", "㛼"),
+        (0x2F869, "M", "嬈"),
+        (0x2F86A, "M", "嬾"),
+        (0x2F86C, "M", "𡧈"),
+        (0x2F86D, "M", "寃"),
+        (0x2F86E, "M", "寘"),
+        (0x2F86F, "M", "寧"),
+        (0x2F870, "M", "寳"),
+        (0x2F871, "M", "𡬘"),
+        (0x2F872, "M", "寿"),
+        (0x2F873, "M", "将"),
+        (0x2F874, "M", "当"),
+        (0x2F875, "M", "尢"),
+        (0x2F876, "M", "㞁"),
+    ]
+
+
+def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F877, "M", "屠"),
+        (0x2F878, "M", "屮"),
+        (0x2F879, "M", "峀"),
+        (0x2F87A, "M", "岍"),
+        (0x2F87B, "M", "𡷤"),
+        (0x2F87C, "M", "嵃"),
+        (0x2F87D, "M", "𡷦"),
+        (0x2F87E, "M", "嵮"),
+        (0x2F87F, "M", "嵫"),
+        (0x2F880, "M", "嵼"),
+        (0x2F881, "M", "巡"),
+        (0x2F882, "M", "巢"),
+        (0x2F883, "M", "㠯"),
+        (0x2F884, "M", "巽"),
+        (0x2F885, "M", "帨"),
+        (0x2F886, "M", "帽"),
+        (0x2F887, "M", "幩"),
+        (0x2F888, "M", "㡢"),
+        (0x2F889, "M", "𢆃"),
+        (0x2F88A, "M", "㡼"),
+        (0x2F88B, "M", "庰"),
+        (0x2F88C, "M", "庳"),
+        (0x2F88D, "M", "庶"),
+        (0x2F88E, "M", "廊"),
+        (0x2F88F, "M", "𪎒"),
+        (0x2F890, "M", "廾"),
+        (0x2F891, "M", "𢌱"),
+        (0x2F893, "M", "舁"),
+        (0x2F894, "M", "弢"),
+        (0x2F896, "M", "㣇"),
+        (0x2F897, "M", "𣊸"),
+        (0x2F898, "M", "𦇚"),
+        (0x2F899, "M", "形"),
+        (0x2F89A, "M", "彫"),
+        (0x2F89B, "M", "㣣"),
+        (0x2F89C, "M", "徚"),
+        (0x2F89D, "M", "忍"),
+        (0x2F89E, "M", "志"),
+        (0x2F89F, "M", "忹"),
+        (0x2F8A0, "M", "悁"),
+        (0x2F8A1, "M", "㤺"),
+        (0x2F8A2, "M", "㤜"),
+        (0x2F8A3, "M", "悔"),
+        (0x2F8A4, "M", "𢛔"),
+        (0x2F8A5, "M", "惇"),
+        (0x2F8A6, "M", "慈"),
+        (0x2F8A7, "M", "慌"),
+        (0x2F8A8, "M", "慎"),
+        (0x2F8A9, "M", "慌"),
+        (0x2F8AA, "M", "慺"),
+        (0x2F8AB, "M", "憎"),
+        (0x2F8AC, "M", "憲"),
+        (0x2F8AD, "M", "憤"),
+        (0x2F8AE, "M", "憯"),
+        (0x2F8AF, "M", "懞"),
+        (0x2F8B0, "M", "懲"),
+        (0x2F8B1, "M", "懶"),
+        (0x2F8B2, "M", "成"),
+        (0x2F8B3, "M", "戛"),
+        (0x2F8B4, "M", "扝"),
+        (0x2F8B5, "M", "抱"),
+        (0x2F8B6, "M", "拔"),
+        (0x2F8B7, "M", "捐"),
+        (0x2F8B8, "M", "𢬌"),
+        (0x2F8B9, "M", "挽"),
+        (0x2F8BA, "M", "拼"),
+        (0x2F8BB, "M", "捨"),
+        (0x2F8BC, "M", "掃"),
+        (0x2F8BD, "M", "揤"),
+        (0x2F8BE, "M", "𢯱"),
+        (0x2F8BF, "M", "搢"),
+        (0x2F8C0, "M", "揅"),
+        (0x2F8C1, "M", "掩"),
+        (0x2F8C2, "M", "㨮"),
+        (0x2F8C3, "M", "摩"),
+        (0x2F8C4, "M", "摾"),
+        (0x2F8C5, "M", "撝"),
+        (0x2F8C6, "M", "摷"),
+        (0x2F8C7, "M", "㩬"),
+        (0x2F8C8, "M", "敏"),
+        (0x2F8C9, "M", "敬"),
+        (0x2F8CA, "M", "𣀊"),
+        (0x2F8CB, "M", "旣"),
+        (0x2F8CC, "M", "書"),
+        (0x2F8CD, "M", "晉"),
+        (0x2F8CE, "M", "㬙"),
+        (0x2F8CF, "M", "暑"),
+        (0x2F8D0, "M", "㬈"),
+        (0x2F8D1, "M", "㫤"),
+        (0x2F8D2, "M", "冒"),
+        (0x2F8D3, "M", "冕"),
+        (0x2F8D4, "M", "最"),
+        (0x2F8D5, "M", "暜"),
+        (0x2F8D6, "M", "肭"),
+        (0x2F8D7, "M", "䏙"),
+        (0x2F8D8, "M", "朗"),
+        (0x2F8D9, "M", "望"),
+        (0x2F8DA, "M", "朡"),
+        (0x2F8DB, "M", "杞"),
+        (0x2F8DC, "M", "杓"),
+    ]
+
+
+def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F8DD, "M", "𣏃"),
+        (0x2F8DE, "M", "㭉"),
+        (0x2F8DF, "M", "柺"),
+        (0x2F8E0, "M", "枅"),
+        (0x2F8E1, "M", "桒"),
+        (0x2F8E2, "M", "梅"),
+        (0x2F8E3, "M", "𣑭"),
+        (0x2F8E4, "M", "梎"),
+        (0x2F8E5, "M", "栟"),
+        (0x2F8E6, "M", "椔"),
+        (0x2F8E7, "M", "㮝"),
+        (0x2F8E8, "M", "楂"),
+        (0x2F8E9, "M", "榣"),
+        (0x2F8EA, "M", "槪"),
+        (0x2F8EB, "M", "檨"),
+        (0x2F8EC, "M", "𣚣"),
+        (0x2F8ED, "M", "櫛"),
+        (0x2F8EE, "M", "㰘"),
+        (0x2F8EF, "M", "次"),
+        (0x2F8F0, "M", "𣢧"),
+        (0x2F8F1, "M", "歔"),
+        (0x2F8F2, "M", "㱎"),
+        (0x2F8F3, "M", "歲"),
+        (0x2F8F4, "M", "殟"),
+        (0x2F8F5, "M", "殺"),
+        (0x2F8F6, "M", "殻"),
+        (0x2F8F7, "M", "𣪍"),
+        (0x2F8F8, "M", "𡴋"),
+        (0x2F8F9, "M", "𣫺"),
+        (0x2F8FA, "M", "汎"),
+        (0x2F8FB, "M", "𣲼"),
+        (0x2F8FC, "M", "沿"),
+        (0x2F8FD, "M", "泍"),
+        (0x2F8FE, "M", "汧"),
+        (0x2F8FF, "M", "洖"),
+        (0x2F900, "M", "派"),
+        (0x2F901, "M", "海"),
+        (0x2F902, "M", "流"),
+        (0x2F903, "M", "浩"),
+        (0x2F904, "M", "浸"),
+        (0x2F905, "M", "涅"),
+        (0x2F906, "M", "𣴞"),
+        (0x2F907, "M", "洴"),
+        (0x2F908, "M", "港"),
+        (0x2F909, "M", "湮"),
+        (0x2F90A, "M", "㴳"),
+        (0x2F90B, "M", "滋"),
+        (0x2F90C, "M", "滇"),
+        (0x2F90D, "M", "𣻑"),
+        (0x2F90E, "M", "淹"),
+        (0x2F90F, "M", "潮"),
+        (0x2F910, "M", "𣽞"),
+        (0x2F911, "M", "𣾎"),
+        (0x2F912, "M", "濆"),
+        (0x2F913, "M", "瀹"),
+        (0x2F914, "M", "瀞"),
+        (0x2F915, "M", "瀛"),
+        (0x2F916, "M", "㶖"),
+        (0x2F917, "M", "灊"),
+        (0x2F918, "M", "災"),
+        (0x2F919, "M", "灷"),
+        (0x2F91A, "M", "炭"),
+        (0x2F91B, "M", "𠔥"),
+        (0x2F91C, "M", "煅"),
+        (0x2F91D, "M", "𤉣"),
+        (0x2F91E, "M", "熜"),
+        (0x2F91F, "M", "𤎫"),
+        (0x2F920, "M", "爨"),
+        (0x2F921, "M", "爵"),
+        (0x2F922, "M", "牐"),
+        (0x2F923, "M", "𤘈"),
+        (0x2F924, "M", "犀"),
+        (0x2F925, "M", "犕"),
+        (0x2F926, "M", "𤜵"),
+        (0x2F927, "M", "𤠔"),
+        (0x2F928, "M", "獺"),
+        (0x2F929, "M", "王"),
+        (0x2F92A, "M", "㺬"),
+        (0x2F92B, "M", "玥"),
+        (0x2F92C, "M", "㺸"),
+        (0x2F92E, "M", "瑇"),
+        (0x2F92F, "M", "瑜"),
+        (0x2F930, "M", "瑱"),
+        (0x2F931, "M", "璅"),
+        (0x2F932, "M", "瓊"),
+        (0x2F933, "M", "㼛"),
+        (0x2F934, "M", "甤"),
+        (0x2F935, "M", "𤰶"),
+        (0x2F936, "M", "甾"),
+        (0x2F937, "M", "𤲒"),
+        (0x2F938, "M", "異"),
+        (0x2F939, "M", "𢆟"),
+        (0x2F93A, "M", "瘐"),
+        (0x2F93B, "M", "𤾡"),
+        (0x2F93C, "M", "𤾸"),
+        (0x2F93D, "M", "𥁄"),
+        (0x2F93E, "M", "㿼"),
+        (0x2F93F, "M", "䀈"),
+        (0x2F940, "M", "直"),
+        (0x2F941, "M", "𥃳"),
+    ]
+
+
+def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F942, "M", "𥃲"),
+        (0x2F943, "M", "𥄙"),
+        (0x2F944, "M", "𥄳"),
+        (0x2F945, "M", "眞"),
+        (0x2F946, "M", "真"),
+        (0x2F948, "M", "睊"),
+        (0x2F949, "M", "䀹"),
+        (0x2F94A, "M", "瞋"),
+        (0x2F94B, "M", "䁆"),
+        (0x2F94C, "M", "䂖"),
+        (0x2F94D, "M", "𥐝"),
+        (0x2F94E, "M", "硎"),
+        (0x2F94F, "M", "碌"),
+        (0x2F950, "M", "磌"),
+        (0x2F951, "M", "䃣"),
+        (0x2F952, "M", "𥘦"),
+        (0x2F953, "M", "祖"),
+        (0x2F954, "M", "𥚚"),
+        (0x2F955, "M", "𥛅"),
+        (0x2F956, "M", "福"),
+        (0x2F957, "M", "秫"),
+        (0x2F958, "M", "䄯"),
+        (0x2F959, "M", "穀"),
+        (0x2F95A, "M", "穊"),
+        (0x2F95B, "M", "穏"),
+        (0x2F95C, "M", "𥥼"),
+        (0x2F95D, "M", "𥪧"),
+        (0x2F95F, "M", "竮"),
+        (0x2F960, "M", "䈂"),
+        (0x2F961, "M", "𥮫"),
+        (0x2F962, "M", "篆"),
+        (0x2F963, "M", "築"),
+        (0x2F964, "M", "䈧"),
+        (0x2F965, "M", "𥲀"),
+        (0x2F966, "M", "糒"),
+        (0x2F967, "M", "䊠"),
+        (0x2F968, "M", "糨"),
+        (0x2F969, "M", "糣"),
+        (0x2F96A, "M", "紀"),
+        (0x2F96B, "M", "𥾆"),
+        (0x2F96C, "M", "絣"),
+        (0x2F96D, "M", "䌁"),
+        (0x2F96E, "M", "緇"),
+        (0x2F96F, "M", "縂"),
+        (0x2F970, "M", "繅"),
+        (0x2F971, "M", "䌴"),
+        (0x2F972, "M", "𦈨"),
+        (0x2F973, "M", "𦉇"),
+        (0x2F974, "M", "䍙"),
+        (0x2F975, "M", "𦋙"),
+        (0x2F976, "M", "罺"),
+        (0x2F977, "M", "𦌾"),
+        (0x2F978, "M", "羕"),
+        (0x2F979, "M", "翺"),
+        (0x2F97A, "M", "者"),
+        (0x2F97B, "M", "𦓚"),
+        (0x2F97C, "M", "𦔣"),
+        (0x2F97D, "M", "聠"),
+        (0x2F97E, "M", "𦖨"),
+        (0x2F97F, "M", "聰"),
+        (0x2F980, "M", "𣍟"),
+        (0x2F981, "M", "䏕"),
+        (0x2F982, "M", "育"),
+        (0x2F983, "M", "脃"),
+        (0x2F984, "M", "䐋"),
+        (0x2F985, "M", "脾"),
+        (0x2F986, "M", "媵"),
+        (0x2F987, "M", "𦞧"),
+        (0x2F988, "M", "𦞵"),
+        (0x2F989, "M", "𣎓"),
+        (0x2F98A, "M", "𣎜"),
+        (0x2F98B, "M", "舁"),
+        (0x2F98C, "M", "舄"),
+        (0x2F98D, "M", "辞"),
+        (0x2F98E, "M", "䑫"),
+        (0x2F98F, "M", "芑"),
+        (0x2F990, "M", "芋"),
+        (0x2F991, "M", "芝"),
+        (0x2F992, "M", "劳"),
+        (0x2F993, "M", "花"),
+        (0x2F994, "M", "芳"),
+        (0x2F995, "M", "芽"),
+        (0x2F996, "M", "苦"),
+        (0x2F997, "M", "𦬼"),
+        (0x2F998, "M", "若"),
+        (0x2F999, "M", "茝"),
+        (0x2F99A, "M", "荣"),
+        (0x2F99B, "M", "莭"),
+        (0x2F99C, "M", "茣"),
+        (0x2F99D, "M", "莽"),
+        (0x2F99E, "M", "菧"),
+        (0x2F99F, "M", "著"),
+        (0x2F9A0, "M", "荓"),
+        (0x2F9A1, "M", "菊"),
+        (0x2F9A2, "M", "菌"),
+        (0x2F9A3, "M", "菜"),
+        (0x2F9A4, "M", "𦰶"),
+        (0x2F9A5, "M", "𦵫"),
+        (0x2F9A6, "M", "𦳕"),
+        (0x2F9A7, "M", "䔫"),
+    ]
+
+
+def _seg_82() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2F9A8, "M", "蓱"),
+        (0x2F9A9, "M", "蓳"),
+        (0x2F9AA, "M", "蔖"),
+        (0x2F9AB, "M", "𧏊"),
+        (0x2F9AC, "M", "蕤"),
+        (0x2F9AD, "M", "𦼬"),
+        (0x2F9AE, "M", "䕝"),
+        (0x2F9AF, "M", "䕡"),
+        (0x2F9B0, "M", "𦾱"),
+        (0x2F9B1, "M", "𧃒"),
+        (0x2F9B2, "M", "䕫"),
+        (0x2F9B3, "M", "虐"),
+        (0x2F9B4, "M", "虜"),
+        (0x2F9B5, "M", "虧"),
+        (0x2F9B6, "M", "虩"),
+        (0x2F9B7, "M", "蚩"),
+        (0x2F9B8, "M", "蚈"),
+        (0x2F9B9, "M", "蜎"),
+        (0x2F9BA, "M", "蛢"),
+        (0x2F9BB, "M", "蝹"),
+        (0x2F9BC, "M", "蜨"),
+        (0x2F9BD, "M", "蝫"),
+        (0x2F9BE, "M", "螆"),
+        (0x2F9BF, "M", "䗗"),
+        (0x2F9C0, "M", "蟡"),
+        (0x2F9C1, "M", "蠁"),
+        (0x2F9C2, "M", "䗹"),
+        (0x2F9C3, "M", "衠"),
+        (0x2F9C4, "M", "衣"),
+        (0x2F9C5, "M", "𧙧"),
+        (0x2F9C6, "M", "裗"),
+        (0x2F9C7, "M", "裞"),
+        (0x2F9C8, "M", "䘵"),
+        (0x2F9C9, "M", "裺"),
+        (0x2F9CA, "M", "㒻"),
+        (0x2F9CB, "M", "𧢮"),
+        (0x2F9CC, "M", "𧥦"),
+        (0x2F9CD, "M", "䚾"),
+        (0x2F9CE, "M", "䛇"),
+        (0x2F9CF, "M", "誠"),
+        (0x2F9D0, "M", "諭"),
+        (0x2F9D1, "M", "變"),
+        (0x2F9D2, "M", "豕"),
+        (0x2F9D3, "M", "𧲨"),
+        (0x2F9D4, "M", "貫"),
+        (0x2F9D5, "M", "賁"),
+        (0x2F9D6, "M", "贛"),
+        (0x2F9D7, "M", "起"),
+        (0x2F9D8, "M", "𧼯"),
+        (0x2F9D9, "M", "𠠄"),
+        (0x2F9DA, "M", "跋"),
+        (0x2F9DB, "M", "趼"),
+        (0x2F9DC, "M", "跰"),
+        (0x2F9DD, "M", "𠣞"),
+        (0x2F9DE, "M", "軔"),
+        (0x2F9DF, "M", "輸"),
+        (0x2F9E0, "M", "𨗒"),
+        (0x2F9E1, "M", "𨗭"),
+        (0x2F9E2, "M", "邔"),
+        (0x2F9E3, "M", "郱"),
+        (0x2F9E4, "M", "鄑"),
+        (0x2F9E5, "M", "𨜮"),
+        (0x2F9E6, "M", "鄛"),
+        (0x2F9E7, "M", "鈸"),
+        (0x2F9E8, "M", "鋗"),
+        (0x2F9E9, "M", "鋘"),
+        (0x2F9EA, "M", "鉼"),
+        (0x2F9EB, "M", "鏹"),
+        (0x2F9EC, "M", "鐕"),
+        (0x2F9ED, "M", "𨯺"),
+        (0x2F9EE, "M", "開"),
+        (0x2F9EF, "M", "䦕"),
+        (0x2F9F0, "M", "閷"),
+        (0x2F9F1, "M", "𨵷"),
+        (0x2F9F2, "M", "䧦"),
+        (0x2F9F3, "M", "雃"),
+        (0x2F9F4, "M", "嶲"),
+        (0x2F9F5, "M", "霣"),
+        (0x2F9F6, "M", "𩅅"),
+        (0x2F9F7, "M", "𩈚"),
+        (0x2F9F8, "M", "䩮"),
+        (0x2F9F9, "M", "䩶"),
+        (0x2F9FA, "M", "韠"),
+        (0x2F9FB, "M", "𩐊"),
+        (0x2F9FC, "M", "䪲"),
+        (0x2F9FD, "M", "𩒖"),
+        (0x2F9FE, "M", "頋"),
+        (0x2FA00, "M", "頩"),
+        (0x2FA01, "M", "𩖶"),
+        (0x2FA02, "M", "飢"),
+        (0x2FA03, "M", "䬳"),
+        (0x2FA04, "M", "餩"),
+        (0x2FA05, "M", "馧"),
+        (0x2FA06, "M", "駂"),
+        (0x2FA07, "M", "駾"),
+        (0x2FA08, "M", "䯎"),
+        (0x2FA09, "M", "𩬰"),
+        (0x2FA0A, "M", "鬒"),
+        (0x2FA0B, "M", "鱀"),
+        (0x2FA0C, "M", "鳽"),
+    ]
+
+
+def _seg_83() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+        (0x2FA0D, "M", "䳎"),
+        (0x2FA0E, "M", "䳭"),
+        (0x2FA0F, "M", "鵧"),
+        (0x2FA10, "M", "𪃎"),
+        (0x2FA11, "M", "䳸"),
+        (0x2FA12, "M", "𪄅"),
+        (0x2FA13, "M", "𪈎"),
+        (0x2FA14, "M", "𪊑"),
+        (0x2FA15, "M", "麻"),
+        (0x2FA16, "M", "䵖"),
+        (0x2FA17, "M", "黹"),
+        (0x2FA18, "M", "黾"),
+        (0x2FA19, "M", "鼅"),
+        (0x2FA1A, "M", "鼏"),
+        (0x2FA1B, "M", "鼖"),
+        (0x2FA1C, "M", "鼻"),
+        (0x2FA1D, "M", "𪘀"),
+        (0x2FA1E, "X"),
+        (0x30000, "V"),
+        (0x3134B, "X"),
+        (0x31350, "V"),
+        (0x323B0, "X"),
+        (0xE0100, "I"),
+        (0xE01F0, "X"),
+    ]
+
+
+uts46data = tuple(
+    _seg_0()
+    + _seg_1()
+    + _seg_2()
+    + _seg_3()
+    + _seg_4()
+    + _seg_5()
+    + _seg_6()
+    + _seg_7()
+    + _seg_8()
+    + _seg_9()
+    + _seg_10()
+    + _seg_11()
+    + _seg_12()
+    + _seg_13()
+    + _seg_14()
+    + _seg_15()
+    + _seg_16()
+    + _seg_17()
+    + _seg_18()
+    + _seg_19()
+    + _seg_20()
+    + _seg_21()
+    + _seg_22()
+    + _seg_23()
+    + _seg_24()
+    + _seg_25()
+    + _seg_26()
+    + _seg_27()
+    + _seg_28()
+    + _seg_29()
+    + _seg_30()
+    + _seg_31()
+    + _seg_32()
+    + _seg_33()
+    + _seg_34()
+    + _seg_35()
+    + _seg_36()
+    + _seg_37()
+    + _seg_38()
+    + _seg_39()
+    + _seg_40()
+    + _seg_41()
+    + _seg_42()
+    + _seg_43()
+    + _seg_44()
+    + _seg_45()
+    + _seg_46()
+    + _seg_47()
+    + _seg_48()
+    + _seg_49()
+    + _seg_50()
+    + _seg_51()
+    + _seg_52()
+    + _seg_53()
+    + _seg_54()
+    + _seg_55()
+    + _seg_56()
+    + _seg_57()
+    + _seg_58()
+    + _seg_59()
+    + _seg_60()
+    + _seg_61()
+    + _seg_62()
+    + _seg_63()
+    + _seg_64()
+    + _seg_65()
+    + _seg_66()
+    + _seg_67()
+    + _seg_68()
+    + _seg_69()
+    + _seg_70()
+    + _seg_71()
+    + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
+    + _seg_78()
+    + _seg_79()
+    + _seg_80()
+    + _seg_81()
+    + _seg_82()
+    + _seg_83()
+)  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/INSTALLER b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/METADATA b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/METADATA
new file mode 100644
index 0000000..ffef2ff
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/METADATA
@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: Jinja2
+Version: 3.1.6
+Summary: A very fast and expressive template engine.
+Maintainer-email: Pallets 
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Typing :: Typed
+License-File: LICENSE.txt
+Requires-Dist: MarkupSafe>=2.0
+Requires-Dist: Babel>=2.7 ; extra == "i18n"
+Project-URL: Changes, https://jinja.palletsprojects.com/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://jinja.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/jinja/
+Provides-Extra: i18n
+
+# Jinja
+
+Jinja is a fast, expressive, extensible templating engine. Special
+placeholders in the template allow writing code similar to Python
+syntax. Then the template is passed data to render the final document.
+
+It includes:
+
+-   Template inheritance and inclusion.
+-   Define and import macros within templates.
+-   HTML templates can use autoescaping to prevent XSS from untrusted
+    user input.
+-   A sandboxed environment can safely render untrusted templates.
+-   AsyncIO support for generating templates and calling async
+    functions.
+-   I18N support with Babel.
+-   Templates are compiled to optimized Python code just-in-time and
+    cached, or can be compiled ahead-of-time.
+-   Exceptions point to the correct line in templates to make debugging
+    easier.
+-   Extensible filters, tests, functions, and even syntax.
+
+Jinja's philosophy is that while application logic belongs in Python if
+possible, it shouldn't make the template designer's job difficult by
+restricting functionality too much.
+
+
+## In A Nutshell
+
+```jinja
+{% extends "base.html" %}
+{% block title %}Members{% endblock %}
+{% block content %}
+  
+{% endblock %}
+```
+
+## Donate
+
+The Pallets organization develops and supports Jinja and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, [please
+donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
+
+## Contributing
+
+See our [detailed contributing documentation][contrib] for many ways to
+contribute, including reporting issues, requesting features, asking or answering
+questions, and making PRs.
+
+[contrib]: https://palletsprojects.com/contributing/
+
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/RECORD b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/RECORD
new file mode 100644
index 0000000..be19bf4
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/RECORD
@@ -0,0 +1,58 @@
+jinja2-3.1.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+jinja2-3.1.6.dist-info/METADATA,sha256=aMVUj7Z8QTKhOJjZsx7FDGvqKr3ZFdkh8hQ1XDpkmcg,2871
+jinja2-3.1.6.dist-info/RECORD,,
+jinja2-3.1.6.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinja2-3.1.6.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+jinja2-3.1.6.dist-info/entry_points.txt,sha256=OL85gYU1eD8cuPlikifFngXpeBjaxl6rIJ8KkC_3r-I,58
+jinja2-3.1.6.dist-info/licenses/LICENSE.txt,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
+jinja2/__init__.py,sha256=xxepO9i7DHsqkQrgBEduLtfoz2QCuT6_gbL4XSN1hbU,1928
+jinja2/__pycache__/__init__.cpython-310.pyc,,
+jinja2/__pycache__/_identifier.cpython-310.pyc,,
+jinja2/__pycache__/async_utils.cpython-310.pyc,,
+jinja2/__pycache__/bccache.cpython-310.pyc,,
+jinja2/__pycache__/compiler.cpython-310.pyc,,
+jinja2/__pycache__/constants.cpython-310.pyc,,
+jinja2/__pycache__/debug.cpython-310.pyc,,
+jinja2/__pycache__/defaults.cpython-310.pyc,,
+jinja2/__pycache__/environment.cpython-310.pyc,,
+jinja2/__pycache__/exceptions.cpython-310.pyc,,
+jinja2/__pycache__/ext.cpython-310.pyc,,
+jinja2/__pycache__/filters.cpython-310.pyc,,
+jinja2/__pycache__/idtracking.cpython-310.pyc,,
+jinja2/__pycache__/lexer.cpython-310.pyc,,
+jinja2/__pycache__/loaders.cpython-310.pyc,,
+jinja2/__pycache__/meta.cpython-310.pyc,,
+jinja2/__pycache__/nativetypes.cpython-310.pyc,,
+jinja2/__pycache__/nodes.cpython-310.pyc,,
+jinja2/__pycache__/optimizer.cpython-310.pyc,,
+jinja2/__pycache__/parser.cpython-310.pyc,,
+jinja2/__pycache__/runtime.cpython-310.pyc,,
+jinja2/__pycache__/sandbox.cpython-310.pyc,,
+jinja2/__pycache__/tests.cpython-310.pyc,,
+jinja2/__pycache__/utils.cpython-310.pyc,,
+jinja2/__pycache__/visitor.cpython-310.pyc,,
+jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958
+jinja2/async_utils.py,sha256=vK-PdsuorOMnWSnEkT3iUJRIkTnYgO2T6MnGxDgHI5o,2834
+jinja2/bccache.py,sha256=gh0qs9rulnXo0PhX5jTJy2UHzI8wFnQ63o_vw7nhzRg,14061
+jinja2/compiler.py,sha256=9RpCQl5X88BHllJiPsHPh295Hh0uApvwFJNQuutULeM,74131
+jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433
+jinja2/debug.py,sha256=CnHqCDHd-BVGvti_8ZsTolnXNhA3ECsY-6n_2pwU8Hw,6297
+jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267
+jinja2/environment.py,sha256=9nhrP7Ch-NbGX00wvyr4yy-uhNHq2OCc60ggGrni_fk,61513
+jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071
+jinja2/ext.py,sha256=5PF5eHfh8mXAIxXHHRB2xXbXohi8pE3nHSOxa66uS7E,31875
+jinja2/filters.py,sha256=PQ_Egd9n9jSgtnGQYyF4K5j2nYwhUIulhPnyimkdr-k,55212
+jinja2/idtracking.py,sha256=-ll5lIp73pML3ErUYiIJj7tdmWxcH_IlDv3yA_hiZYo,10555
+jinja2/lexer.py,sha256=LYiYio6br-Tep9nPcupWXsPEtjluw3p1mU-lNBVRUfk,29786
+jinja2/loaders.py,sha256=wIrnxjvcbqh5VwW28NSkfotiDq8qNCxIOSFbGUiSLB4,24055
+jinja2/meta.py,sha256=OTDPkaFvU2Hgvx-6akz7154F8BIWaRmvJcBFvwopHww,4397
+jinja2/nativetypes.py,sha256=7GIGALVJgdyL80oZJdQUaUfwSt5q2lSSZbXt0dNf_M4,4210
+jinja2/nodes.py,sha256=m1Duzcr6qhZI8JQ6VyJgUNinjAf5bQzijSmDnMsvUx8,34579
+jinja2/optimizer.py,sha256=rJnCRlQ7pZsEEmMhsQDgC_pKyDHxP5TPS6zVPGsgcu8,1651
+jinja2/parser.py,sha256=lLOFy3sEmHc5IaEHRiH1sQVnId2moUQzhyeJZTtdY30,40383
+jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinja2/runtime.py,sha256=gDk-GvdriJXqgsGbHgrcKTP0Yp6zPXzhzrIpCFH3jAU,34249
+jinja2/sandbox.py,sha256=Mw2aitlY2I8la7FYhcX2YG9BtUYcLnD0Gh3d29cDWrY,15009
+jinja2/tests.py,sha256=VLsBhVFnWg-PxSBz1MhRnNWgP1ovXk3neO1FLQMeC9Q,5926
+jinja2/utils.py,sha256=rRp3o9e7ZKS4fyrWRbELyLcpuGVTFcnooaOa1qx_FIk,24129
+jinja2/visitor.py,sha256=EcnL1PIwf_4RVCOMxsRNuR8AXHbS1qfAdMOE2ngKJz4,3557
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/REQUESTED b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/WHEEL b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/WHEEL
new file mode 100644
index 0000000..23d2d7e
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.11.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/entry_points.txt b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/entry_points.txt
new file mode 100644
index 0000000..abc3eae
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[babel.extractors]
+jinja2=jinja2.ext:babel_extract[i18n]
+
diff --git a/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt
new file mode 100644
index 0000000..c37cae4
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2-3.1.6.dist-info/licenses/LICENSE.txt
@@ -0,0 +1,28 @@
+Copyright 2007 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__init__.py b/.venv/lib/python3.10/site-packages/jinja2/__init__.py
new file mode 100644
index 0000000..1a423a3
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/__init__.py
@@ -0,0 +1,38 @@
+"""Jinja is a template engine written in pure Python. It provides a
+non-XML syntax that supports inline expressions and an optional
+sandboxed environment.
+"""
+
+from .bccache import BytecodeCache as BytecodeCache
+from .bccache import FileSystemBytecodeCache as FileSystemBytecodeCache
+from .bccache import MemcachedBytecodeCache as MemcachedBytecodeCache
+from .environment import Environment as Environment
+from .environment import Template as Template
+from .exceptions import TemplateAssertionError as TemplateAssertionError
+from .exceptions import TemplateError as TemplateError
+from .exceptions import TemplateNotFound as TemplateNotFound
+from .exceptions import TemplateRuntimeError as TemplateRuntimeError
+from .exceptions import TemplatesNotFound as TemplatesNotFound
+from .exceptions import TemplateSyntaxError as TemplateSyntaxError
+from .exceptions import UndefinedError as UndefinedError
+from .loaders import BaseLoader as BaseLoader
+from .loaders import ChoiceLoader as ChoiceLoader
+from .loaders import DictLoader as DictLoader
+from .loaders import FileSystemLoader as FileSystemLoader
+from .loaders import FunctionLoader as FunctionLoader
+from .loaders import ModuleLoader as ModuleLoader
+from .loaders import PackageLoader as PackageLoader
+from .loaders import PrefixLoader as PrefixLoader
+from .runtime import ChainableUndefined as ChainableUndefined
+from .runtime import DebugUndefined as DebugUndefined
+from .runtime import make_logging_undefined as make_logging_undefined
+from .runtime import StrictUndefined as StrictUndefined
+from .runtime import Undefined as Undefined
+from .utils import clear_caches as clear_caches
+from .utils import is_undefined as is_undefined
+from .utils import pass_context as pass_context
+from .utils import pass_environment as pass_environment
+from .utils import pass_eval_context as pass_eval_context
+from .utils import select_autoescape as select_autoescape
+
+__version__ = "3.1.6"
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/__init__.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000..8e234be
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/__init__.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/_identifier.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/_identifier.cpython-310.pyc
new file mode 100644
index 0000000..cbcf95a
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/_identifier.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/async_utils.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/async_utils.cpython-310.pyc
new file mode 100644
index 0000000..770776d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/async_utils.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/bccache.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/bccache.cpython-310.pyc
new file mode 100644
index 0000000..8ba8188
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/bccache.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/compiler.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/compiler.cpython-310.pyc
new file mode 100644
index 0000000..51b1bf3
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/compiler.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/constants.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/constants.cpython-310.pyc
new file mode 100644
index 0000000..7d6180d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/constants.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/debug.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/debug.cpython-310.pyc
new file mode 100644
index 0000000..9f2c32d
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/debug.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/defaults.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/defaults.cpython-310.pyc
new file mode 100644
index 0000000..05d1493
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/defaults.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/environment.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/environment.cpython-310.pyc
new file mode 100644
index 0000000..660c83f
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/environment.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/exceptions.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000..12f6dad
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/exceptions.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/ext.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/ext.cpython-310.pyc
new file mode 100644
index 0000000..8e89eb7
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/ext.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/filters.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/filters.cpython-310.pyc
new file mode 100644
index 0000000..0641268
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/filters.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/idtracking.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/idtracking.cpython-310.pyc
new file mode 100644
index 0000000..a0fcd8e
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/idtracking.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/lexer.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/lexer.cpython-310.pyc
new file mode 100644
index 0000000..35581ff
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/lexer.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/loaders.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/loaders.cpython-310.pyc
new file mode 100644
index 0000000..6c221a5
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/loaders.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/meta.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/meta.cpython-310.pyc
new file mode 100644
index 0000000..a30dc86
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/meta.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nativetypes.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nativetypes.cpython-310.pyc
new file mode 100644
index 0000000..59f0e95
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nativetypes.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nodes.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nodes.cpython-310.pyc
new file mode 100644
index 0000000..820585b
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/nodes.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/optimizer.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/optimizer.cpython-310.pyc
new file mode 100644
index 0000000..a0580e0
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/optimizer.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/parser.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/parser.cpython-310.pyc
new file mode 100644
index 0000000..45c4b5f
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/parser.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/runtime.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/runtime.cpython-310.pyc
new file mode 100644
index 0000000..42e1572
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/runtime.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/sandbox.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/sandbox.cpython-310.pyc
new file mode 100644
index 0000000..6f14770
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/sandbox.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/tests.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/tests.cpython-310.pyc
new file mode 100644
index 0000000..543a389
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/tests.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/utils.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000..074c437
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/utils.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/__pycache__/visitor.cpython-310.pyc b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/visitor.cpython-310.pyc
new file mode 100644
index 0000000..b3455b8
Binary files /dev/null and b/.venv/lib/python3.10/site-packages/jinja2/__pycache__/visitor.cpython-310.pyc differ
diff --git a/.venv/lib/python3.10/site-packages/jinja2/_identifier.py b/.venv/lib/python3.10/site-packages/jinja2/_identifier.py
new file mode 100644
index 0000000..928c150
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/_identifier.py
@@ -0,0 +1,6 @@
+import re
+
+# generated by scripts/generate_identifier_pattern.py
+pattern = re.compile(
+    r"[\w·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-ٰٟۖ-ۜ۟-۪ۤۧۨ-ܑۭܰ-݊ަ-ް߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛࣓-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣঁ-ঃ়া-ৄেৈো-্ৗৢৣ৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑੰੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣஂா-ூெ-ைொ-்ௗఀ-ఄా-ౄె-ైొ-్ౕౖౢౣಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣංඃ්ා-ුූෘ-ෟෲෳัิ-ฺ็-๎ັິ-ູົຼ່-ໍ༹༘༙༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏႚ-ႝ፝-፟ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝᠋-᠍ᢅᢆᢩᤠ-ᤫᤰ-᤻ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼᪰-᪽ᬀ-ᬄ᬴-᭄᭫-᭳ᮀ-ᮂᮡ-ᮭ᯦-᯳ᰤ-᰷᳐-᳔᳒-᳨᳭ᳲ-᳴᳷-᳹᷀-᷹᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰℘℮⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣠-꣱ꣿꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀ꧥꨩ-ꨶꩃꩌꩍꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭ﬞ︀-️︠-︯︳︴﹍-﹏＿𐇽𐋠𐍶-𐍺𐨁-𐨃𐨅𐨆𐨌-𐨏𐨸-𐨿𐨺𐫦𐫥𐴤-𐽆𐴧-𐽐𑀀-𑀂𑀸-𑁆𑁿-𑂂𑂰-𑂺𑄀-𑄂𑄧-𑄴𑅅𑅆𑅳𑆀-𑆂𑆳-𑇀𑇉-𑇌𑈬-𑈷𑈾𑋟-𑋪𑌀-𑌃𑌻𑌼𑌾-𑍄𑍇𑍈𑍋-𑍍𑍗𑍢𑍣𑍦-𑍬𑍰-𑍴𑐵-𑑆𑑞𑒰-𑓃𑖯-𑖵𑖸-𑗀𑗜𑗝𑘰-𑙀𑚫-𑚷𑜝-𑜫𑠬-𑠺𑨁-𑨊𑨳-𑨹𑨻-𑨾𑩇𑩑-𑩛𑪊-𑪙𑰯-𑰶𑰸-𑰿𑲒-𑲧𑲩-𑲶𑴱-𑴶𑴺𑴼𑴽𑴿-𑵅𑵇𑶊-𑶎𑶐𑶑𑶓-𑶗𑻳-𑻶𖫰-𖫴𖬰-𖬶𖽑-𖽾𖾏-𖾒𛲝𛲞𝅥-𝅩𝅭-𝅲𝅻-𝆂𝆅-𝆋𝆪-𝆭𝉂-𝉄𝨀-𝨶𝨻-𝩬𝩵𝪄𝪛-𝪟𝪡-𝪯𞀀-𞀆𞀈-𞀘𞀛-𞀡𞀣𞀤𞀦-𞣐𞀪-𞣖𞥄-𞥊󠄀-󠇯]+"  # noqa: B950
+)
diff --git a/.venv/lib/python3.10/site-packages/jinja2/async_utils.py b/.venv/lib/python3.10/site-packages/jinja2/async_utils.py
new file mode 100644
index 0000000..f0c1402
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/async_utils.py
@@ -0,0 +1,99 @@
+import inspect
+import typing as t
+from functools import WRAPPER_ASSIGNMENTS
+from functools import wraps
+
+from .utils import _PassArg
+from .utils import pass_eval_context
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+V = t.TypeVar("V")
+
+
+def async_variant(normal_func):  # type: ignore
+    def decorator(async_func):  # type: ignore
+        pass_arg = _PassArg.from_obj(normal_func)
+        need_eval_context = pass_arg is None
+
+        if pass_arg is _PassArg.environment:
+
+            def is_async(args: t.Any) -> bool:
+                return t.cast(bool, args[0].is_async)
+
+        else:
+
+            def is_async(args: t.Any) -> bool:
+                return t.cast(bool, args[0].environment.is_async)
+
+        # Take the doc and annotations from the sync function, but the
+        # name from the async function. Pallets-Sphinx-Themes
+        # build_function_directive expects __wrapped__ to point to the
+        # sync function.
+        async_func_attrs = ("__module__", "__name__", "__qualname__")
+        normal_func_attrs = tuple(set(WRAPPER_ASSIGNMENTS).difference(async_func_attrs))
+
+        @wraps(normal_func, assigned=normal_func_attrs)
+        @wraps(async_func, assigned=async_func_attrs, updated=())
+        def wrapper(*args, **kwargs):  # type: ignore
+            b = is_async(args)
+
+            if need_eval_context:
+                args = args[1:]
+
+            if b:
+                return async_func(*args, **kwargs)
+
+            return normal_func(*args, **kwargs)
+
+        if need_eval_context:
+            wrapper = pass_eval_context(wrapper)
+
+        wrapper.jinja_async_variant = True  # type: ignore[attr-defined]
+        return wrapper
+
+    return decorator
+
+
+_common_primitives = {int, float, bool, str, list, dict, tuple, type(None)}
+
+
+async def auto_await(value: t.Union[t.Awaitable["V"], "V"]) -> "V":
+    # Avoid a costly call to isawaitable
+    if type(value) in _common_primitives:
+        return t.cast("V", value)
+
+    if inspect.isawaitable(value):
+        return await t.cast("t.Awaitable[V]", value)
+
+    return value
+
+
+class _IteratorToAsyncIterator(t.Generic[V]):
+    def __init__(self, iterator: "t.Iterator[V]"):
+        self._iterator = iterator
+
+    def __aiter__(self) -> "te.Self":
+        return self
+
+    async def __anext__(self) -> V:
+        try:
+            return next(self._iterator)
+        except StopIteration as e:
+            raise StopAsyncIteration(e.value) from e
+
+
+def auto_aiter(
+    iterable: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+) -> "t.AsyncIterator[V]":
+    if hasattr(iterable, "__aiter__"):
+        return iterable.__aiter__()
+    else:
+        return _IteratorToAsyncIterator(iter(iterable))
+
+
+async def auto_to_list(
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+) -> t.List["V"]:
+    return [x async for x in auto_aiter(value)]
diff --git a/.venv/lib/python3.10/site-packages/jinja2/bccache.py b/.venv/lib/python3.10/site-packages/jinja2/bccache.py
new file mode 100644
index 0000000..ada8b09
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/bccache.py
@@ -0,0 +1,408 @@
+"""The optional bytecode cache system. This is useful if you have very
+complex template situations and the compilation of all those templates
+slows down your application too much.
+
+Situations where this is useful are often forking web applications that
+are initialized on the first request.
+"""
+
+import errno
+import fnmatch
+import marshal
+import os
+import pickle
+import stat
+import sys
+import tempfile
+import typing as t
+from hashlib import sha1
+from io import BytesIO
+from types import CodeType
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .environment import Environment
+
+    class _MemcachedClient(te.Protocol):
+        def get(self, key: str) -> bytes: ...
+
+        def set(
+            self, key: str, value: bytes, timeout: t.Optional[int] = None
+        ) -> None: ...
+
+
+bc_version = 5
+# Magic bytes to identify Jinja bytecode cache files. Contains the
+# Python major and minor version to avoid loading incompatible bytecode
+# if a project upgrades its Python version.
+bc_magic = (
+    b"j2"
+    + pickle.dumps(bc_version, 2)
+    + pickle.dumps((sys.version_info[0] << 24) | sys.version_info[1], 2)
+)
+
+
+class Bucket:
+    """Buckets are used to store the bytecode for one template.  It's created
+    and initialized by the bytecode cache and passed to the loading functions.
+
+    The buckets get an internal checksum from the cache assigned and use this
+    to automatically reject outdated cache material.  Individual bytecode
+    cache subclasses don't have to care about cache invalidation.
+    """
+
+    def __init__(self, environment: "Environment", key: str, checksum: str) -> None:
+        self.environment = environment
+        self.key = key
+        self.checksum = checksum
+        self.reset()
+
+    def reset(self) -> None:
+        """Resets the bucket (unloads the bytecode)."""
+        self.code: t.Optional[CodeType] = None
+
+    def load_bytecode(self, f: t.BinaryIO) -> None:
+        """Loads bytecode from a file or file like object."""
+        # make sure the magic header is correct
+        magic = f.read(len(bc_magic))
+        if magic != bc_magic:
+            self.reset()
+            return
+        # the source code of the file changed, we need to reload
+        checksum = pickle.load(f)
+        if self.checksum != checksum:
+            self.reset()
+            return
+        # if marshal_load fails then we need to reload
+        try:
+            self.code = marshal.load(f)
+        except (EOFError, ValueError, TypeError):
+            self.reset()
+            return
+
+    def write_bytecode(self, f: t.IO[bytes]) -> None:
+        """Dump the bytecode into the file or file like object passed."""
+        if self.code is None:
+            raise TypeError("can't write empty bucket")
+        f.write(bc_magic)
+        pickle.dump(self.checksum, f, 2)
+        marshal.dump(self.code, f)
+
+    def bytecode_from_string(self, string: bytes) -> None:
+        """Load bytecode from bytes."""
+        self.load_bytecode(BytesIO(string))
+
+    def bytecode_to_string(self) -> bytes:
+        """Return the bytecode as bytes."""
+        out = BytesIO()
+        self.write_bytecode(out)
+        return out.getvalue()
+
+
+class BytecodeCache:
+    """To implement your own bytecode cache you have to subclass this class
+    and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of
+    these methods are passed a :class:`~jinja2.bccache.Bucket`.
+
+    A very basic bytecode cache that saves the bytecode on the file system::
+
+        from os import path
+
+        class MyCache(BytecodeCache):
+
+            def __init__(self, directory):
+                self.directory = directory
+
+            def load_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                if path.exists(filename):
+                    with open(filename, 'rb') as f:
+                        bucket.load_bytecode(f)
+
+            def dump_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                with open(filename, 'wb') as f:
+                    bucket.write_bytecode(f)
+
+    A more advanced version of a filesystem based bytecode cache is part of
+    Jinja.
+    """
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        """Subclasses have to override this method to load bytecode into a
+        bucket.  If they are not able to find code in the cache for the
+        bucket, it must not do anything.
+        """
+        raise NotImplementedError()
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        """Subclasses have to override this method to write the bytecode
+        from a bucket back to the cache.  If it unable to do so it must not
+        fail silently but raise an exception.
+        """
+        raise NotImplementedError()
+
+    def clear(self) -> None:
+        """Clears the cache.  This method is not used by Jinja but should be
+        implemented to allow applications to clear the bytecode cache used
+        by a particular environment.
+        """
+
+    def get_cache_key(
+        self, name: str, filename: t.Optional[t.Union[str]] = None
+    ) -> str:
+        """Returns the unique hash key for this template name."""
+        hash = sha1(name.encode("utf-8"))
+
+        if filename is not None:
+            hash.update(f"|{filename}".encode())
+
+        return hash.hexdigest()
+
+    def get_source_checksum(self, source: str) -> str:
+        """Returns a checksum for the source."""
+        return sha1(source.encode("utf-8")).hexdigest()
+
+    def get_bucket(
+        self,
+        environment: "Environment",
+        name: str,
+        filename: t.Optional[str],
+        source: str,
+    ) -> Bucket:
+        """Return a cache bucket for the given template.  All arguments are
+        mandatory but filename may be `None`.
+        """
+        key = self.get_cache_key(name, filename)
+        checksum = self.get_source_checksum(source)
+        bucket = Bucket(environment, key, checksum)
+        self.load_bytecode(bucket)
+        return bucket
+
+    def set_bucket(self, bucket: Bucket) -> None:
+        """Put the bucket into the cache."""
+        self.dump_bytecode(bucket)
+
+
+class FileSystemBytecodeCache(BytecodeCache):
+    """A bytecode cache that stores bytecode on the filesystem.  It accepts
+    two arguments: The directory where the cache items are stored and a
+    pattern string that is used to build the filename.
+
+    If no directory is specified a default cache directory is selected.  On
+    Windows the user's temp directory is used, on UNIX systems a directory
+    is created for the user in the system temp directory.
+
+    The pattern can be used to have multiple separate caches operate on the
+    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
+    is replaced with the cache key.
+
+    >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
+
+    This bytecode cache supports clearing of the cache using the clear method.
+    """
+
+    def __init__(
+        self, directory: t.Optional[str] = None, pattern: str = "__jinja2_%s.cache"
+    ) -> None:
+        if directory is None:
+            directory = self._get_default_cache_dir()
+        self.directory = directory
+        self.pattern = pattern
+
+    def _get_default_cache_dir(self) -> str:
+        def _unsafe_dir() -> "te.NoReturn":
+            raise RuntimeError(
+                "Cannot determine safe temp directory.  You "
+                "need to explicitly provide one."
+            )
+
+        tmpdir = tempfile.gettempdir()
+
+        # On windows the temporary directory is used specific unless
+        # explicitly forced otherwise.  We can just use that.
+        if os.name == "nt":
+            return tmpdir
+        if not hasattr(os, "getuid"):
+            _unsafe_dir()
+
+        dirname = f"_jinja2-cache-{os.getuid()}"
+        actual_dir = os.path.join(tmpdir, dirname)
+
+        try:
+            os.mkdir(actual_dir, stat.S_IRWXU)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        try:
+            os.chmod(actual_dir, stat.S_IRWXU)
+            actual_dir_stat = os.lstat(actual_dir)
+            if (
+                actual_dir_stat.st_uid != os.getuid()
+                or not stat.S_ISDIR(actual_dir_stat.st_mode)
+                or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
+            ):
+                _unsafe_dir()
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        actual_dir_stat = os.lstat(actual_dir)
+        if (
+            actual_dir_stat.st_uid != os.getuid()
+            or not stat.S_ISDIR(actual_dir_stat.st_mode)
+            or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
+        ):
+            _unsafe_dir()
+
+        return actual_dir
+
+    def _get_cache_filename(self, bucket: Bucket) -> str:
+        return os.path.join(self.directory, self.pattern % (bucket.key,))
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        filename = self._get_cache_filename(bucket)
+
+        # Don't test for existence before opening the file, since the
+        # file could disappear after the test before the open.
+        try:
+            f = open(filename, "rb")
+        except (FileNotFoundError, IsADirectoryError, PermissionError):
+            # PermissionError can occur on Windows when an operation is
+            # in progress, such as calling clear().
+            return
+
+        with f:
+            bucket.load_bytecode(f)
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        # Write to a temporary file, then rename to the real name after
+        # writing. This avoids another process reading the file before
+        # it is fully written.
+        name = self._get_cache_filename(bucket)
+        f = tempfile.NamedTemporaryFile(
+            mode="wb",
+            dir=os.path.dirname(name),
+            prefix=os.path.basename(name),
+            suffix=".tmp",
+            delete=False,
+        )
+
+        def remove_silent() -> None:
+            try:
+                os.remove(f.name)
+            except OSError:
+                # Another process may have called clear(). On Windows,
+                # another program may be holding the file open.
+                pass
+
+        try:
+            with f:
+                bucket.write_bytecode(f)
+        except BaseException:
+            remove_silent()
+            raise
+
+        try:
+            os.replace(f.name, name)
+        except OSError:
+            # Another process may have called clear(). On Windows,
+            # another program may be holding the file open.
+            remove_silent()
+        except BaseException:
+            remove_silent()
+            raise
+
+    def clear(self) -> None:
+        # imported lazily here because google app-engine doesn't support
+        # write access on the file system and the function does not exist
+        # normally.
+        from os import remove
+
+        files = fnmatch.filter(os.listdir(self.directory), self.pattern % ("*",))
+        for filename in files:
+            try:
+                remove(os.path.join(self.directory, filename))
+            except OSError:
+                pass
+
+
+class MemcachedBytecodeCache(BytecodeCache):
+    """This class implements a bytecode cache that uses a memcache cache for
+    storing the information.  It does not enforce a specific memcache library
+    (tummy's memcache or cmemcache) but will accept any class that provides
+    the minimal interface required.
+
+    Libraries compatible with this class:
+
+    -   `cachelib `_
+    -   `python-memcached `_
+
+    (Unfortunately the django cache interface is not compatible because it
+    does not support storing binary data, only text. You can however pass
+    the underlying cache client to the bytecode cache which is available
+    as `django.core.cache.cache._client`.)
+
+    The minimal interface for the client passed to the constructor is this:
+
+    .. class:: MinimalClientInterface
+
+        .. method:: set(key, value[, timeout])
+
+            Stores the bytecode in the cache.  `value` is a string and
+            `timeout` the timeout of the key.  If timeout is not provided
+            a default timeout or no timeout should be assumed, if it's
+            provided it's an integer with the number of seconds the cache
+            item should exist.
+
+        .. method:: get(key)
+
+            Returns the value for the cache key.  If the item does not
+            exist in the cache the return value must be `None`.
+
+    The other arguments to the constructor are the prefix for all keys that
+    is added before the actual cache key and the timeout for the bytecode in
+    the cache system.  We recommend a high (or no) timeout.
+
+    This bytecode cache does not support clearing of used items in the cache.
+    The clear method is a no-operation function.
+
+    .. versionadded:: 2.7
+       Added support for ignoring memcache errors through the
+       `ignore_memcache_errors` parameter.
+    """
+
+    def __init__(
+        self,
+        client: "_MemcachedClient",
+        prefix: str = "jinja2/bytecode/",
+        timeout: t.Optional[int] = None,
+        ignore_memcache_errors: bool = True,
+    ):
+        self.client = client
+        self.prefix = prefix
+        self.timeout = timeout
+        self.ignore_memcache_errors = ignore_memcache_errors
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        try:
+            code = self.client.get(self.prefix + bucket.key)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise
+        else:
+            bucket.bytecode_from_string(code)
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        key = self.prefix + bucket.key
+        value = bucket.bytecode_to_string()
+
+        try:
+            if self.timeout is not None:
+                self.client.set(key, value, self.timeout)
+            else:
+                self.client.set(key, value)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise
diff --git a/.venv/lib/python3.10/site-packages/jinja2/compiler.py b/.venv/lib/python3.10/site-packages/jinja2/compiler.py
new file mode 100644
index 0000000..a4ff6a1
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/compiler.py
@@ -0,0 +1,1998 @@
+"""Compiles nodes from the parser into Python code."""
+
+import typing as t
+from contextlib import contextmanager
+from functools import update_wrapper
+from io import StringIO
+from itertools import chain
+from keyword import iskeyword as is_python_keyword
+
+from markupsafe import escape
+from markupsafe import Markup
+
+from . import nodes
+from .exceptions import TemplateAssertionError
+from .idtracking import Symbols
+from .idtracking import VAR_LOAD_ALIAS
+from .idtracking import VAR_LOAD_PARAMETER
+from .idtracking import VAR_LOAD_RESOLVE
+from .idtracking import VAR_LOAD_UNDEFINED
+from .nodes import EvalContext
+from .optimizer import Optimizer
+from .utils import _PassArg
+from .utils import concat
+from .visitor import NodeVisitor
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .environment import Environment
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+operators = {
+    "eq": "==",
+    "ne": "!=",
+    "gt": ">",
+    "gteq": ">=",
+    "lt": "<",
+    "lteq": "<=",
+    "in": "in",
+    "notin": "not in",
+}
+
+
+def optimizeconst(f: F) -> F:
+    def new_func(
+        self: "CodeGenerator", node: nodes.Expr, frame: "Frame", **kwargs: t.Any
+    ) -> t.Any:
+        # Only optimize if the frame is not volatile
+        if self.optimizer is not None and not frame.eval_ctx.volatile:
+            new_node = self.optimizer.visit(node, frame.eval_ctx)
+
+            if new_node != node:
+                return self.visit(new_node, frame)
+
+        return f(self, node, frame, **kwargs)
+
+    return update_wrapper(new_func, f)  # type: ignore[return-value]
+
+
+def _make_binop(op: str) -> t.Callable[["CodeGenerator", nodes.BinExpr, "Frame"], None]:
+    @optimizeconst
+    def visitor(self: "CodeGenerator", node: nodes.BinExpr, frame: Frame) -> None:
+        if (
+            self.environment.sandboxed and op in self.environment.intercepted_binops  # type: ignore
+        ):
+            self.write(f"environment.call_binop(context, {op!r}, ")
+            self.visit(node.left, frame)
+            self.write(", ")
+            self.visit(node.right, frame)
+        else:
+            self.write("(")
+            self.visit(node.left, frame)
+            self.write(f" {op} ")
+            self.visit(node.right, frame)
+
+        self.write(")")
+
+    return visitor
+
+
+def _make_unop(
+    op: str,
+) -> t.Callable[["CodeGenerator", nodes.UnaryExpr, "Frame"], None]:
+    @optimizeconst
+    def visitor(self: "CodeGenerator", node: nodes.UnaryExpr, frame: Frame) -> None:
+        if (
+            self.environment.sandboxed and op in self.environment.intercepted_unops  # type: ignore
+        ):
+            self.write(f"environment.call_unop(context, {op!r}, ")
+            self.visit(node.node, frame)
+        else:
+            self.write("(" + op)
+            self.visit(node.node, frame)
+
+        self.write(")")
+
+    return visitor
+
+
+def generate(
+    node: nodes.Template,
+    environment: "Environment",
+    name: t.Optional[str],
+    filename: t.Optional[str],
+    stream: t.Optional[t.TextIO] = None,
+    defer_init: bool = False,
+    optimized: bool = True,
+) -> t.Optional[str]:
+    """Generate the python source for a node tree."""
+    if not isinstance(node, nodes.Template):
+        raise TypeError("Can't compile non template nodes")
+
+    generator = environment.code_generator_class(
+        environment, name, filename, stream, defer_init, optimized
+    )
+    generator.visit(node)
+
+    if stream is None:
+        return generator.stream.getvalue()  # type: ignore
+
+    return None
+
+
+def has_safe_repr(value: t.Any) -> bool:
+    """Does the node have a safe representation?"""
+    if value is None or value is NotImplemented or value is Ellipsis:
+        return True
+
+    if type(value) in {bool, int, float, complex, range, str, Markup}:
+        return True
+
+    if type(value) in {tuple, list, set, frozenset}:
+        return all(has_safe_repr(v) for v in value)
+
+    if type(value) is dict:  # noqa E721
+        return all(has_safe_repr(k) and has_safe_repr(v) for k, v in value.items())
+
+    return False
+
+
+def find_undeclared(
+    nodes: t.Iterable[nodes.Node], names: t.Iterable[str]
+) -> t.Set[str]:
+    """Check if the names passed are accessed undeclared.  The return value
+    is a set of all the undeclared names from the sequence of names found.
+    """
+    visitor = UndeclaredNameVisitor(names)
+    try:
+        for node in nodes:
+            visitor.visit(node)
+    except VisitorExit:
+        pass
+    return visitor.undeclared
+
+
+class MacroRef:
+    def __init__(self, node: t.Union[nodes.Macro, nodes.CallBlock]) -> None:
+        self.node = node
+        self.accesses_caller = False
+        self.accesses_kwargs = False
+        self.accesses_varargs = False
+
+
+class Frame:
+    """Holds compile time information for us."""
+
+    def __init__(
+        self,
+        eval_ctx: EvalContext,
+        parent: t.Optional["Frame"] = None,
+        level: t.Optional[int] = None,
+    ) -> None:
+        self.eval_ctx = eval_ctx
+
+        # the parent of this frame
+        self.parent = parent
+
+        if parent is None:
+            self.symbols = Symbols(level=level)
+
+            # in some dynamic inheritance situations the compiler needs to add
+            # write tests around output statements.
+            self.require_output_check = False
+
+            # inside some tags we are using a buffer rather than yield statements.
+            # this for example affects {% filter %} or {% macro %}.  If a frame
+            # is buffered this variable points to the name of the list used as
+            # buffer.
+            self.buffer: t.Optional[str] = None
+
+            # the name of the block we're in, otherwise None.
+            self.block: t.Optional[str] = None
+
+        else:
+            self.symbols = Symbols(parent.symbols, level=level)
+            self.require_output_check = parent.require_output_check
+            self.buffer = parent.buffer
+            self.block = parent.block
+
+        # a toplevel frame is the root + soft frames such as if conditions.
+        self.toplevel = False
+
+        # the root frame is basically just the outermost frame, so no if
+        # conditions.  This information is used to optimize inheritance
+        # situations.
+        self.rootlevel = False
+
+        # variables set inside of loops and blocks should not affect outer frames,
+        # but they still needs to be kept track of as part of the active context.
+        self.loop_frame = False
+        self.block_frame = False
+
+        # track whether the frame is being used in an if-statement or conditional
+        # expression as it determines which errors should be raised during runtime
+        # or compile time.
+        self.soft_frame = False
+
+    def copy(self) -> "te.Self":
+        """Create a copy of the current one."""
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.symbols = self.symbols.copy()
+        return rv
+
+    def inner(self, isolated: bool = False) -> "Frame":
+        """Return an inner frame."""
+        if isolated:
+            return Frame(self.eval_ctx, level=self.symbols.level + 1)
+        return Frame(self.eval_ctx, self)
+
+    def soft(self) -> "te.Self":
+        """Return a soft frame.  A soft frame may not be modified as
+        standalone thing as it shares the resources with the frame it
+        was created of, but it's not a rootlevel frame any longer.
+
+        This is only used to implement if-statements and conditional
+        expressions.
+        """
+        rv = self.copy()
+        rv.rootlevel = False
+        rv.soft_frame = True
+        return rv
+
+    __copy__ = copy
+
+
+class VisitorExit(RuntimeError):
+    """Exception used by the `UndeclaredNameVisitor` to signal a stop."""
+
+
+class DependencyFinderVisitor(NodeVisitor):
+    """A visitor that collects filter and test calls."""
+
+    def __init__(self) -> None:
+        self.filters: t.Set[str] = set()
+        self.tests: t.Set[str] = set()
+
+    def visit_Filter(self, node: nodes.Filter) -> None:
+        self.generic_visit(node)
+        self.filters.add(node.name)
+
+    def visit_Test(self, node: nodes.Test) -> None:
+        self.generic_visit(node)
+        self.tests.add(node.name)
+
+    def visit_Block(self, node: nodes.Block) -> None:
+        """Stop visiting at blocks."""
+
+
+class UndeclaredNameVisitor(NodeVisitor):
+    """A visitor that checks if a name is accessed without being
+    declared.  This is different from the frame visitor as it will
+    not stop at closure frames.
+    """
+
+    def __init__(self, names: t.Iterable[str]) -> None:
+        self.names = set(names)
+        self.undeclared: t.Set[str] = set()
+
+    def visit_Name(self, node: nodes.Name) -> None:
+        if node.ctx == "load" and node.name in self.names:
+            self.undeclared.add(node.name)
+            if self.undeclared == self.names:
+                raise VisitorExit()
+        else:
+            self.names.discard(node.name)
+
+    def visit_Block(self, node: nodes.Block) -> None:
+        """Stop visiting a blocks."""
+
+
+class CompilerExit(Exception):
+    """Raised if the compiler encountered a situation where it just
+    doesn't make sense to further process the code.  Any block that
+    raises such an exception is not further processed.
+    """
+
+
+class CodeGenerator(NodeVisitor):
+    def __init__(
+        self,
+        environment: "Environment",
+        name: t.Optional[str],
+        filename: t.Optional[str],
+        stream: t.Optional[t.TextIO] = None,
+        defer_init: bool = False,
+        optimized: bool = True,
+    ) -> None:
+        if stream is None:
+            stream = StringIO()
+        self.environment = environment
+        self.name = name
+        self.filename = filename
+        self.stream = stream
+        self.created_block_context = False
+        self.defer_init = defer_init
+        self.optimizer: t.Optional[Optimizer] = None
+
+        if optimized:
+            self.optimizer = Optimizer(environment)
+
+        # aliases for imports
+        self.import_aliases: t.Dict[str, str] = {}
+
+        # a registry for all blocks.  Because blocks are moved out
+        # into the global python scope they are registered here
+        self.blocks: t.Dict[str, nodes.Block] = {}
+
+        # the number of extends statements so far
+        self.extends_so_far = 0
+
+        # some templates have a rootlevel extends.  In this case we
+        # can safely assume that we're a child template and do some
+        # more optimizations.
+        self.has_known_extends = False
+
+        # the current line number
+        self.code_lineno = 1
+
+        # registry of all filters and tests (global, not block local)
+        self.tests: t.Dict[str, str] = {}
+        self.filters: t.Dict[str, str] = {}
+
+        # the debug information
+        self.debug_info: t.List[t.Tuple[int, int]] = []
+        self._write_debug_info: t.Optional[int] = None
+
+        # the number of new lines before the next write()
+        self._new_lines = 0
+
+        # the line number of the last written statement
+        self._last_line = 0
+
+        # true if nothing was written so far.
+        self._first_write = True
+
+        # used by the `temporary_identifier` method to get new
+        # unique, temporary identifier
+        self._last_identifier = 0
+
+        # the current indentation
+        self._indentation = 0
+
+        # Tracks toplevel assignments
+        self._assign_stack: t.List[t.Set[str]] = []
+
+        # Tracks parameter definition blocks
+        self._param_def_block: t.List[t.Set[str]] = []
+
+        # Tracks the current context.
+        self._context_reference_stack = ["context"]
+
+    @property
+    def optimized(self) -> bool:
+        return self.optimizer is not None
+
+    # -- Various compilation helpers
+
+    def fail(self, msg: str, lineno: int) -> "te.NoReturn":
+        """Fail with a :exc:`TemplateAssertionError`."""
+        raise TemplateAssertionError(msg, lineno, self.name, self.filename)
+
+    def temporary_identifier(self) -> str:
+        """Get a new unique identifier."""
+        self._last_identifier += 1
+        return f"t_{self._last_identifier}"
+
+    def buffer(self, frame: Frame) -> None:
+        """Enable buffering for the frame from that point onwards."""
+        frame.buffer = self.temporary_identifier()
+        self.writeline(f"{frame.buffer} = []")
+
+    def return_buffer_contents(
+        self, frame: Frame, force_unescaped: bool = False
+    ) -> None:
+        """Return the buffer contents of the frame."""
+        if not force_unescaped:
+            if frame.eval_ctx.volatile:
+                self.writeline("if context.eval_ctx.autoescape:")
+                self.indent()
+                self.writeline(f"return Markup(concat({frame.buffer}))")
+                self.outdent()
+                self.writeline("else:")
+                self.indent()
+                self.writeline(f"return concat({frame.buffer})")
+                self.outdent()
+                return
+            elif frame.eval_ctx.autoescape:
+                self.writeline(f"return Markup(concat({frame.buffer}))")
+                return
+        self.writeline(f"return concat({frame.buffer})")
+
+    def indent(self) -> None:
+        """Indent by one."""
+        self._indentation += 1
+
+    def outdent(self, step: int = 1) -> None:
+        """Outdent by step."""
+        self._indentation -= step
+
+    def start_write(self, frame: Frame, node: t.Optional[nodes.Node] = None) -> None:
+        """Yield or write into the frame buffer."""
+        if frame.buffer is None:
+            self.writeline("yield ", node)
+        else:
+            self.writeline(f"{frame.buffer}.append(", node)
+
+    def end_write(self, frame: Frame) -> None:
+        """End the writing process started by `start_write`."""
+        if frame.buffer is not None:
+            self.write(")")
+
+    def simple_write(
+        self, s: str, frame: Frame, node: t.Optional[nodes.Node] = None
+    ) -> None:
+        """Simple shortcut for start_write + write + end_write."""
+        self.start_write(frame, node)
+        self.write(s)
+        self.end_write(frame)
+
+    def blockvisit(self, nodes: t.Iterable[nodes.Node], frame: Frame) -> None:
+        """Visit a list of nodes as block in a frame.  If the current frame
+        is no buffer a dummy ``if 0: yield None`` is written automatically.
+        """
+        try:
+            self.writeline("pass")
+            for node in nodes:
+                self.visit(node, frame)
+        except CompilerExit:
+            pass
+
+    def write(self, x: str) -> None:
+        """Write a string into the output stream."""
+        if self._new_lines:
+            if not self._first_write:
+                self.stream.write("\n" * self._new_lines)
+                self.code_lineno += self._new_lines
+                if self._write_debug_info is not None:
+                    self.debug_info.append((self._write_debug_info, self.code_lineno))
+                    self._write_debug_info = None
+            self._first_write = False
+            self.stream.write("    " * self._indentation)
+            self._new_lines = 0
+        self.stream.write(x)
+
+    def writeline(
+        self, x: str, node: t.Optional[nodes.Node] = None, extra: int = 0
+    ) -> None:
+        """Combination of newline and write."""
+        self.newline(node, extra)
+        self.write(x)
+
+    def newline(self, node: t.Optional[nodes.Node] = None, extra: int = 0) -> None:
+        """Add one or more newlines before the next write."""
+        self._new_lines = max(self._new_lines, 1 + extra)
+        if node is not None and node.lineno != self._last_line:
+            self._write_debug_info = node.lineno
+            self._last_line = node.lineno
+
+    def signature(
+        self,
+        node: t.Union[nodes.Call, nodes.Filter, nodes.Test],
+        frame: Frame,
+        extra_kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+    ) -> None:
+        """Writes a function call to the stream for the current node.
+        A leading comma is added automatically.  The extra keyword
+        arguments may not include python keywords otherwise a syntax
+        error could occur.  The extra keyword arguments should be given
+        as python dict.
+        """
+        # if any of the given keyword arguments is a python keyword
+        # we have to make sure that no invalid call is created.
+        kwarg_workaround = any(
+            is_python_keyword(t.cast(str, k))
+            for k in chain((x.key for x in node.kwargs), extra_kwargs or ())
+        )
+
+        for arg in node.args:
+            self.write(", ")
+            self.visit(arg, frame)
+
+        if not kwarg_workaround:
+            for kwarg in node.kwargs:
+                self.write(", ")
+                self.visit(kwarg, frame)
+            if extra_kwargs is not None:
+                for key, value in extra_kwargs.items():
+                    self.write(f", {key}={value}")
+        if node.dyn_args:
+            self.write(", *")
+            self.visit(node.dyn_args, frame)
+
+        if kwarg_workaround:
+            if node.dyn_kwargs is not None:
+                self.write(", **dict({")
+            else:
+                self.write(", **{")
+            for kwarg in node.kwargs:
+                self.write(f"{kwarg.key!r}: ")
+                self.visit(kwarg.value, frame)
+                self.write(", ")
+            if extra_kwargs is not None:
+                for key, value in extra_kwargs.items():
+                    self.write(f"{key!r}: {value}, ")
+            if node.dyn_kwargs is not None:
+                self.write("}, **")
+                self.visit(node.dyn_kwargs, frame)
+                self.write(")")
+            else:
+                self.write("}")
+
+        elif node.dyn_kwargs is not None:
+            self.write(", **")
+            self.visit(node.dyn_kwargs, frame)
+
+    def pull_dependencies(self, nodes: t.Iterable[nodes.Node]) -> None:
+        """Find all filter and test names used in the template and
+        assign them to variables in the compiled namespace. Checking
+        that the names are registered with the environment is done when
+        compiling the Filter and Test nodes. If the node is in an If or
+        CondExpr node, the check is done at runtime instead.
+
+        .. versionchanged:: 3.0
+            Filters and tests in If and CondExpr nodes are checked at
+            runtime instead of compile time.
+        """
+        visitor = DependencyFinderVisitor()
+
+        for node in nodes:
+            visitor.visit(node)
+
+        for id_map, names, dependency in (
+            (self.filters, visitor.filters, "filters"),
+            (
+                self.tests,
+                visitor.tests,
+                "tests",
+            ),
+        ):
+            for name in sorted(names):
+                if name not in id_map:
+                    id_map[name] = self.temporary_identifier()
+
+                # add check during runtime that dependencies used inside of executed
+                # blocks are defined, as this step may be skipped during compile time
+                self.writeline("try:")
+                self.indent()
+                self.writeline(f"{id_map[name]} = environment.{dependency}[{name!r}]")
+                self.outdent()
+                self.writeline("except KeyError:")
+                self.indent()
+                self.writeline("@internalcode")
+                self.writeline(f"def {id_map[name]}(*unused):")
+                self.indent()
+                self.writeline(
+                    f'raise TemplateRuntimeError("No {dependency[:-1]}'
+                    f' named {name!r} found.")'
+                )
+                self.outdent()
+                self.outdent()
+
+    def enter_frame(self, frame: Frame) -> None:
+        undefs = []
+        for target, (action, param) in frame.symbols.loads.items():
+            if action == VAR_LOAD_PARAMETER:
+                pass
+            elif action == VAR_LOAD_RESOLVE:
+                self.writeline(f"{target} = {self.get_resolve_func()}({param!r})")
+            elif action == VAR_LOAD_ALIAS:
+                self.writeline(f"{target} = {param}")
+            elif action == VAR_LOAD_UNDEFINED:
+                undefs.append(target)
+            else:
+                raise NotImplementedError("unknown load instruction")
+        if undefs:
+            self.writeline(f"{' = '.join(undefs)} = missing")
+
+    def leave_frame(self, frame: Frame, with_python_scope: bool = False) -> None:
+        if not with_python_scope:
+            undefs = []
+            for target in frame.symbols.loads:
+                undefs.append(target)
+            if undefs:
+                self.writeline(f"{' = '.join(undefs)} = missing")
+
+    def choose_async(self, async_value: str = "async ", sync_value: str = "") -> str:
+        return async_value if self.environment.is_async else sync_value
+
+    def func(self, name: str) -> str:
+        return f"{self.choose_async()}def {name}"
+
+    def macro_body(
+        self, node: t.Union[nodes.Macro, nodes.CallBlock], frame: Frame
+    ) -> t.Tuple[Frame, MacroRef]:
+        """Dump the function def of a macro or call block."""
+        frame = frame.inner()
+        frame.symbols.analyze_node(node)
+        macro_ref = MacroRef(node)
+
+        explicit_caller = None
+        skip_special_params = set()
+        args = []
+
+        for idx, arg in enumerate(node.args):
+            if arg.name == "caller":
+                explicit_caller = idx
+            if arg.name in ("kwargs", "varargs"):
+                skip_special_params.add(arg.name)
+            args.append(frame.symbols.ref(arg.name))
+
+        undeclared = find_undeclared(node.body, ("caller", "kwargs", "varargs"))
+
+        if "caller" in undeclared:
+            # In older Jinja versions there was a bug that allowed caller
+            # to retain the special behavior even if it was mentioned in
+            # the argument list.  However thankfully this was only really
+            # working if it was the last argument.  So we are explicitly
+            # checking this now and error out if it is anywhere else in
+            # the argument list.
+            if explicit_caller is not None:
+                try:
+                    node.defaults[explicit_caller - len(node.args)]
+                except IndexError:
+                    self.fail(
+                        "When defining macros or call blocks the "
+                        'special "caller" argument must be omitted '
+                        "or be given a default.",
+                        node.lineno,
+                    )
+            else:
+                args.append(frame.symbols.declare_parameter("caller"))
+            macro_ref.accesses_caller = True
+        if "kwargs" in undeclared and "kwargs" not in skip_special_params:
+            args.append(frame.symbols.declare_parameter("kwargs"))
+            macro_ref.accesses_kwargs = True
+        if "varargs" in undeclared and "varargs" not in skip_special_params:
+            args.append(frame.symbols.declare_parameter("varargs"))
+            macro_ref.accesses_varargs = True
+
+        # macros are delayed, they never require output checks
+        frame.require_output_check = False
+        frame.symbols.analyze_node(node)
+        self.writeline(f"{self.func('macro')}({', '.join(args)}):", node)
+        self.indent()
+
+        self.buffer(frame)
+        self.enter_frame(frame)
+
+        self.push_parameter_definitions(frame)
+        for idx, arg in enumerate(node.args):
+            ref = frame.symbols.ref(arg.name)
+            self.writeline(f"if {ref} is missing:")
+            self.indent()
+            try:
+                default = node.defaults[idx - len(node.args)]
+            except IndexError:
+                self.writeline(
+                    f'{ref} = undefined("parameter {arg.name!r} was not provided",'
+                    f" name={arg.name!r})"
+                )
+            else:
+                self.writeline(f"{ref} = ")
+                self.visit(default, frame)
+            self.mark_parameter_stored(ref)
+            self.outdent()
+        self.pop_parameter_definitions()
+
+        self.blockvisit(node.body, frame)
+        self.return_buffer_contents(frame, force_unescaped=True)
+        self.leave_frame(frame, with_python_scope=True)
+        self.outdent()
+
+        return frame, macro_ref
+
+    def macro_def(self, macro_ref: MacroRef, frame: Frame) -> None:
+        """Dump the macro definition for the def created by macro_body."""
+        arg_tuple = ", ".join(repr(x.name) for x in macro_ref.node.args)
+        name = getattr(macro_ref.node, "name", None)
+        if len(macro_ref.node.args) == 1:
+            arg_tuple += ","
+        self.write(
+            f"Macro(environment, macro, {name!r}, ({arg_tuple}),"
+            f" {macro_ref.accesses_kwargs!r}, {macro_ref.accesses_varargs!r},"
+            f" {macro_ref.accesses_caller!r}, context.eval_ctx.autoescape)"
+        )
+
+    def position(self, node: nodes.Node) -> str:
+        """Return a human readable position for the node."""
+        rv = f"line {node.lineno}"
+        if self.name is not None:
+            rv = f"{rv} in {self.name!r}"
+        return rv
+
+    def dump_local_context(self, frame: Frame) -> str:
+        items_kv = ", ".join(
+            f"{name!r}: {target}"
+            for name, target in frame.symbols.dump_stores().items()
+        )
+        return f"{{{items_kv}}}"
+
+    def write_commons(self) -> None:
+        """Writes a common preamble that is used by root and block functions.
+        Primarily this sets up common local helpers and enforces a generator
+        through a dead branch.
+        """
+        self.writeline("resolve = context.resolve_or_missing")
+        self.writeline("undefined = environment.undefined")
+        self.writeline("concat = environment.concat")
+        # always use the standard Undefined class for the implicit else of
+        # conditional expressions
+        self.writeline("cond_expr_undefined = Undefined")
+        self.writeline("if 0: yield None")
+
+    def push_parameter_definitions(self, frame: Frame) -> None:
+        """Pushes all parameter targets from the given frame into a local
+        stack that permits tracking of yet to be assigned parameters.  In
+        particular this enables the optimization from `visit_Name` to skip
+        undefined expressions for parameters in macros as macros can reference
+        otherwise unbound parameters.
+        """
+        self._param_def_block.append(frame.symbols.dump_param_targets())
+
+    def pop_parameter_definitions(self) -> None:
+        """Pops the current parameter definitions set."""
+        self._param_def_block.pop()
+
+    def mark_parameter_stored(self, target: str) -> None:
+        """Marks a parameter in the current parameter definitions as stored.
+        This will skip the enforced undefined checks.
+        """
+        if self._param_def_block:
+            self._param_def_block[-1].discard(target)
+
+    def push_context_reference(self, target: str) -> None:
+        self._context_reference_stack.append(target)
+
+    def pop_context_reference(self) -> None:
+        self._context_reference_stack.pop()
+
+    def get_context_ref(self) -> str:
+        return self._context_reference_stack[-1]
+
+    def get_resolve_func(self) -> str:
+        target = self._context_reference_stack[-1]
+        if target == "context":
+            return "resolve"
+        return f"{target}.resolve"
+
+    def derive_context(self, frame: Frame) -> str:
+        return f"{self.get_context_ref()}.derived({self.dump_local_context(frame)})"
+
+    def parameter_is_undeclared(self, target: str) -> bool:
+        """Checks if a given target is an undeclared parameter."""
+        if not self._param_def_block:
+            return False
+        return target in self._param_def_block[-1]
+
+    def push_assign_tracking(self) -> None:
+        """Pushes a new layer for assignment tracking."""
+        self._assign_stack.append(set())
+
+    def pop_assign_tracking(self, frame: Frame) -> None:
+        """Pops the topmost level for assignment tracking and updates the
+        context variables if necessary.
+        """
+        vars = self._assign_stack.pop()
+        if (
+            not frame.block_frame
+            and not frame.loop_frame
+            and not frame.toplevel
+            or not vars
+        ):
+            return
+        public_names = [x for x in vars if x[:1] != "_"]
+        if len(vars) == 1:
+            name = next(iter(vars))
+            ref = frame.symbols.ref(name)
+            if frame.loop_frame:
+                self.writeline(f"_loop_vars[{name!r}] = {ref}")
+                return
+            if frame.block_frame:
+                self.writeline(f"_block_vars[{name!r}] = {ref}")
+                return
+            self.writeline(f"context.vars[{name!r}] = {ref}")
+        else:
+            if frame.loop_frame:
+                self.writeline("_loop_vars.update({")
+            elif frame.block_frame:
+                self.writeline("_block_vars.update({")
+            else:
+                self.writeline("context.vars.update({")
+            for idx, name in enumerate(sorted(vars)):
+                if idx:
+                    self.write(", ")
+                ref = frame.symbols.ref(name)
+                self.write(f"{name!r}: {ref}")
+            self.write("})")
+        if not frame.block_frame and not frame.loop_frame and public_names:
+            if len(public_names) == 1:
+                self.writeline(f"context.exported_vars.add({public_names[0]!r})")
+            else:
+                names_str = ", ".join(map(repr, sorted(public_names)))
+                self.writeline(f"context.exported_vars.update(({names_str}))")
+
+    # -- Statement Visitors
+
+    def visit_Template(
+        self, node: nodes.Template, frame: t.Optional[Frame] = None
+    ) -> None:
+        assert frame is None, "no root frame allowed"
+        eval_ctx = EvalContext(self.environment, self.name)
+
+        from .runtime import async_exported
+        from .runtime import exported
+
+        if self.environment.is_async:
+            exported_names = sorted(exported + async_exported)
+        else:
+            exported_names = sorted(exported)
+
+        self.writeline("from jinja2.runtime import " + ", ".join(exported_names))
+
+        # if we want a deferred initialization we cannot move the
+        # environment into a local name
+        envenv = "" if self.defer_init else ", environment=environment"
+
+        # do we have an extends tag at all?  If not, we can save some
+        # overhead by just not processing any inheritance code.
+        have_extends = node.find(nodes.Extends) is not None
+
+        # find all blocks
+        for block in node.find_all(nodes.Block):
+            if block.name in self.blocks:
+                self.fail(f"block {block.name!r} defined twice", block.lineno)
+            self.blocks[block.name] = block
+
+        # find all imports and import them
+        for import_ in node.find_all(nodes.ImportedName):
+            if import_.importname not in self.import_aliases:
+                imp = import_.importname
+                self.import_aliases[imp] = alias = self.temporary_identifier()
+                if "." in imp:
+                    module, obj = imp.rsplit(".", 1)
+                    self.writeline(f"from {module} import {obj} as {alias}")
+                else:
+                    self.writeline(f"import {imp} as {alias}")
+
+        # add the load name
+        self.writeline(f"name = {self.name!r}")
+
+        # generate the root render function.
+        self.writeline(
+            f"{self.func('root')}(context, missing=missing{envenv}):", extra=1
+        )
+        self.indent()
+        self.write_commons()
+
+        # process the root
+        frame = Frame(eval_ctx)
+        if "self" in find_undeclared(node.body, ("self",)):
+            ref = frame.symbols.declare_parameter("self")
+            self.writeline(f"{ref} = TemplateReference(context)")
+        frame.symbols.analyze_node(node)
+        frame.toplevel = frame.rootlevel = True
+        frame.require_output_check = have_extends and not self.has_known_extends
+        if have_extends:
+            self.writeline("parent_template = None")
+        self.enter_frame(frame)
+        self.pull_dependencies(node.body)
+        self.blockvisit(node.body, frame)
+        self.leave_frame(frame, with_python_scope=True)
+        self.outdent()
+
+        # make sure that the parent root is called.
+        if have_extends:
+            if not self.has_known_extends:
+                self.indent()
+                self.writeline("if parent_template is not None:")
+            self.indent()
+            if not self.environment.is_async:
+                self.writeline("yield from parent_template.root_render_func(context)")
+            else:
+                self.writeline("agen = parent_template.root_render_func(context)")
+                self.writeline("try:")
+                self.indent()
+                self.writeline("async for event in agen:")
+                self.indent()
+                self.writeline("yield event")
+                self.outdent()
+                self.outdent()
+                self.writeline("finally: await agen.aclose()")
+            self.outdent(1 + (not self.has_known_extends))
+
+        # at this point we now have the blocks collected and can visit them too.
+        for name, block in self.blocks.items():
+            self.writeline(
+                f"{self.func('block_' + name)}(context, missing=missing{envenv}):",
+                block,
+                1,
+            )
+            self.indent()
+            self.write_commons()
+            # It's important that we do not make this frame a child of the
+            # toplevel template.  This would cause a variety of
+            # interesting issues with identifier tracking.
+            block_frame = Frame(eval_ctx)
+            block_frame.block_frame = True
+            undeclared = find_undeclared(block.body, ("self", "super"))
+            if "self" in undeclared:
+                ref = block_frame.symbols.declare_parameter("self")
+                self.writeline(f"{ref} = TemplateReference(context)")
+            if "super" in undeclared:
+                ref = block_frame.symbols.declare_parameter("super")
+                self.writeline(f"{ref} = context.super({name!r}, block_{name})")
+            block_frame.symbols.analyze_node(block)
+            block_frame.block = name
+            self.writeline("_block_vars = {}")
+            self.enter_frame(block_frame)
+            self.pull_dependencies(block.body)
+            self.blockvisit(block.body, block_frame)
+            self.leave_frame(block_frame, with_python_scope=True)
+            self.outdent()
+
+        blocks_kv_str = ", ".join(f"{x!r}: block_{x}" for x in self.blocks)
+        self.writeline(f"blocks = {{{blocks_kv_str}}}", extra=1)
+        debug_kv_str = "&".join(f"{k}={v}" for k, v in self.debug_info)
+        self.writeline(f"debug_info = {debug_kv_str!r}")
+
+    def visit_Block(self, node: nodes.Block, frame: Frame) -> None:
+        """Call a block and register it for the template."""
+        level = 0
+        if frame.toplevel:
+            # if we know that we are a child template, there is no need to
+            # check if we are one
+            if self.has_known_extends:
+                return
+            if self.extends_so_far > 0:
+                self.writeline("if parent_template is None:")
+                self.indent()
+                level += 1
+
+        if node.scoped:
+            context = self.derive_context(frame)
+        else:
+            context = self.get_context_ref()
+
+        if node.required:
+            self.writeline(f"if len(context.blocks[{node.name!r}]) <= 1:", node)
+            self.indent()
+            self.writeline(
+                f'raise TemplateRuntimeError("Required block {node.name!r} not found")',
+                node,
+            )
+            self.outdent()
+
+        if not self.environment.is_async and frame.buffer is None:
+            self.writeline(
+                f"yield from context.blocks[{node.name!r}][0]({context})", node
+            )
+        else:
+            self.writeline(f"gen = context.blocks[{node.name!r}][0]({context})")
+            self.writeline("try:")
+            self.indent()
+            self.writeline(
+                f"{self.choose_async()}for event in gen:",
+                node,
+            )
+            self.indent()
+            self.simple_write("event", frame)
+            self.outdent()
+            self.outdent()
+            self.writeline(
+                f"finally: {self.choose_async('await gen.aclose()', 'gen.close()')}"
+            )
+
+        self.outdent(level)
+
+    def visit_Extends(self, node: nodes.Extends, frame: Frame) -> None:
+        """Calls the extender."""
+        if not frame.toplevel:
+            self.fail("cannot use extend from a non top-level scope", node.lineno)
+
+        # if the number of extends statements in general is zero so
+        # far, we don't have to add a check if something extended
+        # the template before this one.
+        if self.extends_so_far > 0:
+            # if we have a known extends we just add a template runtime
+            # error into the generated code.  We could catch that at compile
+            # time too, but i welcome it not to confuse users by throwing the
+            # same error at different times just "because we can".
+            if not self.has_known_extends:
+                self.writeline("if parent_template is not None:")
+                self.indent()
+            self.writeline('raise TemplateRuntimeError("extended multiple times")')
+
+            # if we have a known extends already we don't need that code here
+            # as we know that the template execution will end here.
+            if self.has_known_extends:
+                raise CompilerExit()
+            else:
+                self.outdent()
+
+        self.writeline("parent_template = environment.get_template(", node)
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r})")
+        self.writeline("for name, parent_block in parent_template.blocks.items():")
+        self.indent()
+        self.writeline("context.blocks.setdefault(name, []).append(parent_block)")
+        self.outdent()
+
+        # if this extends statement was in the root level we can take
+        # advantage of that information and simplify the generated code
+        # in the top level from this point onwards
+        if frame.rootlevel:
+            self.has_known_extends = True
+
+        # and now we have one more
+        self.extends_so_far += 1
+
+    def visit_Include(self, node: nodes.Include, frame: Frame) -> None:
+        """Handles includes."""
+        if node.ignore_missing:
+            self.writeline("try:")
+            self.indent()
+
+        func_name = "get_or_select_template"
+        if isinstance(node.template, nodes.Const):
+            if isinstance(node.template.value, str):
+                func_name = "get_template"
+            elif isinstance(node.template.value, (tuple, list)):
+                func_name = "select_template"
+        elif isinstance(node.template, (nodes.Tuple, nodes.List)):
+            func_name = "select_template"
+
+        self.writeline(f"template = environment.{func_name}(", node)
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r})")
+        if node.ignore_missing:
+            self.outdent()
+            self.writeline("except TemplateNotFound:")
+            self.indent()
+            self.writeline("pass")
+            self.outdent()
+            self.writeline("else:")
+            self.indent()
+
+        def loop_body() -> None:
+            self.indent()
+            self.simple_write("event", frame)
+            self.outdent()
+
+        if node.with_context:
+            self.writeline(
+                f"gen = template.root_render_func("
+                "template.new_context(context.get_all(), True,"
+                f" {self.dump_local_context(frame)}))"
+            )
+            self.writeline("try:")
+            self.indent()
+            self.writeline(f"{self.choose_async()}for event in gen:")
+            loop_body()
+            self.outdent()
+            self.writeline(
+                f"finally: {self.choose_async('await gen.aclose()', 'gen.close()')}"
+            )
+        elif self.environment.is_async:
+            self.writeline(
+                "for event in (await template._get_default_module_async())"
+                "._body_stream:"
+            )
+            loop_body()
+        else:
+            self.writeline("yield from template._get_default_module()._body_stream")
+
+        if node.ignore_missing:
+            self.outdent()
+
+    def _import_common(
+        self, node: t.Union[nodes.Import, nodes.FromImport], frame: Frame
+    ) -> None:
+        self.write(f"{self.choose_async('await ')}environment.get_template(")
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r}).")
+
+        if node.with_context:
+            f_name = f"make_module{self.choose_async('_async')}"
+            self.write(
+                f"{f_name}(context.get_all(), True, {self.dump_local_context(frame)})"
+            )
+        else:
+            self.write(f"_get_default_module{self.choose_async('_async')}(context)")
+
+    def visit_Import(self, node: nodes.Import, frame: Frame) -> None:
+        """Visit regular imports."""
+        self.writeline(f"{frame.symbols.ref(node.target)} = ", node)
+        if frame.toplevel:
+            self.write(f"context.vars[{node.target!r}] = ")
+
+        self._import_common(node, frame)
+
+        if frame.toplevel and not node.target.startswith("_"):
+            self.writeline(f"context.exported_vars.discard({node.target!r})")
+
+    def visit_FromImport(self, node: nodes.FromImport, frame: Frame) -> None:
+        """Visit named imports."""
+        self.newline(node)
+        self.write("included_template = ")
+        self._import_common(node, frame)
+        var_names = []
+        discarded_names = []
+        for name in node.names:
+            if isinstance(name, tuple):
+                name, alias = name
+            else:
+                alias = name
+            self.writeline(
+                f"{frame.symbols.ref(alias)} ="
+                f" getattr(included_template, {name!r}, missing)"
+            )
+            self.writeline(f"if {frame.symbols.ref(alias)} is missing:")
+            self.indent()
+            # The position will contain the template name, and will be formatted
+            # into a string that will be compiled into an f-string. Curly braces
+            # in the name must be replaced with escapes so that they will not be
+            # executed as part of the f-string.
+            position = self.position(node).replace("{", "{{").replace("}", "}}")
+            message = (
+                "the template {included_template.__name__!r}"
+                f" (imported on {position})"
+                f" does not export the requested name {name!r}"
+            )
+            self.writeline(
+                f"{frame.symbols.ref(alias)} = undefined(f{message!r}, name={name!r})"
+            )
+            self.outdent()
+            if frame.toplevel:
+                var_names.append(alias)
+                if not alias.startswith("_"):
+                    discarded_names.append(alias)
+
+        if var_names:
+            if len(var_names) == 1:
+                name = var_names[0]
+                self.writeline(f"context.vars[{name!r}] = {frame.symbols.ref(name)}")
+            else:
+                names_kv = ", ".join(
+                    f"{name!r}: {frame.symbols.ref(name)}" for name in var_names
+                )
+                self.writeline(f"context.vars.update({{{names_kv}}})")
+        if discarded_names:
+            if len(discarded_names) == 1:
+                self.writeline(f"context.exported_vars.discard({discarded_names[0]!r})")
+            else:
+                names_str = ", ".join(map(repr, discarded_names))
+                self.writeline(
+                    f"context.exported_vars.difference_update(({names_str}))"
+                )
+
+    def visit_For(self, node: nodes.For, frame: Frame) -> None:
+        loop_frame = frame.inner()
+        loop_frame.loop_frame = True
+        test_frame = frame.inner()
+        else_frame = frame.inner()
+
+        # try to figure out if we have an extended loop.  An extended loop
+        # is necessary if the loop is in recursive mode if the special loop
+        # variable is accessed in the body if the body is a scoped block.
+        extended_loop = (
+            node.recursive
+            or "loop"
+            in find_undeclared(node.iter_child_nodes(only=("body",)), ("loop",))
+            or any(block.scoped for block in node.find_all(nodes.Block))
+        )
+
+        loop_ref = None
+        if extended_loop:
+            loop_ref = loop_frame.symbols.declare_parameter("loop")
+
+        loop_frame.symbols.analyze_node(node, for_branch="body")
+        if node.else_:
+            else_frame.symbols.analyze_node(node, for_branch="else")
+
+        if node.test:
+            loop_filter_func = self.temporary_identifier()
+            test_frame.symbols.analyze_node(node, for_branch="test")
+            self.writeline(f"{self.func(loop_filter_func)}(fiter):", node.test)
+            self.indent()
+            self.enter_frame(test_frame)
+            self.writeline(self.choose_async("async for ", "for "))
+            self.visit(node.target, loop_frame)
+            self.write(" in ")
+            self.write(self.choose_async("auto_aiter(fiter)", "fiter"))
+            self.write(":")
+            self.indent()
+            self.writeline("if ", node.test)
+            self.visit(node.test, test_frame)
+            self.write(":")
+            self.indent()
+            self.writeline("yield ")
+            self.visit(node.target, loop_frame)
+            self.outdent(3)
+            self.leave_frame(test_frame, with_python_scope=True)
+
+        # if we don't have an recursive loop we have to find the shadowed
+        # variables at that point.  Because loops can be nested but the loop
+        # variable is a special one we have to enforce aliasing for it.
+        if node.recursive:
+            self.writeline(
+                f"{self.func('loop')}(reciter, loop_render_func, depth=0):", node
+            )
+            self.indent()
+            self.buffer(loop_frame)
+
+            # Use the same buffer for the else frame
+            else_frame.buffer = loop_frame.buffer
+
+        # make sure the loop variable is a special one and raise a template
+        # assertion error if a loop tries to write to loop
+        if extended_loop:
+            self.writeline(f"{loop_ref} = missing")
+
+        for name in node.find_all(nodes.Name):
+            if name.ctx == "store" and name.name == "loop":
+                self.fail(
+                    "Can't assign to special loop variable in for-loop target",
+                    name.lineno,
+                )
+
+        if node.else_:
+            iteration_indicator = self.temporary_identifier()
+            self.writeline(f"{iteration_indicator} = 1")
+
+        self.writeline(self.choose_async("async for ", "for "), node)
+        self.visit(node.target, loop_frame)
+        if extended_loop:
+            self.write(f", {loop_ref} in {self.choose_async('Async')}LoopContext(")
+        else:
+            self.write(" in ")
+
+        if node.test:
+            self.write(f"{loop_filter_func}(")
+        if node.recursive:
+            self.write("reciter")
+        else:
+            if self.environment.is_async and not extended_loop:
+                self.write("auto_aiter(")
+            self.visit(node.iter, frame)
+            if self.environment.is_async and not extended_loop:
+                self.write(")")
+        if node.test:
+            self.write(")")
+
+        if node.recursive:
+            self.write(", undefined, loop_render_func, depth):")
+        else:
+            self.write(", undefined):" if extended_loop else ":")
+
+        self.indent()
+        self.enter_frame(loop_frame)
+
+        self.writeline("_loop_vars = {}")
+        self.blockvisit(node.body, loop_frame)
+        if node.else_:
+            self.writeline(f"{iteration_indicator} = 0")
+        self.outdent()
+        self.leave_frame(
+            loop_frame, with_python_scope=node.recursive and not node.else_
+        )
+
+        if node.else_:
+            self.writeline(f"if {iteration_indicator}:")
+            self.indent()
+            self.enter_frame(else_frame)
+            self.blockvisit(node.else_, else_frame)
+            self.leave_frame(else_frame)
+            self.outdent()
+
+        # if the node was recursive we have to return the buffer contents
+        # and start the iteration code
+        if node.recursive:
+            self.return_buffer_contents(loop_frame)
+            self.outdent()
+            self.start_write(frame, node)
+            self.write(f"{self.choose_async('await ')}loop(")
+            if self.environment.is_async:
+                self.write("auto_aiter(")
+            self.visit(node.iter, frame)
+            if self.environment.is_async:
+                self.write(")")
+            self.write(", loop)")
+            self.end_write(frame)
+
+        # at the end of the iteration, clear any assignments made in the
+        # loop from the top level
+        if self._assign_stack:
+            self._assign_stack[-1].difference_update(loop_frame.symbols.stores)
+
+    def visit_If(self, node: nodes.If, frame: Frame) -> None:
+        if_frame = frame.soft()
+        self.writeline("if ", node)
+        self.visit(node.test, if_frame)
+        self.write(":")
+        self.indent()
+        self.blockvisit(node.body, if_frame)
+        self.outdent()
+        for elif_ in node.elif_:
+            self.writeline("elif ", elif_)
+            self.visit(elif_.test, if_frame)
+            self.write(":")
+            self.indent()
+            self.blockvisit(elif_.body, if_frame)
+            self.outdent()
+        if node.else_:
+            self.writeline("else:")
+            self.indent()
+            self.blockvisit(node.else_, if_frame)
+            self.outdent()
+
+    def visit_Macro(self, node: nodes.Macro, frame: Frame) -> None:
+        macro_frame, macro_ref = self.macro_body(node, frame)
+        self.newline()
+        if frame.toplevel:
+            if not node.name.startswith("_"):
+                self.write(f"context.exported_vars.add({node.name!r})")
+            self.writeline(f"context.vars[{node.name!r}] = ")
+        self.write(f"{frame.symbols.ref(node.name)} = ")
+        self.macro_def(macro_ref, macro_frame)
+
+    def visit_CallBlock(self, node: nodes.CallBlock, frame: Frame) -> None:
+        call_frame, macro_ref = self.macro_body(node, frame)
+        self.writeline("caller = ")
+        self.macro_def(macro_ref, call_frame)
+        self.start_write(frame, node)
+        self.visit_Call(node.call, frame, forward_caller=True)
+        self.end_write(frame)
+
+    def visit_FilterBlock(self, node: nodes.FilterBlock, frame: Frame) -> None:
+        filter_frame = frame.inner()
+        filter_frame.symbols.analyze_node(node)
+        self.enter_frame(filter_frame)
+        self.buffer(filter_frame)
+        self.blockvisit(node.body, filter_frame)
+        self.start_write(frame, node)
+        self.visit_Filter(node.filter, filter_frame)
+        self.end_write(frame)
+        self.leave_frame(filter_frame)
+
+    def visit_With(self, node: nodes.With, frame: Frame) -> None:
+        with_frame = frame.inner()
+        with_frame.symbols.analyze_node(node)
+        self.enter_frame(with_frame)
+        for target, expr in zip(node.targets, node.values):
+            self.newline()
+            self.visit(target, with_frame)
+            self.write(" = ")
+            self.visit(expr, frame)
+        self.blockvisit(node.body, with_frame)
+        self.leave_frame(with_frame)
+
+    def visit_ExprStmt(self, node: nodes.ExprStmt, frame: Frame) -> None:
+        self.newline(node)
+        self.visit(node.node, frame)
+
+    class _FinalizeInfo(t.NamedTuple):
+        const: t.Optional[t.Callable[..., str]]
+        src: t.Optional[str]
+
+    @staticmethod
+    def _default_finalize(value: t.Any) -> t.Any:
+        """The default finalize function if the environment isn't
+        configured with one. Or, if the environment has one, this is
+        called on that function's output for constants.
+        """
+        return str(value)
+
+    _finalize: t.Optional[_FinalizeInfo] = None
+
+    def _make_finalize(self) -> _FinalizeInfo:
+        """Build the finalize function to be used on constants and at
+        runtime. Cached so it's only created once for all output nodes.
+
+        Returns a ``namedtuple`` with the following attributes:
+
+        ``const``
+            A function to finalize constant data at compile time.
+
+        ``src``
+            Source code to output around nodes to be evaluated at
+            runtime.
+        """
+        if self._finalize is not None:
+            return self._finalize
+
+        finalize: t.Optional[t.Callable[..., t.Any]]
+        finalize = default = self._default_finalize
+        src = None
+
+        if self.environment.finalize:
+            src = "environment.finalize("
+            env_finalize = self.environment.finalize
+            pass_arg = {
+                _PassArg.context: "context",
+                _PassArg.eval_context: "context.eval_ctx",
+                _PassArg.environment: "environment",
+            }.get(
+                _PassArg.from_obj(env_finalize)  # type: ignore
+            )
+            finalize = None
+
+            if pass_arg is None:
+
+                def finalize(value: t.Any) -> t.Any:  # noqa: F811
+                    return default(env_finalize(value))
+
+            else:
+                src = f"{src}{pass_arg}, "
+
+                if pass_arg == "environment":
+
+                    def finalize(value: t.Any) -> t.Any:  # noqa: F811
+                        return default(env_finalize(self.environment, value))
+
+        self._finalize = self._FinalizeInfo(finalize, src)
+        return self._finalize
+
+    def _output_const_repr(self, group: t.Iterable[t.Any]) -> str:
+        """Given a group of constant values converted from ``Output``
+        child nodes, produce a string to write to the template module
+        source.
+        """
+        return repr(concat(group))
+
+    def _output_child_to_const(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> str:
+        """Try to optimize a child of an ``Output`` node by trying to
+        convert it to constant, finalized data at compile time.
+
+        If :exc:`Impossible` is raised, the node is not constant and
+        will be evaluated at runtime. Any other exception will also be
+        evaluated at runtime for easier debugging.
+        """
+        const = node.as_const(frame.eval_ctx)
+
+        if frame.eval_ctx.autoescape:
+            const = escape(const)
+
+        # Template data doesn't go through finalize.
+        if isinstance(node, nodes.TemplateData):
+            return str(const)
+
+        return finalize.const(const)  # type: ignore
+
+    def _output_child_pre(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> None:
+        """Output extra source code before visiting a child of an
+        ``Output`` node.
+        """
+        if frame.eval_ctx.volatile:
+            self.write("(escape if context.eval_ctx.autoescape else str)(")
+        elif frame.eval_ctx.autoescape:
+            self.write("escape(")
+        else:
+            self.write("str(")
+
+        if finalize.src is not None:
+            self.write(finalize.src)
+
+    def _output_child_post(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> None:
+        """Output extra source code after visiting a child of an
+        ``Output`` node.
+        """
+        self.write(")")
+
+        if finalize.src is not None:
+            self.write(")")
+
+    def visit_Output(self, node: nodes.Output, frame: Frame) -> None:
+        # If an extends is active, don't render outside a block.
+        if frame.require_output_check:
+            # A top-level extends is known to exist at compile time.
+            if self.has_known_extends:
+                return
+
+            self.writeline("if parent_template is None:")
+            self.indent()
+
+        finalize = self._make_finalize()
+        body: t.List[t.Union[t.List[t.Any], nodes.Expr]] = []
+
+        # Evaluate constants at compile time if possible. Each item in
+        # body will be either a list of static data or a node to be
+        # evaluated at runtime.
+        for child in node.nodes:
+            try:
+                if not (
+                    # If the finalize function requires runtime context,
+                    # constants can't be evaluated at compile time.
+                    finalize.const
+                    # Unless it's basic template data that won't be
+                    # finalized anyway.
+                    or isinstance(child, nodes.TemplateData)
+                ):
+                    raise nodes.Impossible()
+
+                const = self._output_child_to_const(child, frame, finalize)
+            except (nodes.Impossible, Exception):
+                # The node was not constant and needs to be evaluated at
+                # runtime. Or another error was raised, which is easier
+                # to debug at runtime.
+                body.append(child)
+                continue
+
+            if body and isinstance(body[-1], list):
+                body[-1].append(const)
+            else:
+                body.append([const])
+
+        if frame.buffer is not None:
+            if len(body) == 1:
+                self.writeline(f"{frame.buffer}.append(")
+            else:
+                self.writeline(f"{frame.buffer}.extend((")
+
+            self.indent()
+
+        for item in body:
+            if isinstance(item, list):
+                # A group of constant data to join and output.
+                val = self._output_const_repr(item)
+
+                if frame.buffer is None:
+                    self.writeline("yield " + val)
+                else:
+                    self.writeline(val + ",")
+            else:
+                if frame.buffer is None:
+                    self.writeline("yield ", item)
+                else:
+                    self.newline(item)
+
+                # A node to be evaluated at runtime.
+                self._output_child_pre(item, frame, finalize)
+                self.visit(item, frame)
+                self._output_child_post(item, frame, finalize)
+
+                if frame.buffer is not None:
+                    self.write(",")
+
+        if frame.buffer is not None:
+            self.outdent()
+            self.writeline(")" if len(body) == 1 else "))")
+
+        if frame.require_output_check:
+            self.outdent()
+
+    def visit_Assign(self, node: nodes.Assign, frame: Frame) -> None:
+        self.push_assign_tracking()
+
+        # ``a.b`` is allowed for assignment, and is parsed as an NSRef. However,
+        # it is only valid if it references a Namespace object. Emit a check for
+        # that for each ref here, before assignment code is emitted. This can't
+        # be done in visit_NSRef as the ref could be in the middle of a tuple.
+        seen_refs: t.Set[str] = set()
+
+        for nsref in node.find_all(nodes.NSRef):
+            if nsref.name in seen_refs:
+                # Only emit the check for each reference once, in case the same
+                # ref is used multiple times in a tuple, `ns.a, ns.b = c, d`.
+                continue
+
+            seen_refs.add(nsref.name)
+            ref = frame.symbols.ref(nsref.name)
+            self.writeline(f"if not isinstance({ref}, Namespace):")
+            self.indent()
+            self.writeline(
+                "raise TemplateRuntimeError"
+                '("cannot assign attribute on non-namespace object")'
+            )
+            self.outdent()
+
+        self.newline(node)
+        self.visit(node.target, frame)
+        self.write(" = ")
+        self.visit(node.node, frame)
+        self.pop_assign_tracking(frame)
+
+    def visit_AssignBlock(self, node: nodes.AssignBlock, frame: Frame) -> None:
+        self.push_assign_tracking()
+        block_frame = frame.inner()
+        # This is a special case.  Since a set block always captures we
+        # will disable output checks.  This way one can use set blocks
+        # toplevel even in extended templates.
+        block_frame.require_output_check = False
+        block_frame.symbols.analyze_node(node)
+        self.enter_frame(block_frame)
+        self.buffer(block_frame)
+        self.blockvisit(node.body, block_frame)
+        self.newline(node)
+        self.visit(node.target, frame)
+        self.write(" = (Markup if context.eval_ctx.autoescape else identity)(")
+        if node.filter is not None:
+            self.visit_Filter(node.filter, block_frame)
+        else:
+            self.write(f"concat({block_frame.buffer})")
+        self.write(")")
+        self.pop_assign_tracking(frame)
+        self.leave_frame(block_frame)
+
+    # -- Expression Visitors
+
+    def visit_Name(self, node: nodes.Name, frame: Frame) -> None:
+        if node.ctx == "store" and (
+            frame.toplevel or frame.loop_frame or frame.block_frame
+        ):
+            if self._assign_stack:
+                self._assign_stack[-1].add(node.name)
+        ref = frame.symbols.ref(node.name)
+
+        # If we are looking up a variable we might have to deal with the
+        # case where it's undefined.  We can skip that case if the load
+        # instruction indicates a parameter which are always defined.
+        if node.ctx == "load":
+            load = frame.symbols.find_load(ref)
+            if not (
+                load is not None
+                and load[0] == VAR_LOAD_PARAMETER
+                and not self.parameter_is_undeclared(ref)
+            ):
+                self.write(
+                    f"(undefined(name={node.name!r}) if {ref} is missing else {ref})"
+                )
+                return
+
+        self.write(ref)
+
+    def visit_NSRef(self, node: nodes.NSRef, frame: Frame) -> None:
+        # NSRef is a dotted assignment target a.b=c, but uses a[b]=c internally.
+        # visit_Assign emits code to validate that each ref is to a Namespace
+        # object only. That can't be emitted here as the ref could be in the
+        # middle of a tuple assignment.
+        ref = frame.symbols.ref(node.name)
+        self.writeline(f"{ref}[{node.attr!r}]")
+
+    def visit_Const(self, node: nodes.Const, frame: Frame) -> None:
+        val = node.as_const(frame.eval_ctx)
+        if isinstance(val, float):
+            self.write(str(val))
+        else:
+            self.write(repr(val))
+
+    def visit_TemplateData(self, node: nodes.TemplateData, frame: Frame) -> None:
+        try:
+            self.write(repr(node.as_const(frame.eval_ctx)))
+        except nodes.Impossible:
+            self.write(
+                f"(Markup if context.eval_ctx.autoescape else identity)({node.data!r})"
+            )
+
+    def visit_Tuple(self, node: nodes.Tuple, frame: Frame) -> None:
+        self.write("(")
+        idx = -1
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item, frame)
+        self.write(",)" if idx == 0 else ")")
+
+    def visit_List(self, node: nodes.List, frame: Frame) -> None:
+        self.write("[")
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item, frame)
+        self.write("]")
+
+    def visit_Dict(self, node: nodes.Dict, frame: Frame) -> None:
+        self.write("{")
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item.key, frame)
+            self.write(": ")
+            self.visit(item.value, frame)
+        self.write("}")
+
+    visit_Add = _make_binop("+")
+    visit_Sub = _make_binop("-")
+    visit_Mul = _make_binop("*")
+    visit_Div = _make_binop("/")
+    visit_FloorDiv = _make_binop("//")
+    visit_Pow = _make_binop("**")
+    visit_Mod = _make_binop("%")
+    visit_And = _make_binop("and")
+    visit_Or = _make_binop("or")
+    visit_Pos = _make_unop("+")
+    visit_Neg = _make_unop("-")
+    visit_Not = _make_unop("not ")
+
+    @optimizeconst
+    def visit_Concat(self, node: nodes.Concat, frame: Frame) -> None:
+        if frame.eval_ctx.volatile:
+            func_name = "(markup_join if context.eval_ctx.volatile else str_join)"
+        elif frame.eval_ctx.autoescape:
+            func_name = "markup_join"
+        else:
+            func_name = "str_join"
+        self.write(f"{func_name}((")
+        for arg in node.nodes:
+            self.visit(arg, frame)
+            self.write(", ")
+        self.write("))")
+
+    @optimizeconst
+    def visit_Compare(self, node: nodes.Compare, frame: Frame) -> None:
+        self.write("(")
+        self.visit(node.expr, frame)
+        for op in node.ops:
+            self.visit(op, frame)
+        self.write(")")
+
+    def visit_Operand(self, node: nodes.Operand, frame: Frame) -> None:
+        self.write(f" {operators[node.op]} ")
+        self.visit(node.expr, frame)
+
+    @optimizeconst
+    def visit_Getattr(self, node: nodes.Getattr, frame: Frame) -> None:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+
+        self.write("environment.getattr(")
+        self.visit(node.node, frame)
+        self.write(f", {node.attr!r})")
+
+        if self.environment.is_async:
+            self.write("))")
+
+    @optimizeconst
+    def visit_Getitem(self, node: nodes.Getitem, frame: Frame) -> None:
+        # slices bypass the environment getitem method.
+        if isinstance(node.arg, nodes.Slice):
+            self.visit(node.node, frame)
+            self.write("[")
+            self.visit(node.arg, frame)
+            self.write("]")
+        else:
+            if self.environment.is_async:
+                self.write("(await auto_await(")
+
+            self.write("environment.getitem(")
+            self.visit(node.node, frame)
+            self.write(", ")
+            self.visit(node.arg, frame)
+            self.write(")")
+
+            if self.environment.is_async:
+                self.write("))")
+
+    def visit_Slice(self, node: nodes.Slice, frame: Frame) -> None:
+        if node.start is not None:
+            self.visit(node.start, frame)
+        self.write(":")
+        if node.stop is not None:
+            self.visit(node.stop, frame)
+        if node.step is not None:
+            self.write(":")
+            self.visit(node.step, frame)
+
+    @contextmanager
+    def _filter_test_common(
+        self, node: t.Union[nodes.Filter, nodes.Test], frame: Frame, is_filter: bool
+    ) -> t.Iterator[None]:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+
+        if is_filter:
+            self.write(f"{self.filters[node.name]}(")
+            func = self.environment.filters.get(node.name)
+        else:
+            self.write(f"{self.tests[node.name]}(")
+            func = self.environment.tests.get(node.name)
+
+        # When inside an If or CondExpr frame, allow the filter to be
+        # undefined at compile time and only raise an error if it's
+        # actually called at runtime. See pull_dependencies.
+        if func is None and not frame.soft_frame:
+            type_name = "filter" if is_filter else "test"
+            self.fail(f"No {type_name} named {node.name!r}.", node.lineno)
+
+        pass_arg = {
+            _PassArg.context: "context",
+            _PassArg.eval_context: "context.eval_ctx",
+            _PassArg.environment: "environment",
+        }.get(
+            _PassArg.from_obj(func)  # type: ignore
+        )
+
+        if pass_arg is not None:
+            self.write(f"{pass_arg}, ")
+
+        # Back to the visitor function to handle visiting the target of
+        # the filter or test.
+        yield
+
+        self.signature(node, frame)
+        self.write(")")
+
+        if self.environment.is_async:
+            self.write("))")
+
+    @optimizeconst
+    def visit_Filter(self, node: nodes.Filter, frame: Frame) -> None:
+        with self._filter_test_common(node, frame, True):
+            # if the filter node is None we are inside a filter block
+            # and want to write to the current buffer
+            if node.node is not None:
+                self.visit(node.node, frame)
+            elif frame.eval_ctx.volatile:
+                self.write(
+                    f"(Markup(concat({frame.buffer}))"
+                    f" if context.eval_ctx.autoescape else concat({frame.buffer}))"
+                )
+            elif frame.eval_ctx.autoescape:
+                self.write(f"Markup(concat({frame.buffer}))")
+            else:
+                self.write(f"concat({frame.buffer})")
+
+    @optimizeconst
+    def visit_Test(self, node: nodes.Test, frame: Frame) -> None:
+        with self._filter_test_common(node, frame, False):
+            self.visit(node.node, frame)
+
+    @optimizeconst
+    def visit_CondExpr(self, node: nodes.CondExpr, frame: Frame) -> None:
+        frame = frame.soft()
+
+        def write_expr2() -> None:
+            if node.expr2 is not None:
+                self.visit(node.expr2, frame)
+                return
+
+            self.write(
+                f'cond_expr_undefined("the inline if-expression on'
+                f" {self.position(node)} evaluated to false and no else"
+                f' section was defined.")'
+            )
+
+        self.write("(")
+        self.visit(node.expr1, frame)
+        self.write(" if ")
+        self.visit(node.test, frame)
+        self.write(" else ")
+        write_expr2()
+        self.write(")")
+
+    @optimizeconst
+    def visit_Call(
+        self, node: nodes.Call, frame: Frame, forward_caller: bool = False
+    ) -> None:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+        if self.environment.sandboxed:
+            self.write("environment.call(context, ")
+        else:
+            self.write("context.call(")
+        self.visit(node.node, frame)
+        extra_kwargs = {"caller": "caller"} if forward_caller else None
+        loop_kwargs = {"_loop_vars": "_loop_vars"} if frame.loop_frame else {}
+        block_kwargs = {"_block_vars": "_block_vars"} if frame.block_frame else {}
+        if extra_kwargs:
+            extra_kwargs.update(loop_kwargs, **block_kwargs)
+        elif loop_kwargs or block_kwargs:
+            extra_kwargs = dict(loop_kwargs, **block_kwargs)
+        self.signature(node, frame, extra_kwargs)
+        self.write(")")
+        if self.environment.is_async:
+            self.write("))")
+
+    def visit_Keyword(self, node: nodes.Keyword, frame: Frame) -> None:
+        self.write(node.key + "=")
+        self.visit(node.value, frame)
+
+    # -- Unused nodes for extensions
+
+    def visit_MarkSafe(self, node: nodes.MarkSafe, frame: Frame) -> None:
+        self.write("Markup(")
+        self.visit(node.expr, frame)
+        self.write(")")
+
+    def visit_MarkSafeIfAutoescape(
+        self, node: nodes.MarkSafeIfAutoescape, frame: Frame
+    ) -> None:
+        self.write("(Markup if context.eval_ctx.autoescape else identity)(")
+        self.visit(node.expr, frame)
+        self.write(")")
+
+    def visit_EnvironmentAttribute(
+        self, node: nodes.EnvironmentAttribute, frame: Frame
+    ) -> None:
+        self.write("environment." + node.name)
+
+    def visit_ExtensionAttribute(
+        self, node: nodes.ExtensionAttribute, frame: Frame
+    ) -> None:
+        self.write(f"environment.extensions[{node.identifier!r}].{node.name}")
+
+    def visit_ImportedName(self, node: nodes.ImportedName, frame: Frame) -> None:
+        self.write(self.import_aliases[node.importname])
+
+    def visit_InternalName(self, node: nodes.InternalName, frame: Frame) -> None:
+        self.write(node.name)
+
+    def visit_ContextReference(
+        self, node: nodes.ContextReference, frame: Frame
+    ) -> None:
+        self.write("context")
+
+    def visit_DerivedContextReference(
+        self, node: nodes.DerivedContextReference, frame: Frame
+    ) -> None:
+        self.write(self.derive_context(frame))
+
+    def visit_Continue(self, node: nodes.Continue, frame: Frame) -> None:
+        self.writeline("continue", node)
+
+    def visit_Break(self, node: nodes.Break, frame: Frame) -> None:
+        self.writeline("break", node)
+
+    def visit_Scope(self, node: nodes.Scope, frame: Frame) -> None:
+        scope_frame = frame.inner()
+        scope_frame.symbols.analyze_node(node)
+        self.enter_frame(scope_frame)
+        self.blockvisit(node.body, scope_frame)
+        self.leave_frame(scope_frame)
+
+    def visit_OverlayScope(self, node: nodes.OverlayScope, frame: Frame) -> None:
+        ctx = self.temporary_identifier()
+        self.writeline(f"{ctx} = {self.derive_context(frame)}")
+        self.writeline(f"{ctx}.vars = ")
+        self.visit(node.context, frame)
+        self.push_context_reference(ctx)
+
+        scope_frame = frame.inner(isolated=True)
+        scope_frame.symbols.analyze_node(node)
+        self.enter_frame(scope_frame)
+        self.blockvisit(node.body, scope_frame)
+        self.leave_frame(scope_frame)
+        self.pop_context_reference()
+
+    def visit_EvalContextModifier(
+        self, node: nodes.EvalContextModifier, frame: Frame
+    ) -> None:
+        for keyword in node.options:
+            self.writeline(f"context.eval_ctx.{keyword.key} = ")
+            self.visit(keyword.value, frame)
+            try:
+                val = keyword.value.as_const(frame.eval_ctx)
+            except nodes.Impossible:
+                frame.eval_ctx.volatile = True
+            else:
+                setattr(frame.eval_ctx, keyword.key, val)
+
+    def visit_ScopedEvalContextModifier(
+        self, node: nodes.ScopedEvalContextModifier, frame: Frame
+    ) -> None:
+        old_ctx_name = self.temporary_identifier()
+        saved_ctx = frame.eval_ctx.save()
+        self.writeline(f"{old_ctx_name} = context.eval_ctx.save()")
+        self.visit_EvalContextModifier(node, frame)
+        for child in node.body:
+            self.visit(child, frame)
+        frame.eval_ctx.revert(saved_ctx)
+        self.writeline(f"context.eval_ctx.revert({old_ctx_name})")
diff --git a/.venv/lib/python3.10/site-packages/jinja2/constants.py b/.venv/lib/python3.10/site-packages/jinja2/constants.py
new file mode 100644
index 0000000..41a1c23
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/constants.py
@@ -0,0 +1,20 @@
+#: list of lorem ipsum words used by the lipsum() helper function
+LOREM_IPSUM_WORDS = """\
+a ac accumsan ad adipiscing aenean aliquam aliquet amet ante aptent arcu at
+auctor augue bibendum blandit class commodo condimentum congue consectetuer
+consequat conubia convallis cras cubilia cum curabitur curae cursus dapibus
+diam dictum dictumst dignissim dis dolor donec dui duis egestas eget eleifend
+elementum elit enim erat eros est et etiam eu euismod facilisi facilisis fames
+faucibus felis fermentum feugiat fringilla fusce gravida habitant habitasse hac
+hendrerit hymenaeos iaculis id imperdiet in inceptos integer interdum ipsum
+justo lacinia lacus laoreet lectus leo libero ligula litora lobortis lorem
+luctus maecenas magna magnis malesuada massa mattis mauris metus mi molestie
+mollis montes morbi mus nam nascetur natoque nec neque netus nibh nisi nisl non
+nonummy nostra nulla nullam nunc odio orci ornare parturient pede pellentesque
+penatibus per pharetra phasellus placerat platea porta porttitor posuere
+potenti praesent pretium primis proin pulvinar purus quam quis quisque rhoncus
+ridiculus risus rutrum sagittis sapien scelerisque sed sem semper senectus sit
+sociis sociosqu sodales sollicitudin suscipit suspendisse taciti tellus tempor
+tempus tincidunt torquent tortor tristique turpis ullamcorper ultrices
+ultricies urna ut varius vehicula vel velit venenatis vestibulum vitae vivamus
+viverra volutpat vulputate"""
diff --git a/.venv/lib/python3.10/site-packages/jinja2/debug.py b/.venv/lib/python3.10/site-packages/jinja2/debug.py
new file mode 100644
index 0000000..eeeeee7
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/debug.py
@@ -0,0 +1,191 @@
+import sys
+import typing as t
+from types import CodeType
+from types import TracebackType
+
+from .exceptions import TemplateSyntaxError
+from .utils import internal_code
+from .utils import missing
+
+if t.TYPE_CHECKING:
+    from .runtime import Context
+
+
+def rewrite_traceback_stack(source: t.Optional[str] = None) -> BaseException:
+    """Rewrite the current exception to replace any tracebacks from
+    within compiled template code with tracebacks that look like they
+    came from the template source.
+
+    This must be called within an ``except`` block.
+
+    :param source: For ``TemplateSyntaxError``, the original source if
+        known.
+    :return: The original exception with the rewritten traceback.
+    """
+    _, exc_value, tb = sys.exc_info()
+    exc_value = t.cast(BaseException, exc_value)
+    tb = t.cast(TracebackType, tb)
+
+    if isinstance(exc_value, TemplateSyntaxError) and not exc_value.translated:
+        exc_value.translated = True
+        exc_value.source = source
+        # Remove the old traceback, otherwise the frames from the
+        # compiler still show up.
+        exc_value.with_traceback(None)
+        # Outside of runtime, so the frame isn't executing template
+        # code, but it still needs to point at the template.
+        tb = fake_traceback(
+            exc_value, None, exc_value.filename or "", exc_value.lineno
+        )
+    else:
+        # Skip the frame for the render function.
+        tb = tb.tb_next
+
+    stack = []
+
+    # Build the stack of traceback object, replacing any in template
+    # code with the source file and line information.
+    while tb is not None:
+        # Skip frames decorated with @internalcode. These are internal
+        # calls that aren't useful in template debugging output.
+        if tb.tb_frame.f_code in internal_code:
+            tb = tb.tb_next
+            continue
+
+        template = tb.tb_frame.f_globals.get("__jinja_template__")
+
+        if template is not None:
+            lineno = template.get_corresponding_lineno(tb.tb_lineno)
+            fake_tb = fake_traceback(exc_value, tb, template.filename, lineno)
+            stack.append(fake_tb)
+        else:
+            stack.append(tb)
+
+        tb = tb.tb_next
+
+    tb_next = None
+
+    # Assign tb_next in reverse to avoid circular references.
+    for tb in reversed(stack):
+        tb.tb_next = tb_next
+        tb_next = tb
+
+    return exc_value.with_traceback(tb_next)
+
+
+def fake_traceback(  # type: ignore
+    exc_value: BaseException, tb: t.Optional[TracebackType], filename: str, lineno: int
+) -> TracebackType:
+    """Produce a new traceback object that looks like it came from the
+    template source instead of the compiled code. The filename, line
+    number, and location name will point to the template, and the local
+    variables will be the current template context.
+
+    :param exc_value: The original exception to be re-raised to create
+        the new traceback.
+    :param tb: The original traceback to get the local variables and
+        code info from.
+    :param filename: The template filename.
+    :param lineno: The line number in the template source.
+    """
+    if tb is not None:
+        # Replace the real locals with the context that would be
+        # available at that point in the template.
+        locals = get_template_locals(tb.tb_frame.f_locals)
+        locals.pop("__jinja_exception__", None)
+    else:
+        locals = {}
+
+    globals = {
+        "__name__": filename,
+        "__file__": filename,
+        "__jinja_exception__": exc_value,
+    }
+    # Raise an exception at the correct line number.
+    code: CodeType = compile(
+        "\n" * (lineno - 1) + "raise __jinja_exception__", filename, "exec"
+    )
+
+    # Build a new code object that points to the template file and
+    # replaces the location with a block name.
+    location = "template"
+
+    if tb is not None:
+        function = tb.tb_frame.f_code.co_name
+
+        if function == "root":
+            location = "top-level template code"
+        elif function.startswith("block_"):
+            location = f"block {function[6:]!r}"
+
+    if sys.version_info >= (3, 8):
+        code = code.replace(co_name=location)
+    else:
+        code = CodeType(
+            code.co_argcount,
+            code.co_kwonlyargcount,
+            code.co_nlocals,
+            code.co_stacksize,
+            code.co_flags,
+            code.co_code,
+            code.co_consts,
+            code.co_names,
+            code.co_varnames,
+            code.co_filename,
+            location,
+            code.co_firstlineno,
+            code.co_lnotab,
+            code.co_freevars,
+            code.co_cellvars,
+        )
+
+    # Execute the new code, which is guaranteed to raise, and return
+    # the new traceback without this frame.
+    try:
+        exec(code, globals, locals)
+    except BaseException:
+        return sys.exc_info()[2].tb_next  # type: ignore
+
+
+def get_template_locals(real_locals: t.Mapping[str, t.Any]) -> t.Dict[str, t.Any]:
+    """Based on the runtime locals, get the context that would be
+    available at that point in the template.
+    """
+    # Start with the current template context.
+    ctx: t.Optional[Context] = real_locals.get("context")
+
+    if ctx is not None:
+        data: t.Dict[str, t.Any] = ctx.get_all().copy()
+    else:
+        data = {}
+
+    # Might be in a derived context that only sets local variables
+    # rather than pushing a context. Local variables follow the scheme
+    # l_depth_name. Find the highest-depth local that has a value for
+    # each name.
+    local_overrides: t.Dict[str, t.Tuple[int, t.Any]] = {}
+
+    for name, value in real_locals.items():
+        if not name.startswith("l_") or value is missing:
+            # Not a template variable, or no longer relevant.
+            continue
+
+        try:
+            _, depth_str, name = name.split("_", 2)
+            depth = int(depth_str)
+        except ValueError:
+            continue
+
+        cur_depth = local_overrides.get(name, (-1,))[0]
+
+        if cur_depth < depth:
+            local_overrides[name] = (depth, value)
+
+    # Modify the context with any derived context.
+    for name, (_, value) in local_overrides.items():
+        if value is missing:
+            data.pop(name, None)
+        else:
+            data[name] = value
+
+    return data
diff --git a/.venv/lib/python3.10/site-packages/jinja2/defaults.py b/.venv/lib/python3.10/site-packages/jinja2/defaults.py
new file mode 100644
index 0000000..638cad3
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/defaults.py
@@ -0,0 +1,48 @@
+import typing as t
+
+from .filters import FILTERS as DEFAULT_FILTERS  # noqa: F401
+from .tests import TESTS as DEFAULT_TESTS  # noqa: F401
+from .utils import Cycler
+from .utils import generate_lorem_ipsum
+from .utils import Joiner
+from .utils import Namespace
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+# defaults for the parser / lexer
+BLOCK_START_STRING = "{%"
+BLOCK_END_STRING = "%}"
+VARIABLE_START_STRING = "{{"
+VARIABLE_END_STRING = "}}"
+COMMENT_START_STRING = "{#"
+COMMENT_END_STRING = "#}"
+LINE_STATEMENT_PREFIX: t.Optional[str] = None
+LINE_COMMENT_PREFIX: t.Optional[str] = None
+TRIM_BLOCKS = False
+LSTRIP_BLOCKS = False
+NEWLINE_SEQUENCE: "te.Literal['\\n', '\\r\\n', '\\r']" = "\n"
+KEEP_TRAILING_NEWLINE = False
+
+# default filters, tests and namespace
+
+DEFAULT_NAMESPACE = {
+    "range": range,
+    "dict": dict,
+    "lipsum": generate_lorem_ipsum,
+    "cycler": Cycler,
+    "joiner": Joiner,
+    "namespace": Namespace,
+}
+
+# default policies
+DEFAULT_POLICIES: t.Dict[str, t.Any] = {
+    "compiler.ascii_str": True,
+    "urlize.rel": "noopener",
+    "urlize.target": None,
+    "urlize.extra_schemes": None,
+    "truncate.leeway": 5,
+    "json.dumps_function": None,
+    "json.dumps_kwargs": {"sort_keys": True},
+    "ext.i18n.trimmed": False,
+}
diff --git a/.venv/lib/python3.10/site-packages/jinja2/environment.py b/.venv/lib/python3.10/site-packages/jinja2/environment.py
new file mode 100644
index 0000000..0fc6e5b
--- /dev/null
+++ b/.venv/lib/python3.10/site-packages/jinja2/environment.py
@@ -0,0 +1,1672 @@
+"""Classes for managing templates and their runtime and compile time
+options.
+"""
+
+import os
+import typing
+import typing as t
+import weakref
+from collections import ChainMap
+from functools import lru_cache
+from functools import partial
+from functools import reduce
+from types import CodeType
+
+from markupsafe import Markup
+
+from . import nodes
+from .compiler import CodeGenerator
+from .compiler import generate
+from .defaults import BLOCK_END_STRING
+from .defaults import BLOCK_START_STRING
+from .defaults import COMMENT_END_STRING
+from .defaults import COMMENT_START_STRING
+from .defaults import DEFAULT_FILTERS  # type: ignore[attr-defined]
+from .defaults import DEFAULT_NAMESPACE
+from .defaults import DEFAULT_POLICIES
+from .defaults import DEFAULT_TESTS  # type: ignore[attr-defined]
+from .defaults import KEEP_TRAILING_NEWLINE
+from .defaults import LINE_COMMENT_PREFIX
+from .defaults import LINE_STATEMENT_PREFIX
+from .defaults import LSTRIP_BLOCKS
+from .defaults import NEWLINE_SEQUENCE
+from .defaults import TRIM_BLOCKS
+from .defaults import VARIABLE_END_STRING
+from .defaults import VARIABLE_START_STRING
+from .exceptions import TemplateNotFound
+from .exceptions import TemplateRuntimeError
+from .exceptions import TemplatesNotFound
+from .exceptions import TemplateSyntaxError
+from .exceptions import UndefinedError
+from .lexer import get_lexer
+from .lexer import Lexer
+from .lexer import TokenStream
+from .nodes import EvalContext
+from .parser import Parser
+from .runtime import Context
+from .runtime import new_context
+from .runtime import Undefined
+from .utils import _PassArg
+from .utils import concat
+from .utils import consume
+from .utils import import_string
+from .utils import internalcode
+from .utils import LRUCache
+from .utils import missing
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .bccache import BytecodeCache
+    from .ext import Extension
+    from .loaders import BaseLoader
+
+_env_bound = t.TypeVar("_env_bound", bound="Environment")
+
+
+# for direct template usage we have up to ten living environments
+@lru_cache(maxsize=10)
+def get_spontaneous_environment(cls: t.Type[_env_bound], *args: t.Any) -> _env_bound:
+    """Return a new spontaneous environment. A spontaneous environment
+    is used for templates created directly rather than through an
+    existing environment.
+
+    :param cls: Environment class to create.
+    :param args: Positional arguments passed to environment.
+    """
+    env = cls(*args)
+    env.shared = True
+    return env
+
+
+def create_cache(
+    size: int,
+) -> t.Optional[t.MutableMapping[t.Tuple["weakref.ref[t.Any]", str], "Template"]]:
+    """Return the cache class for the given size."""
+    if size == 0:
+        return None
+
+    if size < 0:
+        return {}
+
+    return LRUCache(size)  # type: ignore
+
+
+def copy_cache(
+    cache: t.Optional[t.MutableMapping[t.Any, t.Any]],
+) -> t.Optional[t.MutableMapping[t.Tuple["weakref.ref[t.Any]", str], "Template"]]:
+    """Create an empty copy of the given cache."""
+    if cache is None:
+        return None
+
+    if type(cache) is dict:  # noqa E721
+        return {}
+
+    return LRUCache(cache.capacity)  # type: ignore
+
+
+def load_extensions(
+    environment: "Environment",
+    extensions: t.Sequence[t.Union[str, t.Type["Extension"]]],
+) -> t.Dict[str, "Extension"]:
+    """Load the extensions from the list and bind it to the environment.
+    Returns a dict of instantiated extensions.
+    """
+    result = {}
+
+    for extension in extensions:
+        if isinstance(extension, str):
+            extension = t.cast(t.Type["Extension"], import_string(extension))
+
+        result[extension.identifier] = extension(environment)
+
+    return result
+
+
+def _environment_config_check(environment: _env_bound) -> _env_bound:
+    """Perform a sanity check on the environment."""
+    assert issubclass(
+        environment.undefined, Undefined
+    ), "'undefined' must be a subclass of 'jinja2.Undefined'."
+    assert (
+        environment.block_start_string
+        != environment.variable_start_string
+        != environment.comment_start_string
+    ), "block, variable and comment start strings must be different."
+    assert environment.newline_sequence in {
+        "\r",
+        "\r\n",
+        "\n",
+    }, "'newline_sequence' must be one of '\\n', '\\r\\n', or '\\r'."
+    return environment
+
+
+class Environment:
+    r"""The core component of Jinja is the `Environment`.  It contains
+    important shared variables like configuration, filters, tests,
+    globals and others.  Instances of this class may be modified if
+    they are not shared and if no template was loaded so far.
+    Modifications on environments after the first template was loaded
+    will lead to surprising effects and undefined behavior.
+
+    Here are the possible initialization parameters:
+
+        `block_start_string`
+            The string marking the beginning of a block.  Defaults to ``'{%'``.
+
+        `block_end_string`
+            The string marking the end of a block.  Defaults to ``'%}'``.
+
+        `variable_start_string`
+            The string marking the beginning of a print statement.
+            Defaults to ``'{{'``.
+
+        `variable_end_string`
+            The string marking the end of a print statement.  Defaults to
+            ``'}}'``.
+
+        `comment_start_string`
+            The string marking the beginning of a comment.  Defaults to ``'{#'``.
+
+        `comment_end_string`
+            The string marking the end of a comment.  Defaults to ``'#}'``.
+
+        `line_statement_prefix`
+            If given and a string, this will be used as prefix for line based
+            statements.  See also :ref:`line-statements`.
+
+        `line_comment_prefix`
+            If given and a string, this will be used as prefix for line based
+            comments.  See also :ref:`line-statements`.
+
+            .. versionadded:: 2.2
+
+        `trim_blocks`
+            If this is set to ``True`` the first newline after a block is
+            removed (block, not variable tag!).  Defaults to `False`.
+
+        `lstrip_blocks`
+            If this is set to ``True`` leading spaces and tabs are stripped
+            from the start of a line to a block.  Defaults to `False`.
+
+        `newline_sequence`
+            The sequence that starts a newline.  Must be one of ``'\r'``,
+            ``'\n'`` or ``'\r\n'``.  The default is ``'\n'`` which is a
+            useful default for Linux and OS X systems as well as web
+            applications.
+
+        `keep_trailing_newline`
+            Preserve the trailing newline when rendering templates.
+            The default is ``False``, which causes a single newline,
+            if present, to be stripped from the end of the template.
+
+            .. versionadded:: 2.7
+
+        `extensions`
+            List of Jinja extensions to use.  This can either be import paths
+            as strings or extension classes.  For more information have a
+            look at :ref:`the extensions documentation `.
+
+        `optimized`
+            should the optimizer be enabled?  Default is ``True``.
+
+        `undefined`
+            :class:`Undefined` or a subclass of it that is used to represent
+            undefined values in the template.
+
+        `finalize`
+            A callable that can be used to process the result of a variable
+            expression before it is output.  For example one can convert
+            ``None`` implicitly into an empty string here.
+
+        `autoescape`
+            If set to ``True`` the XML/HTML autoescaping feature is enabled by
+            default.  For more details about autoescaping see
+            :class:`~markupsafe.Markup`.  As of Jinja 2.4 this can also
+            be a callable that is passed the template name and has to
+            return ``True`` or ``False`` depending on autoescape should be
+            enabled by default.
+
+            .. versionchanged:: 2.4
+               `autoescape` can now be a function
+
+        `loader`
+            The template loader for this environment.
+
+        `cache_size`
+            The size of the cache.  Per default this is ``400`` which means
+            that if more than 400 templates are loaded the loader will clean
+            out the least recently used template.  If the cache size is set to
+            ``0`` templates are recompiled all the time, if the cache size is
+            ``-1`` the cache will not be cleaned.
+
+            .. versionchanged:: 2.8
+               The cache size was increased to 400 from a low 50.
+
+        `auto_reload`
+            Some loaders load templates from locations where the template
+            sources may change (ie: file system or database).  If
+            ``auto_reload`` is set to ``True`` (default) every time a template is
+            requested the loader checks if the source changed and if yes, it
+            will reload the template.  For higher performance it's possible to
+            disable that.
+
+        `bytecode_cache`
+            If set to a bytecode cache object, this object will provide a
+            cache for the internal Jinja bytecode so that templates don't
+            have to be parsed if they were not changed.
+
+            See :ref:`bytecode-cache` for more information.
+
+        `enable_async`
+            If set to true this enables async template execution which
+            allows using async functions and generators.
+    """
+
+    #: if this environment is sandboxed.  Modifying this variable won't make
+    #: the environment sandboxed though.  For a real sandboxed environment
+    #: have a look at jinja2.sandbox.  This flag alone controls the code
+    #: generation by the compiler.
+    sandboxed = False
+
+    #: True if the environment is just an overlay
+    overlayed = False
+
+    #: the environment this environment is linked to if it is an overlay
+    linked_to: t.Optional["Environment"] = None
+
+    #: shared environments have this set to `True`.  A shared environment
+    #: must not be modified
+    shared = False
+
+    #: the class that is used for code generation.  See
+    #: :class:`~jinja2.compiler.CodeGenerator` for more information.
+    code_generator_class: t.Type["CodeGenerator"] = CodeGenerator
+
+    concat = "".join
+
+    #: the context class that is used for templates.  See
+    #: :class:`~jinja2.runtime.Context` for more information.
+    context_class: t.Type[Context] = Context
+
+    template_class: t.Type["Template"]
+
+    def __init__(
+        self,
+        block_start_string: str = BLOCK_START_STRING,
+        block_end_string: str = BLOCK_END_STRING,
+        variable_start_string: str = VARIABLE_START_STRING,
+        variable_end_string: str = VARIABLE_END_STRING,
+        comment_start_string: str = COMMENT_START_STRING,
+        comment_end_string: str = COMMENT_END_STRING,
+        line_statement_prefix: t.Optional[str] = LINE_STATEMENT_PREFIX,
+        line_comment_prefix: t.Optional[str] = LINE_COMMENT_PREFIX,
+        trim_blocks: bool = TRIM_BLOCKS,
+        lstrip_blocks: bool = LSTRIP_BLOCKS,
+        newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = NEWLINE_SEQUENCE,
+        keep_trailing_newline: bool = KEEP_TRAILING_NEWLINE,
+        extensions: t.Sequence[t.Union[str, t.Type["Extension"]]] = (),
+        optimized: bool = True,
+        undefined: t.Type[Undefined] = Undefined,
+        finalize: t.Optional[t.Callable[..., t.Any]] = None,
+        autoescape: t.Union[bool, t.Callable[[t.Optional[str]], bool]] = False,
+        loader: t.Optional["BaseLoader"] = None,
+        cache_size: int = 400,
+        auto_reload: bool = True,
+        bytecode_cache: t.Optional["BytecodeCache"] = None,
+        enable_async: bool = False,
+    ):
+        # !!Important notice!!
+        #   The constructor accepts quite a few arguments that should be
+        #   passed by keyword rather than position.  However it's important to
+        #   not change the order of arguments because it's used at least
+        #   internally in those cases:
+        #       -   spontaneous environments (i18n extension and Template)
+        #       -   unittests
+        #   If parameter changes are required only add parameters at the end
+        #   and don't change the arguments (or the defaults!) of the arguments
+        #   existing already.
+
+        # lexer / parser information
+        self.block_start_string = block_start_string
+        self.block_end_string = block_end_string
+        self.variable_start_string = variable_start_string
+        self.variable_end_string = variable_end_string
+        self.comment_start_string = comment_start_string
+        self.comment_end_string = comment_end_string
+        self.line_statement_prefix = line_statement_prefix
+        self.line_comment_prefix = line_comment_prefix
+        self.trim_blocks = trim_blocks
+        self.lstrip_blocks = lstrip_blocks
+        self.newline_sequence = newline_sequence
+        self.keep_trailing_newline = keep_trailing_newline
+
+        # runtime information
+        self.undefined: t.Type[Undefined] = undefined
+        self.optimized = optimized
+        self.finalize = finalize
+        self.autoescape = autoescape
+
+        # defaults
+        self.filters = DEFAULT_FILTERS.copy()
+        self.tests = DEFAULT_TESTS.copy()
+        self.globals = DEFAULT_NAMESPACE.copy()
+
+        # set the loader provided
+        self.loader = loader
+        self.cache = create_cache(cache_size)
+        self.bytecode_cache = bytecode_cache
+        self.auto_reload = auto_reload
+
+        # configurable policies
+        self.policies = DEFAULT_POLICIES.copy()
+
+        # load extensions
+        self.extensions = load_extensions(self, extensions)
+
+        self.is_async = enable_async
+        _environment_config_check(self)
+
+    def add_extension(self, extension: t.Union[str, t.Type["Extension"]]) -> None:
+        """Adds an extension after the environment was created.
+
+        .. versionadded:: 2.5
+        """
+        self.extensions.update(load_extensions(self, [extension]))
+
+    def extend(self, **attributes: t.Any) -> None:
+        """Add the items to the instance of the environment if they do not exist
+        yet.  This is used by :ref:`extensions ` to register
+        callbacks and configuration values without breaking inheritance.
+        """
+        for key, value in attributes.items():
+            if not hasattr(self, key):
+                setattr(self, key, value)
+
+    def overlay(
+        self,
+        block_start_string: str = missing,
+        block_end_string: str = missing,
+        variable_start_string: str = missing,
+        variable_end_string: str = missing,
+        comment_start_string: str = missing,
+        comment_end_string: str = missing,
+        line_statement_prefix: t.Optional[str] = missing,
+        line_comment_prefix: t.Optional[str] = missing,
+        trim_blocks: bool = missing,
+        lstrip_blocks: bool = missing,
+        newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = missing,
+        keep_trailing_newline: bool = missing,
+        extensions: t.Sequence[t.Union[str, t.Type["Extension"]]] = missing,
+        optimized: bool = missing,
+        undefined: t.Type[Undefined] = missing,
+        finalize: t.Optional[t.Callable[..., t.Any]] = missing,
+        autoescape: t.Union[bool, t.Callable[[t.Optional[str]], bool]] = missing,
+        loader: t.Optional["BaseLoader"] = missing,
+        cache_size: int = missing,
+        auto_reload: bool = missing,
+        bytecode_cache: t.Optional["BytecodeCache"] = missing,
+        enable_async: bool = missing,
+    ) -> "te.Self":
+        """Create a new overlay environment that shares all the data with the
+        current environment except for cache and the overridden attributes.
+        Extensions cannot be removed for an overlayed environment.  An overlayed
+        environment automatically gets all the extensions of the environment it
+        is linked to plus optional extra extensions.
+
+        Creating overlays should happen after the initial environment was set
+        up completely.  Not all attributes are truly linked, some are just
+        copied over so modifications on the original environment may not shine
+        through.
+
+        .. versionchanged:: 3.1.5
+            ``enable_async`` is applied correctly.
+
+        .. versionchanged:: 3.1.2
+            Added the ``newline_sequence``, ``keep_trailing_newline``,
+            and ``enable_async`` parameters to match ``__init__``.
+        """
+        args = dict(locals())
+        del args["self"], args["cache_size"], args["extensions"], args["enable_async"]
+
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.overlayed = True
+        rv.linked_to = self
+
+        for key, value in args.items():
+            if value is not missing:
+                setattr(rv, key, value)
+
+        if cache_size is not missing:
+            rv.cache = create_cache(cache_size)
+        else:
+            rv.cache = copy_cache(self.cache)
+
+        rv.extensions = {}
+        for key, value in self.extensions.items():
+            rv.extensions[key] = value.bind(rv)
+        if extensions is not missing:
+            rv.extensions.update(load_extensions(rv, extensions))
+
+        if enable_async is not missing:
+            rv.is_async = enable_async
+
+        return _environment_config_check(rv)
+
+    @property
+    def lexer(self) -> Lexer:
+        """The lexer for this environment."""
+        return get_lexer(self)
+
+    def iter_extensions(self) -> t.Iterator["Extension"]:
+        """Iterates over the extensions by priority."""
+        return iter(sorted(self.extensions.values(), key=lambda x: x.priority))
+
+    def getitem(
+        self, obj: t.Any, argument: t.Union[str, t.Any]
+    ) -> t.Union[t.Any, Undefined]:
+        """Get an item or attribute of an object but prefer the item."""
+        try:
+            return obj[argument]
+        except (AttributeError, TypeError, LookupError):
+            if isinstance(argument, str):
+                try:
+                    attr = str(argument)
+                except Exception:
+                    pass
+                else:
+                    try:
+                        return getattr(obj, attr)
+                    except AttributeError:
+                        pass
+            return self.undefined(obj=obj, name=argument)
+
+    def getattr(self, obj: t.Any, attribute: str) -> t.Any:
+        """Get an item or attribute of an object but prefer the attribute.
+        Unlike :meth:`getitem` the attribute *must* be a string.
+        """
+        try:
+            return getattr(obj, attribute)
+        except AttributeError:
+            pass
+        try:
+            return obj[attribute]
+        except (TypeError, LookupError, AttributeError):
+            return self.undefined(obj=obj, name=attribute)
+
+    def _filter_test_common(
+        self,
+        name: t.Union[str, Undefined],
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]],
+        kwargs: t.Optional[t.Mapping[str, t.Any]],
+        context: t.Optional[Context],
+        eval_ctx: t.Optional[EvalContext],
+        is_filter: bool,
+    ) -> t.Any:
+        if is_filter:
+            env_map = self.filters
+            type_name = "filter"
+        else:
+            env_map = self.tests
+            type_name = "test"
+
+        func = env_map.get(name)  # type: ignore
+
+        if func is None:
+            msg = f"No {type_name} named {name!r}."
+
+            if isinstance(name, Undefined):
+                try:
+                    name._fail_with_undefined_error()
+                except Exception as e:
+                    msg = f"{msg} ({e}; did you forget to quote the callable name?)"
+
+            raise TemplateRuntimeError(msg)
+
+        args = [value, *(args if args is not None else ())]
+        kwargs = kwargs if kwargs is not None else {}
+        pass_arg = _PassArg.from_obj(func)
+
+        if pass_arg is _PassArg.context:
+            if context is None:
+                raise TemplateRuntimeError(
+                    f"Attempted to invoke a context {type_name} without context."
+                )
+
+            args.insert(0, context)
+        elif pass_arg is _PassArg.eval_context:
+            if eval_ctx is None:
+                if context is not None:
+                    eval_ctx = context.eval_ctx
+                else:
+                    eval_ctx = EvalContext(self)
+
+            args.insert(0, eval_ctx)
+        elif pass_arg is _PassArg.environment:
+            args.insert(0, self)
+
+        return func(*args, **kwargs)
+
+    def call_filter(
+        self,
+        name: str,
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]] = None,
+        kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+        context: t.Optional[Context] = None,
+        eval_ctx: t.Optional[EvalContext] = None,
+    ) -> t.Any:
+        """Invoke a filter on a value the same way the compiler does.
+
+        This might return a coroutine if the filter is running from an
+        environment in async mode and the filter supports async
+        execution. It's your responsibility to await this if needed.
+
+        .. versionadded:: 2.7
+        """
+        return self._filter_test_common(
+            name, value, args, kwargs, context, eval_ctx, True
+        )
+
+    def call_test(
+        self,
+        name: str,
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]] = None,
+        kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+        context: t.Optional[Context] = None,
+        eval_ctx: t.Optional[EvalContext] = None,
+    ) -> t.Any:
+        """Invoke a test on a value the same way the compiler does.
+
+        This might return a coroutine if the test is running from an
+        environment in async mode and the test supports async execution.
+        It's your responsibility to await this if needed.
+
+        .. versionchanged:: 3.0
+            Tests support ``@pass_context``, etc. decorators. Added
+            the ``context`` and ``eval_ctx`` parameters.
+
+        .. versionadded:: 2.7
+        """
+        return self._filter_test_common(
+            name, value, args, kwargs, context, eval_ctx, False
+        )
+
+    @internalcode
+    def parse(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> nodes.Template:
+        """Parse the sourcecode and return the abstract syntax tree.  This
+        tree of nodes is used by the compiler to convert the template into
+        executable source- or bytecode.  This is useful for debugging or to
+        extract information from templates.
+
+        If you are :ref:`developing Jinja extensions `
+        this gives you a good overview of the node tree generated.
+        """
+        try:
+            return self._parse(source, name, filename)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source)
+
+    def _parse(
+        self, source: str, name: t.Optional[str], filename: t.Optional[str]
+    ) -> nodes.Template:
+        """Internal parsing function used by `parse` and `compile`."""
+        return Parser(self, source, name, filename).parse()
+
+    def lex(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> t.Iterator[t.Tuple[int, str, str]]:
+        """Lex the given sourcecode and return a generator that yields
+        tokens as tuples in the form ``(lineno, token_type, value)``.
+        This can be useful for :ref:`extension development `
+        and debugging templates.
+
+        This does not perform preprocessing.  If you want the preprocessing
+        of the extensions to be applied you have to filter source through
+        the :meth:`preprocess` method.
+        """
+        source = str(source)
+        try:
+            return self.lexer.tokeniter(source, name, filename)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source)
+
+    def preprocess(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> str:
+        """Preprocesses the source with all extensions.  This is automatically
+        called for all parsing and compiling methods but *not* for :meth:`lex`
+        because there you usually only want the actual source tokenized.
+        """
+        return reduce(
+            lambda s, e: e.preprocess(s, name, filename),
+            self.iter_extensions(),
+            str(source),
+        )
+
+    def _tokenize(
+        self,
+        source: str,
+        name: t.Optional[str],
+        filename: t.Optional[str] = None,
+        state: t.Optional[str] = None,
+    ) -> TokenStream:
+        """Called by the parser to do the preprocessing and filtering
+        for all the extensions.  Returns a :class:`~jinja2.lexer.TokenStream`.
+        """
+        source = self.preprocess(source, name, filename)
+        stream = self.lexer.tokenize(source, name, filename, state)
+
+        for ext in self.iter_extensions():
+            stream = ext.filter_stream(stream)  # type: ignore
+
+            if not isinstance(stream, TokenStream):
+                stream = TokenStream(stream, name, filename)
+
+        return stream
+
+    def _generate(
+        self,
+        source: nodes.Template,
+        name: t.Optional[str],
+        filename: t.Optional[str],
+        defer_init: bool = False,
+    ) -> str:
+        """Internal hook that can be overridden to hook a different generate
+        method in.
+
+        .. versionadded:: 2.5
+        """
+        return generate(  # type: ignore
+            source,
+            self,
+            name,
+            filename,
+            defer_init=defer_init,
+            optimized=self.optimized,
+        )
+
+    def _compile(self, source: str, filename: str) -> CodeType:
+        """Internal hook that can be overridden to hook a different compile
+        method in.
+
+        .. versionadded:: 2.5
+        """
+        return compile(source, filename, "exec")
+
+    @typing.overload
+    def compile(
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: "te.Literal[False]" = False,
+        defer_init: bool = False,
+    ) -> CodeType: ...
+
+    @typing.overload
+    def compile(
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: "te.Literal[True]" = ...,
+        defer_init: bool = False,
+    ) -> str: ...
+
+    @internalcode
+    def compile(
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: bool = False,
+        defer_init: bool = False,
+    ) -> t.Union[str, CodeType]:
+        """Compile a node or template source code.  The `name` parameter is
+        the load name of the template after it was joined using
+        :meth:`join_path` if necessary, not the filename on the file system.
+        the `filename` parameter is the estimated filename of the template on
+        the file system.  If the template came from a database or memory this
+        can be omitted.
+
+        The return value of this method is a python code object.  If the `raw`
+        parameter is `True` the return value will be a string with python
+        code equivalent to the bytecode returned otherwise.  This method is
+        mainly used internally.
+
+        `defer_init` is use internally to aid the module code generator.  This
+        causes the generated code to be able to import without the global
+        environment variable to be set.
+
+        .. versionadded:: 2.4
+           `defer_init` parameter added.
+        """
+        source_hint = None
+        try:
+            if isinstance(source, str):
+                source_hint = source
+                source = self._parse(source, name, filename)
+            source = self._generate(source, name, filename, defer_init=defer_init)
+            if raw:
+                return source
+            if filename is None:
+                filename = "