diff --git a/.gitattributes b/.gitattributes index 1ef325f1b111266a6b26e0196871bd78baa8c2f3..36da0921d82c09e91190722709a9b0d4cb6a0ef3 100644 --- a/.gitattributes +++ b/.gitattributes @@ -57,3 +57,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text # Video files - compressed *.mp4 filter=lfs diff=lfs merge=lfs -text *.webm filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/charset_normalizer/md.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/charset_normalizer/md__mypyc.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/huggingface_hub/__pycache__/hf_api.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/prompt_toolkit/layout/__pycache__/containers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.13/site-packages/hf_xet/hf_xet.abi3.so filter=lfs diff=lfs merge=lfs -text diff --git a/.venv/.gitignore b/.venv/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..f59ec20aabf5842d237244ece8c81ab184faeac1 --- /dev/null +++ b/.venv/.gitignore @@ -0,0 +1 @@ +* \ No newline at end of file diff --git a/.venv/.lock b/.venv/.lock new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/CACHEDIR.TAG b/.venv/CACHEDIR.TAG new file mode 100644 index 0000000000000000000000000000000000000000..bc1ecb967a482524e7736038de0df6e08f9ee452 --- /dev/null +++ b/.venv/CACHEDIR.TAG @@ -0,0 +1 @@ +Signature: 8a477f597d28d172789f06886806bc55 \ No newline at end of file diff --git a/.venv/bin/activate b/.venv/bin/activate new file mode 100644 index 0000000000000000000000000000000000000000..06fa28055d3ed53e5f61982ff8b0fd0b572ffc25 --- /dev/null +++ b/.venv/bin/activate @@ -0,0 +1,130 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +if ! [ -z "${SCRIPT_PATH+_}" ] ; then + _OLD_SCRIPT_PATH="$SCRIPT_PATH" +fi + +# Get script path (only used if environment is relocatable). +if [ -n "${BASH_VERSION:+x}" ] ; then + SCRIPT_PATH="${BASH_SOURCE[0]}" + if [ "$SCRIPT_PATH" = "$0" ]; then + # Only bash has a reasonably robust check for source'dness. + echo "You must source this script: \$ source $0" >&2 + exit 33 + fi +elif [ -n "${ZSH_VERSION:+x}" ] ; then + SCRIPT_PATH="${(%):-%x}" +elif [ -n "${KSH_VERSION:+x}" ] ; then + SCRIPT_PATH="${.sh.file}" +fi + +deactivate () { + unset -f pydoc >/dev/null 2>&1 || true + + # reset old environment variables + # ! [ -z ${VAR+_} ] returns true if VAR is declared at all + if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then + PATH="$_OLD_VIRTUAL_PATH" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then + PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # The hash command must be called to get it to forget past + # commands. Without forgetting past commands the $PATH changes + # we made may not be respected + hash -r 2>/dev/null + + if ! [ -z "${_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='/Users/patrickramos/Documents/npb_data_app_data/.venv' +if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then + VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV") +fi +export VIRTUAL_ENV + +# Unset the `SCRIPT_PATH` variable, now that the `VIRTUAL_ENV` variable +# has been set. This is important for relocatable environments. +if ! [ -z "${_OLD_SCRIPT_PATH+_}" ] ; then + SCRIPT_PATH="$_OLD_SCRIPT_PATH" + export SCRIPT_PATH + unset _OLD_SCRIPT_PATH +else + unset SCRIPT_PATH +fi + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +if [ "xnpb_data_app_data" != x ] ; then + VIRTUAL_ENV_PROMPT="(npb_data_app_data) " +else + VIRTUAL_ENV_PROMPT="($(basename "$VIRTUAL_ENV")) " +fi +export VIRTUAL_ENV_PROMPT + +# unset PYTHONHOME if set +if ! [ -z "${PYTHONHOME+_}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1-}" + PS1="${VIRTUAL_ENV_PROMPT}${PS1-}" + export PS1 +fi + +# Make sure to unalias pydoc if it's already there +alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true + +pydoc () { + python -m pydoc "$@" +} + +# The hash command must be called to get it to forget past +# commands. Without forgetting past commands the $PATH changes +# we made may not be respected +hash -r 2>/dev/null diff --git a/.venv/bin/activate.bat b/.venv/bin/activate.bat new file mode 100644 index 0000000000000000000000000000000000000000..2740314a14f6362a54cd55ebde12fef71a555bf9 --- /dev/null +++ b/.venv/bin/activate.bat @@ -0,0 +1,71 @@ +@REM Copyright (c) 2020-202x The virtualenv developers +@REM +@REM Permission is hereby granted, free of charge, to any person obtaining +@REM a copy of this software and associated documentation files (the +@REM "Software"), to deal in the Software without restriction, including +@REM without limitation the rights to use, copy, modify, merge, publish, +@REM distribute, sublicense, and/or sell copies of the Software, and to +@REM permit persons to whom the Software is furnished to do so, subject to +@REM the following conditions: +@REM +@REM The above copyright notice and this permission notice shall be +@REM included in all copies or substantial portions of the Software. +@REM +@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +@REM This file is UTF-8 encoded, so we need to update the current code page while executing it +@for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do @set _OLD_CODEPAGE=%%a +@if defined _OLD_CODEPAGE ( + @"%SystemRoot%\System32\chcp.com" 65001 > nul +) + +@for %%i in ("/Users/patrickramos/Documents/npb_data_app_data/.venv") do @set "VIRTUAL_ENV=%%~fi" + +@set "VIRTUAL_ENV_PROMPT=npb_data_app_data" +@if NOT DEFINED VIRTUAL_ENV_PROMPT ( + @for %%d in ("%VIRTUAL_ENV%") do @set "VIRTUAL_ENV_PROMPT=%%~nxd" +) + +@if defined _OLD_VIRTUAL_PROMPT ( + @set "PROMPT=%_OLD_VIRTUAL_PROMPT%" +) else ( + @if not defined PROMPT ( + @set "PROMPT=$P$G" + ) + @if not defined VIRTUAL_ENV_DISABLE_PROMPT ( + @set "_OLD_VIRTUAL_PROMPT=%PROMPT%" + ) +) +@if not defined VIRTUAL_ENV_DISABLE_PROMPT ( + @set "PROMPT=(%VIRTUAL_ENV_PROMPT%) %PROMPT%" +) + +@REM Don't use () to avoid problems with them in %PATH% +@if defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME + @set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%" +:ENDIFVHOME + +@set PYTHONHOME= + +@REM if defined _OLD_VIRTUAL_PATH ( +@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH1 + @set "PATH=%_OLD_VIRTUAL_PATH%" +:ENDIFVPATH1 +@REM ) else ( +@if defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH2 + @set "_OLD_VIRTUAL_PATH=%PATH%" +:ENDIFVPATH2 + +@set "PATH=%VIRTUAL_ENV%\bin;%PATH%" + +:END +@if defined _OLD_CODEPAGE ( + @"%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul + @set _OLD_CODEPAGE= +) diff --git a/.venv/bin/activate.csh b/.venv/bin/activate.csh new file mode 100644 index 0000000000000000000000000000000000000000..5789af572da9688f2cf3a8cb5b3370953f71c023 --- /dev/null +++ b/.venv/bin/activate.csh @@ -0,0 +1,76 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . + +set newline='\ +' + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV '/Users/patrickramos/Documents/npb_data_app_data/.venv' + +set _OLD_VIRTUAL_PATH="$PATH:q" +setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q" + + + +if ('npb_data_app_data' != "") then + setenv VIRTUAL_ENV_PROMPT 'npb_data_app_data' +else + setenv VIRTUAL_ENV_PROMPT "$VIRTUAL_ENV:t:q" +endif + +if ( $?VIRTUAL_ENV_DISABLE_PROMPT ) then + if ( $VIRTUAL_ENV_DISABLE_PROMPT == "" ) then + set do_prompt = "1" + else + set do_prompt = "0" + endif +else + set do_prompt = "1" +endif + +if ( $do_prompt == "1" ) then + # Could be in a non-interactive environment, + # in which case, $prompt is undefined and we wouldn't + # care about the prompt anyway. + if ( $?prompt ) then + set _OLD_VIRTUAL_PROMPT="$prompt:q" + if ( "$prompt:q" =~ *"$newline:q"* ) then + : + else + set prompt = '('"$VIRTUAL_ENV_PROMPT:q"') '"$prompt:q" + endif + endif +endif + +unset env_name +unset do_prompt + +alias pydoc python -m pydoc + +rehash diff --git a/.venv/bin/activate.fish b/.venv/bin/activate.fish new file mode 100644 index 0000000000000000000000000000000000000000..a7c810e9fa24606303763ba2898817c7736417b5 --- /dev/null +++ b/.venv/bin/activate.fish @@ -0,0 +1,124 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*. +# Do not run it directly. + +function _bashify_path -d "Converts a fish path to something bash can recognize" + set fishy_path $argv + set bashy_path $fishy_path[1] + for path_part in $fishy_path[2..-1] + set bashy_path "$bashy_path:$path_part" + end + echo $bashy_path +end + +function _fishify_path -d "Converts a bash path to something fish can recognize" + echo $argv | tr ':' '\n' +end + +function deactivate -d 'Exit virtualenv mode and return to the normal environment.' + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + # https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling + if test (echo $FISH_VERSION | head -c 1) -lt 3 + set -gx PATH (_fishify_path "$_OLD_VIRTUAL_PATH") + else + set -gx PATH $_OLD_VIRTUAL_PATH + end + 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" + and functions -q _old_fish_prompt + # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`. + set -l fish_function_path + + # Erase virtualenv's `fish_prompt` and restore the original. + functions -e fish_prompt + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + set -e _OLD_FISH_PROMPT_OVERRIDE + end + + set -e VIRTUAL_ENV + set -e VIRTUAL_ENV_PROMPT + + if test "$argv[1]" != 'nondestructive' + # Self-destruct! + functions -e pydoc + functions -e deactivate + functions -e _bashify_path + functions -e _fishify_path + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV '/Users/patrickramos/Documents/npb_data_app_data/.venv' + +# https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling +if test (echo $FISH_VERSION | head -c 1) -lt 3 + set -gx _OLD_VIRTUAL_PATH (_bashify_path $PATH) +else + set -gx _OLD_VIRTUAL_PATH $PATH +end +set -gx PATH "$VIRTUAL_ENV"'/bin' $PATH + +# Prompt override provided? +# If not, just use the environment name. +if test -n 'npb_data_app_data' + set -gx VIRTUAL_ENV_PROMPT 'npb_data_app_data' +else + set -gx VIRTUAL_ENV_PROMPT (basename "$VIRTUAL_ENV") +end + +# Unset `$PYTHONHOME` if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +function pydoc + python -m pydoc $argv +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # Copy the current `fish_prompt` function as `_old_fish_prompt`. + functions -c fish_prompt _old_fish_prompt + + function fish_prompt + # Run the user's prompt first; it might depend on (pipe)status. + set -l prompt (_old_fish_prompt) + + printf '(%s) ' $VIRTUAL_ENV_PROMPT + + string join -- \n $prompt # handle multi-line prompts + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" +end diff --git a/.venv/bin/activate.nu b/.venv/bin/activate.nu new file mode 100644 index 0000000000000000000000000000000000000000..32949ba9a55316ed5c7ff728cfcd7e4dad17614f --- /dev/null +++ b/.venv/bin/activate.nu @@ -0,0 +1,117 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +# virtualenv activation module +# Activate with `overlay use activate.nu` +# Deactivate with `deactivate`, as usual +# +# To customize the overlay name, you can call `overlay use activate.nu as foo`, +# but then simply `deactivate` won't work because it is just an alias to hide +# the "activate" overlay. You'd need to call `overlay hide foo` manually. + +export-env { + def is-string [x] { + ($x | describe) == 'string' + } + + def has-env [...names] { + $names | each {|n| + $n in $env + } | all {|i| $i == true} + } + + # Emulates a `test -z`, but better as it handles e.g 'false' + def is-env-true [name: string] { + if (has-env $name) { + # Try to parse 'true', '0', '1', and fail if not convertible + let parsed = (do -i { $env | get $name | into bool }) + if ($parsed | describe) == 'bool' { + $parsed + } else { + not ($env | get -i $name | is-empty) + } + } else { + false + } + } + + let virtual_env = '/Users/patrickramos/Documents/npb_data_app_data/.venv' + let bin = 'bin' + + let is_windows = ($nu.os-info.family) == 'windows' + let path_name = (if (has-env 'Path') { + 'Path' + } else { + 'PATH' + } + ) + + let venv_path = ([$virtual_env $bin] | path join) + let new_path = ($env | get $path_name | prepend $venv_path) + + # If there is no default prompt, then use the env name instead + let virtual_env_prompt = (if ('npb_data_app_data' | is-empty) { + ($virtual_env | path basename) + } else { + 'npb_data_app_data' + }) + + let new_env = { + $path_name : $new_path + VIRTUAL_ENV : $virtual_env + VIRTUAL_ENV_PROMPT : $virtual_env_prompt + } + + let new_env = (if (is-env-true 'VIRTUAL_ENV_DISABLE_PROMPT') { + $new_env + } else { + # Creating the new prompt for the session + let virtual_prefix = $'(char lparen)($virtual_env_prompt)(char rparen) ' + + # Back up the old prompt builder + let old_prompt_command = (if (has-env 'PROMPT_COMMAND') { + $env.PROMPT_COMMAND + } else { + '' + }) + + let new_prompt = (if (has-env 'PROMPT_COMMAND') { + if 'closure' in ($old_prompt_command | describe) { + {|| $'($virtual_prefix)(do $old_prompt_command)' } + } else { + {|| $'($virtual_prefix)($old_prompt_command)' } + } + } else { + {|| $'($virtual_prefix)' } + }) + + $new_env | merge { + PROMPT_COMMAND : $new_prompt + VIRTUAL_PREFIX : $virtual_prefix + } + }) + + # Environment variables that will be loaded as the virtual env + load-env $new_env +} + +export alias pydoc = python -m pydoc +export alias deactivate = overlay hide activate diff --git a/.venv/bin/activate.ps1 b/.venv/bin/activate.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..021f03835fa44a5927413cb25348a802c7f690fd --- /dev/null +++ b/.venv/bin/activate.ps1 @@ -0,0 +1,82 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +$script:THIS_PATH = $myinvocation.mycommand.path +$script:BASE_DIR = Split-Path (Resolve-Path "$THIS_PATH/..") -Parent + +function global:deactivate([switch] $NonDestructive) { + if (Test-Path variable:_OLD_VIRTUAL_PATH) { + $env:PATH = $variable:_OLD_VIRTUAL_PATH + Remove-Variable "_OLD_VIRTUAL_PATH" -Scope global + } + + if (Test-Path function:_old_virtual_prompt) { + $function:prompt = $function:_old_virtual_prompt + Remove-Item function:\_old_virtual_prompt + } + + if ($env:VIRTUAL_ENV) { + Remove-Item env:VIRTUAL_ENV -ErrorAction SilentlyContinue + } + + if ($env:VIRTUAL_ENV_PROMPT) { + Remove-Item env:VIRTUAL_ENV_PROMPT -ErrorAction SilentlyContinue + } + + if (!$NonDestructive) { + # Self destruct! + Remove-Item function:deactivate + Remove-Item function:pydoc + } +} + +function global:pydoc { + python -m pydoc $args +} + +# unset irrelevant variables +deactivate -nondestructive + +$VIRTUAL_ENV = $BASE_DIR +$env:VIRTUAL_ENV = $VIRTUAL_ENV + +if ("npb_data_app_data" -ne "") { + $env:VIRTUAL_ENV_PROMPT = "npb_data_app_data" +} +else { + $env:VIRTUAL_ENV_PROMPT = $( Split-Path $env:VIRTUAL_ENV -Leaf ) +} + +New-Variable -Scope global -Name _OLD_VIRTUAL_PATH -Value $env:PATH + +$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH +if (!$env:VIRTUAL_ENV_DISABLE_PROMPT) { + function global:_old_virtual_prompt { + "" + } + $function:_old_virtual_prompt = $function:prompt + + function global:prompt { + # Add the custom prefix to the existing prompt + $previous_prompt_value = & $function:_old_virtual_prompt + ("(" + $env:VIRTUAL_ENV_PROMPT + ") " + $previous_prompt_value) + } +} diff --git a/.venv/bin/activate_this.py b/.venv/bin/activate_this.py new file mode 100644 index 0000000000000000000000000000000000000000..471c656eb90bd9078803b86b85b9ad6622db73ca --- /dev/null +++ b/.venv/bin/activate_this.py @@ -0,0 +1,59 @@ +# Copyright (c) 2020-202x The virtualenv developers +# +# 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. + +""" +Activate virtualenv for current interpreter: + +import runpy +runpy.run_path(this_file) + +This can be used when you must use an existing Python interpreter, not the virtualenv bin/python. +""" # noqa: D415 + +from __future__ import annotations + +import os +import site +import sys + +try: + abs_file = os.path.abspath(__file__) +except NameError as exc: + msg = "You must use import runpy; runpy.run_path(this_file)" + raise AssertionError(msg) from exc + +bin_dir = os.path.dirname(abs_file) +base = bin_dir[: -len("bin") - 1] # strip away the bin part from the __file__, plus the path separator + +# prepend bin to PATH (this file is inside the bin directory) +os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)]) +os.environ["VIRTUAL_ENV"] = base # virtual env is right above bin directory +os.environ["VIRTUAL_ENV_PROMPT"] = "npb_data_app_data" or os.path.basename(base) # noqa: SIM222 + +# add the virtual environments libraries to the host python import mechanism +prev_length = len(sys.path) +for lib in "../lib/python3.13/site-packages".split(os.pathsep): + path = os.path.realpath(os.path.join(bin_dir, lib)) + site.addsitedir(path) +sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length] + +sys.real_prefix = sys.prefix +sys.prefix = base diff --git a/.venv/bin/deactivate.bat b/.venv/bin/deactivate.bat new file mode 100644 index 0000000000000000000000000000000000000000..07041bc45129994cbb4b338f6fb61aaf502571fb --- /dev/null +++ b/.venv/bin/deactivate.bat @@ -0,0 +1,39 @@ +@REM Copyright (c) 2020-202x The virtualenv developers +@REM +@REM Permission is hereby granted, free of charge, to any person obtaining +@REM a copy of this software and associated documentation files (the +@REM "Software"), to deal in the Software without restriction, including +@REM without limitation the rights to use, copy, modify, merge, publish, +@REM distribute, sublicense, and/or sell copies of the Software, and to +@REM permit persons to whom the Software is furnished to do so, subject to +@REM the following conditions: +@REM +@REM The above copyright notice and this permission notice shall be +@REM included in all copies or substantial portions of the Software. +@REM +@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +@set VIRTUAL_ENV= +@set VIRTUAL_ENV_PROMPT= + +@REM Don't use () to avoid problems with them in %PATH% +@if not defined _OLD_VIRTUAL_PROMPT @goto ENDIFVPROMPT + @set "PROMPT=%_OLD_VIRTUAL_PROMPT%" + @set _OLD_VIRTUAL_PROMPT= +:ENDIFVPROMPT + +@if not defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME + @set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%" + @set _OLD_VIRTUAL_PYTHONHOME= +:ENDIFVHOME + +@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH + @set "PATH=%_OLD_VIRTUAL_PATH%" + @set _OLD_VIRTUAL_PATH= +:ENDIFVPATH \ No newline at end of file diff --git a/.venv/bin/huggingface-cli b/.venv/bin/huggingface-cli new file mode 100644 index 0000000000000000000000000000000000000000..eb0b928fbcf1c75cc7b44dba477126767d31e2a0 --- /dev/null +++ b/.venv/bin/huggingface-cli @@ -0,0 +1,10 @@ +#!/Users/patrickramos/Documents/npb_data_app_data/.venv/bin/python3 +# -*- coding: utf-8 -*- +import sys +from huggingface_hub.commands.huggingface_cli import main +if __name__ == "__main__": + if sys.argv[0].endswith("-script.pyw"): + sys.argv[0] = sys.argv[0][:-11] + elif sys.argv[0].endswith(".exe"): + sys.argv[0] = sys.argv[0][:-4] + sys.exit(main()) diff --git a/.venv/bin/normalizer b/.venv/bin/normalizer new file mode 100644 index 0000000000000000000000000000000000000000..033c32c4771357ae1556639327a25505230301cd --- /dev/null +++ b/.venv/bin/normalizer @@ -0,0 +1,10 @@ +#!/Users/patrickramos/Documents/npb_data_app_data/.venv/bin/python3 +# -*- coding: utf-8 -*- +import sys +from charset_normalizer import cli +if __name__ == "__main__": + if sys.argv[0].endswith("-script.pyw"): + sys.argv[0] = sys.argv[0][:-11] + elif sys.argv[0].endswith(".exe"): + sys.argv[0] = sys.argv[0][:-4] + sys.exit(cli.cli_detect()) diff --git a/.venv/bin/pydoc.bat b/.venv/bin/pydoc.bat new file mode 100644 index 0000000000000000000000000000000000000000..daa20590b181e9f5a1f4f642f6c4eaf471cff00f --- /dev/null +++ b/.venv/bin/pydoc.bat @@ -0,0 +1,22 @@ +@REM Copyright (c) 2020-202x The virtualenv developers +@REM +@REM Permission is hereby granted, free of charge, to any person obtaining +@REM a copy of this software and associated documentation files (the +@REM "Software"), to deal in the Software without restriction, including +@REM without limitation the rights to use, copy, modify, merge, publish, +@REM distribute, sublicense, and/or sell copies of the Software, and to +@REM permit persons to whom the Software is furnished to do so, subject to +@REM the following conditions: +@REM +@REM The above copyright notice and this permission notice shall be +@REM included in all copies or substantial portions of the Software. +@REM +@REM THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +@REM EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +@REM MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +@REM NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +@REM LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +@REM OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +@REM WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +python.exe -m pydoc %* \ No newline at end of file diff --git a/.venv/bin/python b/.venv/bin/python new file mode 100644 index 0000000000000000000000000000000000000000..10331dc9981c5a8694cda947328771bcbafe23ca Binary files /dev/null and b/.venv/bin/python differ diff --git a/.venv/bin/python3 b/.venv/bin/python3 new file mode 100644 index 0000000000000000000000000000000000000000..10331dc9981c5a8694cda947328771bcbafe23ca Binary files /dev/null and b/.venv/bin/python3 differ diff --git a/.venv/bin/python3.13 b/.venv/bin/python3.13 new file mode 100644 index 0000000000000000000000000000000000000000..10331dc9981c5a8694cda947328771bcbafe23ca Binary files /dev/null and b/.venv/bin/python3.13 differ diff --git a/.venv/bin/tiny-agents b/.venv/bin/tiny-agents new file mode 100644 index 0000000000000000000000000000000000000000..2daf9060cd1fefc23532ce98b28902ef14929a79 --- /dev/null +++ b/.venv/bin/tiny-agents @@ -0,0 +1,10 @@ +#!/Users/patrickramos/Documents/npb_data_app_data/.venv/bin/python3 +# -*- coding: utf-8 -*- +import sys +from huggingface_hub.inference._mcp.cli import app +if __name__ == "__main__": + if sys.argv[0].endswith("-script.pyw"): + sys.argv[0] = sys.argv[0][:-11] + elif sys.argv[0].endswith(".exe"): + sys.argv[0] = sys.argv[0][:-4] + sys.exit(app()) diff --git a/.venv/bin/tqdm b/.venv/bin/tqdm new file mode 100644 index 0000000000000000000000000000000000000000..b8b09ba48cba8e7ab4d52a87872ac5ac70b6a889 --- /dev/null +++ b/.venv/bin/tqdm @@ -0,0 +1,10 @@ +#!/Users/patrickramos/Documents/npb_data_app_data/.venv/bin/python3 +# -*- coding: utf-8 -*- +import sys +from tqdm.cli import main +if __name__ == "__main__": + if sys.argv[0].endswith("-script.pyw"): + sys.argv[0] = sys.argv[0][:-11] + elif sys.argv[0].endswith(".exe"): + sys.argv[0] = sys.argv[0][:-4] + sys.exit(main()) diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__init__.py b/.venv/lib/python3.13/site-packages/InquirerPy/base/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fb6d176dd3069595accf314ad55e99cf17eb50a0 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/base/__init__.py @@ -0,0 +1,15 @@ +"""Module contains base class for prompts. + +BaseSimplePrompt ← InputPrompt ← SecretPrompt ... + ↑ +BaseComplexPrompt + ↑ +BaseListPrompt ← FuzzyPrompt + ↑ +ListPrompt ← ExpandPrompt ... +""" + +from .complex import BaseComplexPrompt, FakeDocument +from .control import Choice, InquirerPyUIListControl +from .list import BaseListPrompt +from .simple import BaseSimplePrompt diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5a645d2edcf3b99c33a0b460ee28891bc67547b Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/__init__.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/complex.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/complex.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8c88bdad0932b935c8e00effbe1330126c5f6bd Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/complex.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/control.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/control.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f26dc2dee1b7c559eb0afd06dc81b269602adf9 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/control.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/list.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9f5ae52bb0ad3cc6e056082224d1b96e51df2fd Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/list.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/simple.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/simple.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a3997e57edb55100ce93da5bb54cdf541e037136 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/base/__pycache__/simple.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/complex.py b/.venv/lib/python3.13/site-packages/InquirerPy/base/complex.py new file mode 100644 index 0000000000000000000000000000000000000000..89c9f73e3598a262ecf835145e5122e03ebac1e5 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/base/complex.py @@ -0,0 +1,294 @@ +"""Contains the interface class :class:`.BaseComplexPrompt` for more complex prompts and the mocked document class :class:`.FakeDocument`.""" +import shutil +from dataclasses import dataclass +from typing import Any, Callable, List, Optional, Tuple, Union + +from prompt_toolkit.application import Application +from prompt_toolkit.enums import EditingMode +from prompt_toolkit.filters.base import Condition, FilterOrBool +from prompt_toolkit.key_binding.key_bindings import KeyHandlerCallable +from prompt_toolkit.keys import Keys + +from InquirerPy.base.simple import BaseSimplePrompt +from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT +from InquirerPy.utils import ( + InquirerPySessionResult, + InquirerPyStyle, + InquirerPyValidate, +) + + +@dataclass +class FakeDocument: + """A fake `prompt_toolkit` document class. + + Work around to allow non-buffer type :class:`~prompt_toolkit.layout.UIControl` to use + :class:`~prompt_toolkit.validation.Validator`. + + Args: + text: Content to be validated. + cursor_position: Fake cursor position. + """ + + text: str + cursor_position: int = 0 + + +class BaseComplexPrompt(BaseSimplePrompt): + """A base class to create a more complex prompt that will involve :class:`~prompt_toolkit.application.Application`. + + Note: + This class does not create :class:`~prompt_toolkit.layout.Layout` nor :class:`~prompt_toolkit.application.Application`, + it only contains the necessary attributes and helper functions to be consumed. + + Note: + Use :class:`~InquirerPy.base.BaseListPrompt` to create a complex list prompt which involves multiple choices. It has + more methods and helper function implemented. + + See Also: + :class:`~InquirerPy.base.BaseListPrompt` + :class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt` + """ + + def __init__( + self, + message: Union[str, Callable[[InquirerPySessionResult], str]], + style: Optional[InquirerPyStyle] = None, + border: bool = False, + vi_mode: bool = False, + qmark: str = "?", + amark: str = "?", + instruction: str = "", + long_instruction: str = "", + transformer: Optional[Callable[[Any], Any]] = None, + filter: Optional[Callable[[Any], Any]] = None, + validate: Optional[InquirerPyValidate] = None, + invalid_message: str = "Invalid input", + wrap_lines: bool = True, + raise_keyboard_interrupt: bool = True, + mandatory: bool = True, + mandatory_message: str = "Mandatory prompt", + session_result: Optional[InquirerPySessionResult] = None, + ) -> None: + super().__init__( + message=message, + style=style, + vi_mode=vi_mode, + qmark=qmark, + amark=amark, + instruction=instruction, + transformer=transformer, + filter=filter, + invalid_message=invalid_message, + validate=validate, + wrap_lines=wrap_lines, + raise_keyboard_interrupt=raise_keyboard_interrupt, + mandatory=mandatory, + mandatory_message=mandatory_message, + session_result=session_result, + ) + self._invalid_message = invalid_message + self._rendered = False + self._invalid = False + self._loading = False + self._application: Application + self._long_instruction = long_instruction + self._border = border + self._height_offset = 2 # prev prompt result + current prompt question + if self._border: + self._height_offset += 2 + if self._long_instruction: + self._height_offset += 1 + self._validation_window_bottom_offset = 0 if not self._long_instruction else 1 + if self._wrap_lines: + self._validation_window_bottom_offset += ( + self.extra_long_instruction_line_count + ) + + self._is_vim_edit = Condition(lambda: self._editing_mode == EditingMode.VI) + self._is_invalid = Condition(lambda: self._invalid) + self._is_displaying_long_instruction = Condition( + lambda: self._long_instruction != "" + ) + + def _redraw(self) -> None: + """Redraw the application UI.""" + self._application.invalidate() + + def register_kb( + self, *keys: Union[Keys, str], filter: FilterOrBool = True + ) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]: + """Decorate keybinding registration function. + + Ensure that the `invalid` state is cleared on next keybinding entered. + """ + kb_dec = super().register_kb(*keys, filter=filter) + + def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable: + @kb_dec + def executable(event): + if self._invalid: + self._invalid = False + func(event) + + return executable + + return decorator + + def _exception_handler(self, _, context) -> None: + """Set exception handler for the event loop. + + Skip the question and raise exception. + + Args: + loop: Current event loop. + context: Exception context. + """ + self._status["answered"] = True + self._status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT + self._status["skipped"] = True + self._application.exit(exception=context["exception"]) + + def _after_render(self, app: Optional[Application]) -> None: + """Run after the :class:`~prompt_toolkit.application.Application` is rendered/updated. + + Since this function is fired up on each render, adding a check on `self._rendered` to + process logics that should only run once. + + Set event loop exception handler here, since its guaranteed that the event loop is running + in `_after_render`. + """ + if not self._rendered: + self._rendered = True + + self._keybinding_factory() + self._on_rendered(app) + + def _set_error(self, message: str) -> None: + """Set error message and set invalid state. + + Args: + message: Error message to display. + """ + self._invalid_message = message + self._invalid = True + + def _get_error_message(self) -> List[Tuple[str, str]]: + """Obtain the error message dynamically. + + Returns: + FormattedText in list of tuple format. + """ + return [ + ( + "class:validation-toolbar", + self._invalid_message, + ) + ] + + def _on_rendered(self, _: Optional[Application]) -> None: + """Run once after the UI is rendered. Acts like `ComponentDidMount`.""" + pass + + def _get_prompt_message(self) -> List[Tuple[str, str]]: + """Get the prompt message to display. + + Returns: + Formatted text in list of tuple format. + """ + pre_answer = ( + "class:instruction", + " %s " % self.instruction if self.instruction else " ", + ) + post_answer = ("class:answer", " %s" % self.status["result"]) + return super()._get_prompt_message(pre_answer, post_answer) + + def _run(self) -> Any: + """Run the application.""" + return self.application.run() + + async def _run_async(self) -> None: + """Run the application asynchronously.""" + return await self.application.run_async() + + @property + def application(self) -> Application: + """Get the application. + + :class:`.BaseComplexPrompt` requires :attr:`.BaseComplexPrompt._application` to be defined since this class + doesn't implement :class:`~prompt_toolkit.layout.Layout` and :class:`~prompt_toolkit.application.Application`. + + Raises: + NotImplementedError: When `self._application` is not defined. + """ + if not self._application: + raise NotImplementedError + return self._application + + @application.setter + def application(self, value: Application) -> None: + self._application = value + + @property + def height_offset(self) -> int: + """int: Height offset to apply.""" + if not self._wrap_lines: + return self._height_offset + return self.extra_line_count + self._height_offset + + @property + def total_message_length(self) -> int: + """int: Total length of the message.""" + total_message_length = 0 + if self._qmark: + total_message_length += len(self._qmark) + total_message_length += 1 # Extra space if qmark is present + total_message_length += len(str(self._message)) + total_message_length += 1 # Extra space between message and instruction + total_message_length += len(str(self._instruction)) + if self._instruction: + total_message_length += 1 # Extra space behind the instruction + return total_message_length + + @property + def extra_message_line_count(self) -> int: + """int: Get the extra lines created caused by line wrapping. + + Minus 1 on the totoal message length as we only want the extra line. + 24 // 24 will equal to 1 however we only want the value to be 1 when we have 25 char + which will create an extra line. + """ + term_width, _ = shutil.get_terminal_size() + return (self.total_message_length - 1) // term_width + + @property + def extra_long_instruction_line_count(self) -> int: + """int: Get the extra lines created caused by line wrapping. + + See Also: + :attr:`.BaseComplexPrompt.extra_message_line_count` + """ + if self._long_instruction: + term_width, _ = shutil.get_terminal_size() + return (len(self._long_instruction) - 1) // term_width + else: + return 0 + + @property + def extra_line_count(self) -> int: + """Get the extra lines created caused by line wrapping. + + Used mainly to calculate how much additional offset should be applied when getting + the height. + + Returns: + Total extra lines created due to line wrapping. + """ + result = 0 + + # message wrap + result += self.extra_message_line_count + # long instruction wrap + result += self.extra_long_instruction_line_count + + return result diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/control.py b/.venv/lib/python3.13/site-packages/InquirerPy/base/control.py new file mode 100644 index 0000000000000000000000000000000000000000..69cdc3803a22782a59f15f6dda6598d2f40640eb --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/base/control.py @@ -0,0 +1,227 @@ +"""Contains the content control class :class:`.InquirerPyUIListControl`.""" +from abc import abstractmethod +from dataclasses import asdict, dataclass +from typing import Any, Callable, Dict, List, Optional, Tuple, cast + +from prompt_toolkit.layout.controls import FormattedTextControl + +from InquirerPy.exceptions import InvalidArgument, RequiredKeyNotFound +from InquirerPy.separator import Separator +from InquirerPy.utils import InquirerPyListChoices, InquirerPySessionResult + +__all__ = ["Choice", "InquirerPyUIListControl"] + + +@dataclass +class Choice: + """Class to create choices for list type prompts. + + A simple dataclass that can be used as an alternate to using :class:`dict` + when working with choices. + + Args: + value: The value of the choice when user selects this choice. + name: The value that should be presented to the user prior/after selection of the choice. + This value is optional, if not provided, it will fallback to the string representation of `value`. + enabled: Indicates if the choice should be pre-selected. + This only has effects when the prompt has `multiselect` enabled. + """ + + value: Any + name: Optional[str] = None + enabled: bool = False + + def __post_init__(self): + """Assign strinify value to name if not present.""" + if self.name is None: + self.name = str(self.value) + + +class InquirerPyUIListControl(FormattedTextControl): + """A base class to create :class:`~prompt_toolkit.layout.UIControl` to display list type contents. + + Args: + choices(InquirerPyListChoices): List of choices to display as the content. + Can also be a callable or async callable that returns a list of choices. + default: Default value, this will affect the cursor position. + multiselect: Indicate if the current prompt has `multiselect` enabled. + session_result: Current session result. + """ + + def __init__( + self, + choices: InquirerPyListChoices, + default: Any = None, + multiselect: bool = False, + session_result: Optional[InquirerPySessionResult] = None, + ) -> None: + self._session_result = session_result or {} + self._selected_choice_index: int = 0 + self._choice_func = None + self._multiselect = multiselect + self._default = ( + default + if not isinstance(default, Callable) + else cast(Callable, default)(self._session_result) + ) + self._raw_choices = ( + choices + if not isinstance(choices, Callable) + else cast(Callable, choices)(self._session_result) + ) + self._choices = self._get_choices(self._raw_choices, self._default) + self._safety_check() + self._format_choices() + super().__init__(self._get_formatted_choices) + + def _get_choices(self, choices: List[Any], default: Any) -> List[Dict[str, Any]]: + """Process the raw user input choices and format it into dictionary. + + Args: + choices: List of chices to display. + default: Default value, this will affect the :attr:`.InquirerPyUIListControl.selected_choice_index` + + Returns: + List of choices. + + Raises: + RequiredKeyNotFound: When the provided choice is missing the `name` or `value` key. + """ + processed_choices: List[Dict[str, Any]] = [] + try: + for index, choice in enumerate(choices, start=0): + if isinstance(choice, dict): + if choice["value"] == default: + self.selected_choice_index = index + processed_choices.append( + { + "name": str(choice["name"]), + "value": choice["value"], + "enabled": choice.get("enabled", False) + if self._multiselect + else False, + } + ) + elif isinstance(choice, Separator): + if self.selected_choice_index == index: + self.selected_choice_index = ( + self.selected_choice_index + 1 + ) % len(choices) + processed_choices.append( + {"name": str(choice), "value": choice, "enabled": False} + ) + elif isinstance(choice, Choice): + dict_choice = asdict(choice) + if dict_choice["value"] == default: + self.selected_choice_index = index + if not self._multiselect: + dict_choice["enabled"] = False + processed_choices.append(dict_choice) + else: + if choice == default: + self.selected_choice_index = index + processed_choices.append( + {"name": str(choice), "value": choice, "enabled": False} + ) + except KeyError: + raise RequiredKeyNotFound( + "dictionary type of choice require a 'name' key and a 'value' key" + ) + return processed_choices + + @property + def selected_choice_index(self) -> int: + """int: Current highlighted index.""" + return self._selected_choice_index + + @selected_choice_index.setter + def selected_choice_index(self, value: int) -> None: + self._selected_choice_index = value + + @property + def choices(self) -> List[Dict[str, Any]]: + """List[Dict[str, Any]]: Get all processed choices.""" + return self._choices + + @choices.setter + def choices(self, value: List[Dict[str, Any]]) -> None: + self._choices = value + + def _safety_check(self) -> None: + """Validate processed choices. + + Check if the choices are empty or if it only contains :class:`~InquirerPy.separator.Separator`. + """ + if not self.choices: + raise InvalidArgument("argument choices cannot be empty") + should_proceed: bool = False + for choice in self.choices: + if not isinstance(choice["value"], Separator): + should_proceed = True + break + if not should_proceed: + raise InvalidArgument( + "argument choices should contain choices other than separator" + ) + + def _get_formatted_choices(self) -> List[Tuple[str, str]]: + """Get all choices in formatted text format. + + Returns: + List of choices in formatted text form. + """ + display_choices = [] + + for index, choice in enumerate(self.choices): + if index == self.selected_choice_index: + display_choices += self._get_hover_text(choice) + else: + display_choices += self._get_normal_text(choice) + display_choices.append(("", "\n")) + if display_choices: + display_choices.pop() + return display_choices + + def _format_choices(self) -> None: + """Perform post processing on the choices. + + Additional customisation to the choices after :meth:`.InquirerPyUIListControl._get_choices` call. + """ + pass + + @abstractmethod + def _get_hover_text(self, choice) -> List[Tuple[str, str]]: + """Generate the formatted text for hovered choice. + + Returns: + Formatted text in list of tuple format. + """ + pass + + @abstractmethod + def _get_normal_text(self, choice) -> List[Tuple[str, str]]: + """Generate the formatted text for non-hovered choices. + + Returns: + Formatted text in list of tuple format. + """ + pass + + @property + def choice_count(self) -> int: + """int: Total count of choices.""" + return len(self.choices) + + @property + def selection(self) -> Dict[str, Any]: + """Dict[str, Any]: Current selected choice.""" + return self.choices[self.selected_choice_index] + + @property + def loading(self) -> bool: + """bool: Indicate if the content control is loading.""" + return self._loading + + @loading.setter + def loading(self, value: bool) -> None: + self._loading = value diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/list.py b/.venv/lib/python3.13/site-packages/InquirerPy/base/list.py new file mode 100644 index 0000000000000000000000000000000000000000..77f06aab5a8787eee8c54d3356515fc7ba30ec82 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/base/list.py @@ -0,0 +1,238 @@ +"""Contains the base class :class:`.BaseListPrompt` which can be used to create a prompt involving choices.""" +from abc import abstractmethod +from typing import Any, Callable, List, Optional + +from prompt_toolkit.filters.base import Condition +from prompt_toolkit.keys import Keys + +from InquirerPy.base.complex import BaseComplexPrompt +from InquirerPy.base.control import InquirerPyUIListControl +from InquirerPy.separator import Separator +from InquirerPy.utils import ( + InquirerPyKeybindings, + InquirerPyMessage, + InquirerPySessionResult, + InquirerPyStyle, + InquirerPyValidate, +) + + +class BaseListPrompt(BaseComplexPrompt): + """A base class to create a complex prompt involving choice selections (i.e. list) using `prompt_toolkit` Application. + + Note: + This class does not create :class:`~prompt_toolkit.layout.Layout` nor :class:`~prompt_toolkit.application.Application`, + it only contains the necessary attributes and helper functions to be consumed. + + See Also: + :class:`~InquirerPy.prompts.list.ListPrompt` + :class:`~InquirerPy.prompts.fuzzy.FuzzyPrompt` + """ + + def __init__( + self, + message: InquirerPyMessage, + style: Optional[InquirerPyStyle] = None, + vi_mode: bool = False, + qmark: str = "?", + amark: str = "?", + instruction: str = "", + long_instruction: str = "", + border: bool = False, + transformer: Optional[Callable[[Any], Any]] = None, + filter: Optional[Callable[[Any], Any]] = None, + validate: Optional[InquirerPyValidate] = None, + invalid_message: str = "Invalid input", + multiselect: bool = False, + keybindings: Optional[InquirerPyKeybindings] = None, + cycle: bool = True, + wrap_lines: bool = True, + raise_keyboard_interrupt: bool = True, + mandatory: bool = True, + mandatory_message: str = "Mandatory prompt", + session_result: Optional[InquirerPySessionResult] = None, + ) -> None: + super().__init__( + message=message, + style=style, + border=border, + vi_mode=vi_mode, + qmark=qmark, + amark=amark, + transformer=transformer, + filter=filter, + invalid_message=invalid_message, + validate=validate, + instruction=instruction, + long_instruction=long_instruction, + wrap_lines=wrap_lines, + raise_keyboard_interrupt=raise_keyboard_interrupt, + mandatory=mandatory, + mandatory_message=mandatory_message, + session_result=session_result, + ) + + self._content_control: InquirerPyUIListControl + self._multiselect = multiselect + self._is_multiselect = Condition(lambda: self._multiselect) + self._cycle = cycle + + if not keybindings: + keybindings = {} + + self.kb_maps = { + "down": [ + {"key": "down"}, + {"key": "c-n", "filter": ~self._is_vim_edit}, + {"key": "j", "filter": self._is_vim_edit}, + ], + "up": [ + {"key": "up"}, + {"key": "c-p", "filter": ~self._is_vim_edit}, + {"key": "k", "filter": self._is_vim_edit}, + ], + "toggle": [ + {"key": "space"}, + ], + "toggle-down": [ + {"key": Keys.Tab}, + ], + "toggle-up": [ + {"key": Keys.BackTab}, + ], + "toggle-all": [ + {"key": "alt-r"}, + {"key": "c-r"}, + ], + "toggle-all-true": [ + {"key": "alt-a"}, + {"key": "c-a"}, + ], + "toggle-all-false": [], + **keybindings, + } + + self.kb_func_lookup = { + "down": [{"func": self._handle_down}], + "up": [{"func": self._handle_up}], + "toggle": [{"func": self._handle_toggle_choice}], + "toggle-down": [ + {"func": self._handle_toggle_choice}, + {"func": self._handle_down}, + ], + "toggle-up": [ + {"func": self._handle_toggle_choice}, + {"func": self._handle_up}, + ], + "toggle-all": [{"func": self._handle_toggle_all}], + "toggle-all-true": [{"func": self._handle_toggle_all, "args": [True]}], + "toggle-all-false": [{"func": self._handle_toggle_all, "args": [False]}], + } + + @property + def content_control(self) -> InquirerPyUIListControl: + """Get the content controller object. + + Needs to be an instance of :class:`~InquirerPy.base.control.InquirerPyUIListControl`. + + Each :class:`.BaseComplexPrompt` requires a `content_control` to display custom + contents for the prompt. + + Raises: + NotImplementedError: When `self._content_control` is not found. + """ + if not self._content_control: + raise NotImplementedError + return self._content_control + + @content_control.setter + def content_control(self, value: InquirerPyUIListControl) -> None: + self._content_control = value + + @property + def result_name(self) -> Any: + """Get the result value that should be printed to the terminal. + + In multiselect scenario, return result as a list. + """ + if self._multiselect: + return [choice["name"] for choice in self.selected_choices] + else: + try: + return self.content_control.selection["name"] + except IndexError: + return "" + + @property + def result_value(self) -> Any: + """Get the result value that should return to the user. + + In multiselect scenario, return result as a list. + """ + if self._multiselect: + return [choice["value"] for choice in self.selected_choices] + else: + try: + return self.content_control.selection["value"] + except IndexError: + return "" + + @property + def selected_choices(self) -> List[Any]: + """List[Any]: Get all user selected choices.""" + + def filter_choice(choice): + return not isinstance(choice, Separator) and choice["enabled"] + + return list(filter(filter_choice, self.content_control.choices)) + + def _handle_down(self, _) -> bool: + """Handle event when user attempts to move down. + + Returns: + Boolean indicating if the action hits the cap. + """ + if self._cycle: + self.content_control.selected_choice_index = ( + self.content_control.selected_choice_index + 1 + ) % self.content_control.choice_count + return False + else: + self.content_control.selected_choice_index += 1 + if ( + self.content_control.selected_choice_index + >= self.content_control.choice_count + ): + self.content_control.selected_choice_index = ( + self.content_control.choice_count - 1 + ) + return True + return False + + def _handle_up(self, _) -> bool: + """Handle event when user attempts to move up. + + Returns: + Boolean indicating if the action hits the cap. + """ + if self._cycle: + self.content_control.selected_choice_index = ( + self.content_control.selected_choice_index - 1 + ) % self.content_control.choice_count + return False + else: + self.content_control.selected_choice_index -= 1 + if self.content_control.selected_choice_index < 0: + self.content_control.selected_choice_index = 0 + return True + return False + + @abstractmethod + def _handle_toggle_choice(self, event) -> None: + """Handle event when user attempting to toggle the state of the chocie.""" + pass + + @abstractmethod + def _handle_toggle_all(self, event, value: bool) -> None: + """Handle event when user attempting to alter the state of all choices.""" + pass diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/base/simple.py b/.venv/lib/python3.13/site-packages/InquirerPy/base/simple.py new file mode 100644 index 0000000000000000000000000000000000000000..de695bfe18c8ffa0f3b6fa6ba8898470b5e0ce74 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/base/simple.py @@ -0,0 +1,378 @@ +"""Contains the base class :class:`.BaseSimplePrompt`.""" +import os +import re +from abc import ABC, abstractmethod +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Dict, + List, + Optional, + Tuple, + Union, + cast, +) + +from prompt_toolkit.enums import EditingMode +from prompt_toolkit.filters.base import Condition, FilterOrBool +from prompt_toolkit.key_binding.key_bindings import KeyBindings, KeyHandlerCallable +from prompt_toolkit.keys import Keys +from prompt_toolkit.styles.style import Style +from prompt_toolkit.validation import Validator + +from InquirerPy.enum import INQUIRERPY_KEYBOARD_INTERRUPT +from InquirerPy.exceptions import RequiredKeyNotFound +from InquirerPy.utils import ( + InquirerPyMessage, + InquirerPySessionResult, + InquirerPyStyle, + InquirerPyValidate, + get_style, +) + +if TYPE_CHECKING: + from prompt_toolkit.key_binding.key_processor import KeyPressEvent + + +class BaseSimplePrompt(ABC): + """The base class to create a simple terminal input prompt. + + Note: + No actual :class:`~prompt_toolkit.application.Application` is created by this class. + This class only creates some common interface and attributes that can be easily used + by `prompt_toolkit`. + + To have a functional prompt, you'll at least have to implement the :meth:`.BaseSimplePrompt._run` + and :meth:`.BaseSimplePrompt._get_prompt_message`. + + See Also: + :class:`~InquirerPy.prompts.input.InputPrompt` + """ + + def __init__( + self, + message: InquirerPyMessage, + style: Optional[InquirerPyStyle] = None, + vi_mode: bool = False, + qmark: str = "?", + amark: str = "?", + instruction: str = "", + validate: Optional[InquirerPyValidate] = None, + invalid_message: str = "Invalid input", + transformer: Optional[Callable[[Any], Any]] = None, + filter: Optional[Callable[[Any], Any]] = None, + default: Any = "", + wrap_lines: bool = True, + raise_keyboard_interrupt: bool = True, + mandatory: bool = True, + mandatory_message: str = "Mandatory prompt", + session_result: Optional[InquirerPySessionResult] = None, + ) -> None: + self._mandatory = mandatory + self._mandatory_message = mandatory_message + self._result = session_result or {} + self._message = ( + message + if not isinstance(message, Callable) + else cast(Callable, message)(self._result) + ) + self._instruction = instruction + self._default = ( + default if not isinstance(default, Callable) else default(self._result) + ) + self._style = Style.from_dict(style.dict if style else get_style().dict) + self._qmark = qmark + self._amark = amark + self._status = {"answered": False, "result": None, "skipped": False} + self._kb = KeyBindings() + self._lexer = "class:input" + self._transformer = transformer + self._filter = filter + self._wrap_lines = wrap_lines + self._editing_mode = ( + EditingMode.VI + if vi_mode or bool(os.getenv("INQUIRERPY_VI_MODE", False)) + else EditingMode.EMACS + ) + if isinstance(validate, Validator): + self._validator = validate + else: + self._validator = Validator.from_callable( + validate if validate else lambda _: True, + invalid_message, + move_cursor_to_end=True, + ) + self._raise_kbi = not os.getenv( + "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt + ) + self._is_rasing_kbi = Condition(lambda: self._raise_kbi) + + self._kb_maps = { + "answer": [{"key": Keys.Enter}], + "interrupt": [ + {"key": "c-c", "filter": self._is_rasing_kbi}, + {"key": "c-d", "filter": ~self._is_rasing_kbi}, + ], + "skip": [{"key": "c-z"}, {"key": "c-c", "filter": ~self._is_rasing_kbi}], + } + self._kb_func_lookup = { + "answer": [{"func": self._handle_enter}], + "interrupt": [{"func": self._handle_interrupt}], + "skip": [{"func": self._handle_skip}], + } + + def _keybinding_factory(self): + """Register all keybindings in `self._kb_maps`. + + It's required to call this function at the end of prompt constructor if + it inherits from :class:`~InquirerPy.base.simple.BaseSimplePrompt` or + :class:`~InquirerPy.base.complex.BaseComplexPrompt`. + """ + + def _factory(keys, filter, action): + if action not in self.kb_func_lookup: + raise RequiredKeyNotFound(f"keybinding action {action} not found") + if not isinstance(keys, list): + keys = [keys] + + @self.register_kb(*keys, filter=filter) + def _(event): + for method in self.kb_func_lookup[action]: + method["func"](event, *method.get("args", [])) + + for key, item in self.kb_maps.items(): + if not isinstance(item, list): + item = [item] + for kb in item: + _factory(kb["key"], kb.get("filter", Condition(lambda: True)), key) + + @abstractmethod + def _set_error(self, message: str) -> None: + """Set the error message for the prompt. + + Args: + message: Error message to set. + """ + pass + + def _handle_skip(self, event: Optional["KeyPressEvent"]) -> None: + """Handle the event when attempting to skip a prompt. + + Skip the prompt if the `_mandatory` field is False, otherwise + show an error message that the prompt cannot be skipped. + """ + if not self._mandatory: + self.status["answered"] = True + self.status["skipped"] = True + self.status["result"] = None + if event: + event.app.exit(result=None) + else: + self._set_error(message=self._mandatory_message) + + def _handle_interrupt(self, event: Optional["KeyPressEvent"]) -> None: + """Handle the event when a KeyboardInterrupt signal is sent.""" + self.status["answered"] = True + self.status["result"] = INQUIRERPY_KEYBOARD_INTERRUPT + self.status["skipped"] = True + if event: + event.app.exit(result=INQUIRERPY_KEYBOARD_INTERRUPT) + + @abstractmethod + def _handle_enter(self, event: Optional["KeyPressEvent"]) -> None: + """Handle the event when user attempt to answer the question.""" + pass + + @property + def status(self) -> Dict[str, Any]: + """Dict[str, Any]: Get current prompt status. + + The status contains 3 keys: "answered" and "result". + answered: If the current prompt is answered. + result: The result of the user answer. + skipped: If the prompt is skipped. + """ + return self._status + + @status.setter + def status(self, value) -> None: + self._status = value + + def register_kb( + self, *keys: Union[Keys, str], filter: FilterOrBool = True, **kwargs + ) -> Callable[[KeyHandlerCallable], KeyHandlerCallable]: + """Keybinding registration decorator. + + This decorator wraps around the :meth:`prompt_toolkit.key_binding.KeyBindings.add` with + added feature to process `alt` realted keybindings. + + By default, `prompt_toolkit` doesn't process `alt` related keybindings, + it requires `alt-ANY` to `escape` + `ANY`. + + Args: + keys: The keys to bind that can trigger the function. + filter: :class:`~prompt_toolkit.filter.Condition` to indicate if this keybinding should be active. + + Returns: + A decorator that should be applied to the function thats intended to be active when the keys + are pressed. + + Examples: + >>> @self.register_kb("alt-j") + ... def test(event): + ... pass + """ + alt_pattern = re.compile(r"^alt-(.*)") + + def decorator(func: KeyHandlerCallable) -> KeyHandlerCallable: + formatted_keys = [] + for key in keys: + match = alt_pattern.match(key) + if match: + formatted_keys.append("escape") + formatted_keys.append(match.group(1)) + else: + formatted_keys.append(key) + + @self._kb.add(*formatted_keys, filter=filter, **kwargs) + def executable(event) -> None: + func(event) + + return executable + + return decorator + + @abstractmethod + def _get_prompt_message( + self, pre_answer: Tuple[str, str], post_answer: Tuple[str, str] + ) -> List[Tuple[str, str]]: + """Get the question message in formatted text form to display in the prompt. + + This function is mainly used to render the question message dynamically based + on the current status (answered or not answered) of the prompt. + + Note: + The function requires implementation when inheriting :class:`.BaseSimplePrompt`. + You should call `super()._get_prompt_message(pre_answer, post_answer)` in + the implemented `_get_prompt_message`. + + Args: + pre_answer: The message to display before the question is answered. + post_answer: The information to display after the question is answered. + + Returns: + Formatted text in list of tuple format. + """ + display_message = [] + if self.status["skipped"]: + display_message.append(("class:skipped", self._qmark)) + display_message.append( + ("class:skipped", "%s%s " % (" " if self._qmark else "", self._message)) + ) + elif self.status["answered"]: + display_message.append(("class:answermark", self._amark)) + display_message.append( + ( + "class:answered_question", + "%s%s" % (" " if self._amark else "", self._message), + ) + ) + display_message.append( + post_answer + if not self._transformer + else ( + "class:answer", + " %s" % self._transformer(self.status["result"]), + ) + ) + else: + display_message.append(("class:questionmark", self._qmark)) + display_message.append( + ( + "class:question", + "%s%s" % (" " if self._qmark else "", self._message), + ) + ) + display_message.append(pre_answer) + return display_message + + @abstractmethod + def _run(self) -> Any: + """Abstractmethod to enforce a run function is implemented. + + All prompt instance requires a `_run` call to initialise and run an instance of + `PromptSession` or `Application`. + """ + pass + + @abstractmethod + async def _run_async(self) -> Any: + """Abstractmethod to enforce a run function is implemented. + + All prompt instance requires a `_run_async` call to initialise and run an instance of + `PromptSession` or `Application`. + """ + pass + + def execute(self, raise_keyboard_interrupt: Optional[bool] = None) -> Any: + """Run the prompt and get the result. + + Args: + raise_keyboard_interrupt: **Deprecated**. Set this parameter on the prompt initialisation instead. + + Returns: + Value of the user answer. Types varies depending on the prompt. + + Raises: + KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True. + """ + result = self._run() + if raise_keyboard_interrupt is not None: + self._raise_kbi = not os.getenv( + "INQUIRERPY_NO_RAISE_KBI", not raise_keyboard_interrupt + ) + if result == INQUIRERPY_KEYBOARD_INTERRUPT: + raise KeyboardInterrupt + if not self._filter: + return result + return self._filter(result) + + async def execute_async(self) -> None: + """Run the prompt asynchronously and get the result. + + Returns: + Value of the user answer. Types varies depending on the prompt. + + Raises: + KeyboardInterrupt: When `ctrl-c` is pressed and `raise_keyboard_interrupt` is True. + """ + result = await self._run_async() + if result == INQUIRERPY_KEYBOARD_INTERRUPT: + raise KeyboardInterrupt + if not self._filter: + return result + return self._filter(result) + + @property + def instruction(self) -> str: + """str: Instruction to display next to question.""" + return self._instruction + + @property + def kb_maps(self) -> Dict[str, Any]: + """Dict[str, Any]: Keybinding mappings.""" + return self._kb_maps + + @kb_maps.setter + def kb_maps(self, value: Dict[str, Any]) -> None: + self._kb_maps = {**self._kb_maps, **value} + + @property + def kb_func_lookup(self) -> Dict[str, Any]: + """Dict[str, Any]: Keybinding function lookup mappings..""" + return self._kb_func_lookup + + @kb_func_lookup.setter + def kb_func_lookup(self, value: Dict[str, Any]) -> None: + self._kb_func_lookup = {**self._kb_func_lookup, **value} diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1aeba1c2ec00440d262cbbad4c94fb9316dc00b Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/__init__.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/instruction.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/instruction.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a1080e215c87b19f13ae9ab28337967bda005c3 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/instruction.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/message.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/message.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f547b51371d40199c54d9ac5fe6ca2a2f5d02c6 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/message.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/spinner.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/spinner.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79ca888d2b6f3a75d4f88430ca7a64fa6207831e Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/spinner.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/validation.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/validation.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e47c5aadcc0b9ba52bb5e8bde6796a126f01834a Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/containers/__pycache__/validation.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/spinner.py b/.venv/lib/python3.13/site-packages/InquirerPy/containers/spinner.py new file mode 100644 index 0000000000000000000000000000000000000000..47be0a0a08ae8ec4f80a1f7584776234b580cc0a --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/containers/spinner.py @@ -0,0 +1,108 @@ +"""Module contains spinner related resources. + +Note: + The spinner is not a standalone spinner to run in the terminal + but rather a `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner. + + Use library such as `yaspin `_ if you need a plain spinner. +""" +import asyncio +from typing import TYPE_CHECKING, Callable, List, NamedTuple, Optional, Tuple, Union + +from prompt_toolkit.filters.utils import to_filter +from prompt_toolkit.layout.containers import ConditionalContainer, Window +from prompt_toolkit.layout.controls import FormattedTextControl + +if TYPE_CHECKING: + from prompt_toolkit.filters.base import Filter + +__all__ = ["SPINNERS", "SpinnerWindow"] + + +class SPINNERS(NamedTuple): + """Presets of spinner patterns. + + See Also: + https://github.com/pavdmyt/yaspin/blob/master/yaspin/data/spinners.json + + This only contains some basic ones thats ready to use. For more patterns, checkout the + URL above. + + Examples: + >>> from InquirerPy import inquirer + >>> from InquirerPy.spinner import SPINNERS + >>> inquirer.select(message="", choices=lambda _: [1, 2, 3], spinner_pattern=SPINNERS.dots) + """ + + dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] + dots2 = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"] + line = ["-", "\\", "|", "/"] + line2 = ["⠂", "-", "–", "—", "–", "-"] + pipe = ["┤", "┘", "┴", "└", "├", "┌", "┬", "┐"] + star = ["✶", "✸", "✹", "✺", "✹", "✷"] + star2 = ["+", "x", "*"] + flip = ["_", "_", "_", "-", "`", "`", "'", "´", "-", "_", "_", "_"] + hamburger = ["☱", "☲", "☴"] + grow_vertical = ["▁", "▃", "▄", "▅", "▆", "▇", "▆", "▅", "▄", "▃"] + grow_horizontal = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "▊", "▋", "▌", "▍", "▎"] + box_bounce = ["▖", "▘", "▝", "▗"] + triangle = ["◢", "◣", "◤", "◥"] + arc = ["◜", "◠", "◝", "◞", "◡", "◟"] + circle = ["◡", "⊙", "◠"] + + +class SpinnerWindow(ConditionalContainer): + """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays a spinner. + + Args: + loading: A :class:`~prompt_toolkit.filters.Condition` to indicate if the spinner should be visible. + redraw: A redraw function (i.e. :meth:`~prompt_toolkit.application.Application.invalidate`) to refresh the UI. + pattern: List of pattern to display as the spinner. + delay: Spinner refresh frequency. + text: Loading text to display. + """ + + def __init__( + self, + loading: "Filter", + redraw: Callable[[], None], + pattern: Optional[Union[List[str], SPINNERS]] = None, + delay: float = 0.1, + text: str = "", + ) -> None: + self._loading = to_filter(loading) + self._spinning = False + self._redraw = redraw + self._pattern = pattern or SPINNERS.line + self._char = self._pattern[0] + self._delay = delay + self._text = text or "Loading ..." + + super().__init__( + content=Window(content=FormattedTextControl(text=self._get_text)), + filter=self._loading, + ) + + def _get_text(self) -> List[Tuple[str, str]]: + """Dynamically get the text for the :class:`~prompt_toolkit.layout.Window`. + + Returns: + Formatted text. + """ + return [ + ("class:spinner_pattern", self._char), + ("", " "), + ("class:spinner_text", self._text), + ] + + async def start(self) -> None: + """Start the spinner.""" + if self._spinning: + return + self._spinning = True + while self._loading(): + for char in self._pattern: + await asyncio.sleep(self._delay) + self._char = char + self._redraw() + self._spinning = False diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/containers/validation.py b/.venv/lib/python3.13/site-packages/InquirerPy/containers/validation.py new file mode 100644 index 0000000000000000000000000000000000000000..32dca31b44558a17b1b1ed8d64df06fabda892b1 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/containers/validation.py @@ -0,0 +1,60 @@ +"""Module contains :class:`.ValidationWindow` which can be used to display error.""" + +from typing import Optional + +from prompt_toolkit.filters.base import FilterOrBool +from prompt_toolkit.formatted_text.base import AnyFormattedText +from prompt_toolkit.layout.containers import ConditionalContainer, Float, Window +from prompt_toolkit.layout.controls import FormattedTextControl + + +class ValidationWindow(ConditionalContainer): + """Conditional `prompt_toolkit` :class:`~prompt_toolkit.layout.Window` that displays error. + + Args: + invalid_message: Error message to display when error occured. + filter: Condition to display the error window. + """ + + def __init__( + self, invalid_message: AnyFormattedText, filter: FilterOrBool, **kwargs + ) -> None: + super().__init__( + Window( + FormattedTextControl(invalid_message), dont_extend_height=True, **kwargs + ), + filter=filter, + ) + + +class ValidationFloat(Float): + """:class:`~prompt_toolkit.layout.Float` wrapper around :class:`.ValidationWindow`. + + Args: + invalid_message: Error message to display when error occured. + filter: Condition to display the error window. + left: Distance to left. + right: Distance to right. + bottom: Distance to bottom. + top: Distance to top. + """ + + def __init__( + self, + invalid_message: AnyFormattedText, + filter: FilterOrBool, + left: Optional[int] = None, + right: Optional[int] = None, + bottom: Optional[int] = None, + top: Optional[int] = None, + **kwargs + ) -> None: + super().__init__( + content=ValidationWindow( + invalid_message=invalid_message, filter=filter, **kwargs + ), + left=left, + right=right, + bottom=bottom, + top=top, + ) diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ea9db27d5b99067ac4bd4009ccc0d1131f6858f Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/__init__.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/checkbox.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/checkbox.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c931a92cbb5bb2979297c01155cd86592ff53e8 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/checkbox.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/confirm.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/confirm.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5f822d43c22f4dec881d2d097a2bfe769e5e797 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/confirm.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/expand.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/expand.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce8111d18cf587a07681d4b3e053d952a623956c Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/expand.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/filepath.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/filepath.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f915cf43350824298fdee45a64fc74b1b61ab76e Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/filepath.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/fuzzy.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/fuzzy.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03ff77eb30ffd57d0d2dd4b8b29c14cf317fcbac Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/fuzzy.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/input.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/input.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d979d89a20e6892fd94f45ef8d6bb6213c388e1 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/input.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/list.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/list.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecb2f8ec608cfcef44633cfde3e1a8239b77809e Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/list.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/number.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/number.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1773aa85c6f168ed7630f6b33d06fc0030a8b369 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/number.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/rawlist.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/rawlist.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e08a8a091baaef9ebe27a3f5619954303ef0b7d Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/rawlist.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/secret.cpython-313.pyc b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/secret.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a5c32ee003e241e0888e7f8acbfabf05e3d4231 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/__pycache__/secret.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/checkbox.py b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/checkbox.py new file mode 100644 index 0000000000000000000000000000000000000000..60f3bdefec95895ef9a61d30ff3d0cf006e3c04e --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/checkbox.py @@ -0,0 +1,244 @@ +"""Module contains the class to create a checkbox prompt.""" +from typing import Any, Callable, List, Optional, Tuple, Union + +from prompt_toolkit.validation import ValidationError + +from InquirerPy.base import FakeDocument, InquirerPyUIListControl +from InquirerPy.enum import ( + INQUIRERPY_EMPTY_CIRCLE_SEQUENCE, + INQUIRERPY_FILL_CIRCLE_SEQUENCE, + INQUIRERPY_POINTER_SEQUENCE, +) +from InquirerPy.prompts.list import ListPrompt +from InquirerPy.separator import Separator +from InquirerPy.utils import ( + InquirerPyKeybindings, + InquirerPyListChoices, + InquirerPyMessage, + InquirerPySessionResult, + InquirerPyStyle, + InquirerPyValidate, +) + +__all__ = ["CheckboxPrompt"] + + +class InquirerPyCheckboxControl(InquirerPyUIListControl): + """An :class:`~prompt_toolkit.layout.UIControl` class that displays a list of choices. + + Reference the parameter definition in :class:`.CheckboxPrompt`. + """ + + def __init__( + self, + choices: InquirerPyListChoices, + default: Any, + pointer: str, + enabled_symbol: str, + disabled_symbol: str, + session_result: Optional[InquirerPySessionResult], + ) -> None: + """Initialise required attributes and call base class.""" + self._pointer = pointer + self._enabled_symbol = enabled_symbol + self._disabled_symbol = disabled_symbol + super().__init__( + choices=choices, + default=default, + session_result=session_result, + multiselect=True, + ) + + def _format_choices(self) -> None: + pass + + def _get_hover_text(self, choice) -> List[Tuple[str, str]]: + display_choices = [] + display_choices.append(("class:pointer", self._pointer)) + if self._pointer: + display_choices.append(("", " ")) + if not isinstance(choice["value"], Separator): + display_choices.append( + ( + "class:checkbox", + self._enabled_symbol + if choice["enabled"] + else self._disabled_symbol, + ) + ) + if self._enabled_symbol and self._disabled_symbol: + display_choices.append(("", " ")) + display_choices.append(("[SetCursorPosition]", "")) + display_choices.append(("class:pointer", choice["name"])) + return display_choices + + def _get_normal_text(self, choice) -> List[Tuple[str, str]]: + display_choices = [] + display_choices.append(("", len(self._pointer) * " ")) + if self._pointer: + display_choices.append(("", " ")) + if not isinstance(choice["value"], Separator): + display_choices.append( + ( + "class:checkbox", + self._enabled_symbol + if choice["enabled"] + else self._disabled_symbol, + ) + ) + if self._enabled_symbol and self._disabled_symbol: + display_choices.append(("", " ")) + display_choices.append(("", choice["name"])) + else: + display_choices.append(("class:separator", choice["name"])) + return display_choices + + +class CheckboxPrompt(ListPrompt): + """Create a prompt which displays a list of checkboxes to toggle. + + A wrapper class around :class:`~prompt_toolkit.application.Application`. + + User can toggle on/off on each checkbox. + + Works very similar to :class:`~InquirerPy.prompts.list.ListPrompt` with `multiselect` enabled, + the main difference is visual/UI and also when not toggling anything, the result will be empty. + + Args: + message: The question to ask the user. + Refer to :ref:`pages/dynamic:message` documentation for more details. + choices: List of choices to display and select. + Refer to :ref:`pages/dynamic:choices` documentation for more details. + style: An :class:`InquirerPyStyle` instance. + Refer to :ref:`Style ` documentation for more details. + vi_mode: Use vim keybinding for the prompt. + Refer to :ref:`pages/kb:Keybindings` documentation for more details. + default: Set the default value of the prompt. + This will be used to determine which choice is highlighted (current selection), + The default value should be the value of one of the choices. + Refer to :ref:`pages/dynamic:default` documentation for more details. + separator: Separator symbol. Custom symbol that will be used as a separator between the choice index number and the choices. + qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered. + amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered. + pointer: Pointer symbol. Customer symbol that will be used to indicate the current choice selection. + enabled_symbol: Checkbox ticked symbol. Custom symbol which indicate the checkbox is ticked. + disabled_symbol: Checkbox not ticked symbol. Custom symbol which indicate the checkbox is not ticked. + instruction: Short instruction to display next to the question. + long_instruction: Long instructions to display at the bottom of the prompt. + validate: Add validation to user input. + The main use case for this prompt would be when `multiselect` is True, you can enforce a min/max selection. + Refer to :ref:`pages/validator:Validator` documentation for more details. + invalid_message: Error message to display when user input is invalid. + Refer to :ref:`pages/validator:Validator` documentation for more details. + transformer: A function which performs additional transformation on the value that gets printed to the terminal. + Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. + Refer to :ref:`pages/dynamic:transformer` documentation for more details. + filter: A function which performs additional transformation on the result. + This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. + Refer to :ref:`pages/dynamic:filter` documentation for more details. + height: Preferred height of the prompt. + Refer to :ref:`pages/height:Height` documentation for more details. + max_height: Max height of the prompt. + Refer to :ref:`pages/height:Height` documentation for more details. + border: Create border around the choice window. + keybindings: Customise the builtin keybindings. + Refer to :ref:`pages/kb:Keybindings` for more details. + show_cursor: Display cursor at the end of the prompt. + Set to False to hide the cursor. + cycle: Return to top item if hit bottom during navigation or vice versa. + wrap_lines: Soft wrap question lines when question exceeds the terminal width. + raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result + will be `None` and the question is skiped. + mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped. + mandatory_message: Error message to show when user attempts to skip mandatory prompt. + session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`. + + Examples: + >>> from InquirerPy import inquirer + >>> result = inquirer.checkbox(message="Select:", choices=[1, 2, 3]).execute() + >>> print(result) + [1] + """ + + def __init__( + self, + message: InquirerPyMessage, + choices: InquirerPyListChoices, + default: Any = None, + style: Optional[InquirerPyStyle] = None, + vi_mode: bool = False, + qmark: str = "?", + amark: str = "?", + pointer: str = INQUIRERPY_POINTER_SEQUENCE, + enabled_symbol: str = INQUIRERPY_FILL_CIRCLE_SEQUENCE, + disabled_symbol: str = INQUIRERPY_EMPTY_CIRCLE_SEQUENCE, + border: bool = False, + instruction: str = "", + long_instruction: str = "", + transformer: Optional[Callable[[Any], Any]] = None, + filter: Optional[Callable[[Any], Any]] = None, + height: Optional[Union[int, str]] = None, + max_height: Optional[Union[int, str]] = None, + validate: Optional[InquirerPyValidate] = None, + invalid_message: str = "Invalid input", + keybindings: Optional[InquirerPyKeybindings] = None, + show_cursor: bool = True, + cycle: bool = True, + wrap_lines: bool = True, + raise_keyboard_interrupt: bool = True, + mandatory: bool = True, + mandatory_message: str = "Mandatory prompt", + session_result: Optional[InquirerPySessionResult] = None, + ) -> None: + self.content_control = InquirerPyCheckboxControl( + choices=choices, + default=default, + pointer=pointer, + enabled_symbol=enabled_symbol, + disabled_symbol=disabled_symbol, + session_result=session_result, + ) + super().__init__( + message=message, + choices=choices, + style=style, + border=border, + vi_mode=vi_mode, + qmark=qmark, + amark=amark, + instruction=instruction, + long_instruction=long_instruction, + transformer=transformer, + filter=filter, + height=height, + max_height=max_height, + validate=validate, + invalid_message=invalid_message, + multiselect=True, + keybindings=keybindings, + show_cursor=show_cursor, + cycle=cycle, + wrap_lines=wrap_lines, + raise_keyboard_interrupt=raise_keyboard_interrupt, + mandatory=mandatory, + mandatory_message=mandatory_message, + session_result=session_result, + ) + + def _handle_enter(self, event) -> None: + """Override this method to force empty array result. + + When user does not select anything, exit with empty list. + + Args: + event: Keypress event. + """ + try: + fake_document = FakeDocument(self.result_value) + self._validator.validate(fake_document) # type: ignore + except ValidationError: + self._invalid = True + else: + self.status["answered"] = True + self.status["result"] = self.result_name + event.app.exit(result=self.result_value) diff --git a/.venv/lib/python3.13/site-packages/InquirerPy/prompts/filepath.py b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/filepath.py new file mode 100644 index 0000000000000000000000000000000000000000..97cce2bf4600c1a57080b6339f6942c87e9ef9c1 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/InquirerPy/prompts/filepath.py @@ -0,0 +1,192 @@ +"""Module contains the class to create filepath prompt and filepath completer class.""" +import os +from pathlib import Path +from typing import TYPE_CHECKING, Any, Callable, Generator, Optional + +from prompt_toolkit.completion import Completer, Completion +from prompt_toolkit.completion.base import ThreadedCompleter + +from InquirerPy.prompts.input import InputPrompt +from InquirerPy.utils import ( + InquirerPyDefault, + InquirerPyKeybindings, + InquirerPyMessage, + InquirerPySessionResult, + InquirerPyStyle, + InquirerPyValidate, +) + +if TYPE_CHECKING: + from prompt_toolkit.input.base import Input + from prompt_toolkit.output.base import Output + +__all__ = ["FilePathPrompt", "FilePathCompleter"] + + +class FilePathCompleter(Completer): + """An auto completion class which generates system filepath. + + See Also: + :class:`~prompt_toolkit.completion.Completer` + + Args: + only_directories: Only complete directories. + only_files: Only complete files. + """ + + def __init__(self, only_directories: bool = False, only_files: bool = False): + self._only_directories = only_directories + self._only_files = only_files + self._delimiter = "/" if os.name == "posix" else "\\" + + def get_completions( + self, document, complete_event + ) -> Generator[Completion, None, None]: + """Get a list of valid system paths.""" + if document.text == "~": + return + + validation = lambda file, doc_text: str(file).startswith(doc_text) + + if document.cursor_position == 0: + dirname = Path.cwd() + validation = lambda file, doc_text: True + elif document.text.startswith("~"): + dirname = Path(os.path.dirname(f"{Path.home()}{document.text[1:]}")) + validation = lambda file, doc_text: str(file).startswith( + f"{Path.home()}{doc_text[1:]}" + ) + elif document.text.startswith(f".{self._delimiter}"): + dirname = Path(os.path.dirname(document.text)) + validation = lambda file, doc_text: str(file).startswith(doc_text[2:]) + else: + dirname = Path(os.path.dirname(document.text)) + + for item in self._get_completion(document, dirname, validation): + yield item + + def _get_completion( + self, document, path, validation + ) -> Generator[Completion, None, None]: + if not path.is_dir(): + return + for file in path.iterdir(): + if self._only_directories and not file.is_dir(): + continue + if self._only_files and not file.is_file(): + continue + if validation(file, document.text): + file_name = file.name + display_name = file_name + if file.is_dir(): + display_name = f"{file_name}{self._delimiter}" + yield Completion( + file.name, + start_position=-1 * len(os.path.basename(document.text)), + display=display_name, + ) + + +class FilePathPrompt(InputPrompt): + """Create a prompt that provides auto completion for system filepaths. + + A wrapper class around :class:`~prompt_toolkit.shortcuts.PromptSession`. + + Args: + message: The question to ask the user. + Refer to :ref:`pages/dynamic:message` documentation for more details. + style: An :class:`InquirerPyStyle` instance. + Refer to :ref:`Style ` documentation for more details. + vi_mode: Use vim keybinding for the prompt. + Refer to :ref:`pages/kb:Keybindings` documentation for more details. + default: Set the default text value of the prompt. + Refer to :ref:`pages/dynamic:default` documentation for more details. + qmark: Question mark symbol. Custom symbol that will be displayed infront of the question before its answered. + amark: Answer mark symbol. Custom symbol that will be displayed infront of the question after its answered. + instruction: Short instruction to display next to the question. + long_instruction: Long instructions to display at the bottom of the prompt. + multicolumn_complete: Change the auto-completion UI to a multi column display. + validate: Add validation to user input. + Refer to :ref:`pages/validator:Validator` documentation for more details. + invalid_message: Error message to display when user input is invalid. + Refer to :ref:`pages/validator:Validator` documentation for more details. + transformer: A function which performs additional transformation on the value that gets printed to the terminal. + Different than `filter` parameter, this is only visual effect and won’t affect the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. + Refer to :ref:`pages/dynamic:transformer` documentation for more details. + filter: A function which performs additional transformation on the result. + This affects the actual value returned by :meth:`~InquirerPy.base.simple.BaseSimplePrompt.execute`. + Refer to :ref:`pages/dynamic:filter` documentation for more details. + keybindings: Customise the builtin keybindings. + Refer to :ref:`pages/kb:Keybindings` for more details. + wrap_lines: Soft wrap question lines when question exceeds the terminal width. + only_directories: Only complete directories. + only_files: Only complete files. + raise_keyboard_interrupt: Raise the :class:`KeyboardInterrupt` exception when `ctrl-c` is pressed. If false, the result + will be `None` and the question is skiped. + mandatory: Indicate if the prompt is mandatory. If True, then the question cannot be skipped. + mandatory_message: Error message to show when user attempts to skip mandatory prompt. + session_result: Used internally for :ref:`index:Classic Syntax (PyInquirer)`. + input: Used internally and will be removed in future updates. + output: Used internally and will be removed in future updates. + + Examples: + >>> from InquirerPy import inquirer + >>> result = inquirer.filepath(message="Enter a path:").execute() + >>> print(result) + /home/ubuntu/README.md + """ + + def __init__( + self, + message: InquirerPyMessage, + style: Optional[InquirerPyStyle] = None, + vi_mode: bool = False, + default: InquirerPyDefault = "", + qmark: str = "?", + amark: str = "?", + instruction: str = "", + long_instruction: str = "", + multicolumn_complete: bool = False, + validate: Optional[InquirerPyValidate] = None, + invalid_message: str = "Invalid input", + only_directories: bool = False, + only_files: bool = False, + transformer: Optional[Callable[[str], Any]] = None, + filter: Optional[Callable[[str], Any]] = None, + keybindings: Optional[InquirerPyKeybindings] = None, + wrap_lines: bool = True, + raise_keyboard_interrupt: bool = True, + mandatory: bool = True, + mandatory_message: str = "Mandatory prompt", + session_result: Optional[InquirerPySessionResult] = None, + input: Optional["Input"] = None, + output: Optional["Output"] = None, + ) -> None: + super().__init__( + message=message, + style=style, + vi_mode=vi_mode, + default=default, + qmark=qmark, + amark=amark, + instruction=instruction, + long_instruction=long_instruction, + completer=ThreadedCompleter( + FilePathCompleter( + only_directories=only_directories, only_files=only_files + ) + ), + multicolumn_complete=multicolumn_complete, + validate=validate, + invalid_message=invalid_message, + transformer=transformer, + filter=filter, + keybindings=keybindings, + wrap_lines=wrap_lines, + raise_keyboard_interrupt=raise_keyboard_interrupt, + mandatory=mandatory, + mandatory_message=mandatory_message, + session_result=session_result, + input=input, + output=output, + ) diff --git a/.venv/lib/python3.13/site-packages/_virtualenv.py b/.venv/lib/python3.13/site-packages/_virtualenv.py new file mode 100644 index 0000000000000000000000000000000000000000..6c1f22640d567f04c9880b90566436ee5ba14400 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/_virtualenv.py @@ -0,0 +1,101 @@ +"""Patches that are applied at runtime to the virtual environment.""" + +import os +import sys + +VIRTUALENV_PATCH_FILE = os.path.join(__file__) + + +def patch_dist(dist): + """ + Distutils allows user to configure some arguments via a configuration file: + https://docs.python.org/3.11/install/index.html#distutils-configuration-files. + + Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up. + """ # noqa: D205 + # we cannot allow some install config as that would get packages installed outside of the virtual environment + old_parse_config_files = dist.Distribution.parse_config_files + + def parse_config_files(self, *args, **kwargs): + result = old_parse_config_files(self, *args, **kwargs) + install = self.get_option_dict("install") + + if "prefix" in install: # the prefix governs where to install the libraries + install["prefix"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix) + for base in ("purelib", "platlib", "headers", "scripts", "data"): + key = f"install_{base}" + if key in install: # do not allow global configs to hijack venv paths + install.pop(key, None) + return result + + dist.Distribution.parse_config_files = parse_config_files + + +# Import hook that patches some modules to ignore configuration values that break package installation in case +# of virtual environments. +_DISTUTILS_PATCH = "distutils.dist", "setuptools.dist" +# https://docs.python.org/3/library/importlib.html#setting-up-an-importer + + +class _Finder: + """A meta path finder that allows patching the imported distutils modules.""" + + fullname = None + + # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup, + # because there are gevent-based applications that need to be first to import threading by themselves. + # See https://github.com/pypa/virtualenv/issues/1895 for details. + lock = [] # noqa: RUF012 + + def find_spec(self, fullname, path, target=None): # noqa: ARG002 + if fullname in _DISTUTILS_PATCH and self.fullname is None: + # initialize lock[0] lazily + if len(self.lock) == 0: + import threading + + lock = threading.Lock() + # there is possibility that two threads T1 and T2 are simultaneously running into find_spec, + # observing .lock as empty, and further going into hereby initialization. However due to the GIL, + # list.append() operation is atomic and this way only one of the threads will "win" to put the lock + # - that every thread will use - into .lock[0]. + # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe + self.lock.append(lock) + + from functools import partial + from importlib.util import find_spec + + with self.lock[0]: + self.fullname = fullname + try: + spec = find_spec(fullname, path) + if spec is not None: + # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work + is_new_api = hasattr(spec.loader, "exec_module") + func_name = "exec_module" if is_new_api else "load_module" + old = getattr(spec.loader, func_name) + func = self.exec_module if is_new_api else self.load_module + if old is not func: + try: # noqa: SIM105 + setattr(spec.loader, func_name, partial(func, old)) + except AttributeError: + pass # C-Extension loaders are r/o such as zipimporter with <3.7 + return spec + finally: + self.fullname = None + return None + + @staticmethod + def exec_module(old, module): + old(module) + if module.__name__ in _DISTUTILS_PATCH: + patch_dist(module) + + @staticmethod + def load_module(old, name): + module = old(name) + if module.__name__ in _DISTUTILS_PATCH: + patch_dist(module) + return module + + +sys.meta_path.insert(0, _Finder()) diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/INSTALLER b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/METADATA b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..a2dece8315da352a7d8b1b597e1f212984b7372b --- /dev/null +++ b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/METADATA @@ -0,0 +1,77 @@ +Metadata-Version: 2.4 +Name: certifi +Version: 2025.7.14 +Summary: Python package for providing Mozilla's CA Bundle. +Home-page: https://github.com/certifi/python-certifi +Author: Kenneth Reitz +Author-email: me@kennethreitz.com +License: MPL-2.0 +Project-URL: Source, https://github.com/certifi/python-certifi +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0) +Classifier: Natural Language :: English +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.7 +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 +Requires-Python: >=3.7 +License-File: LICENSE +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: license +Dynamic: license-file +Dynamic: project-url +Dynamic: requires-python +Dynamic: summary + +Certifi: Python SSL Certificates +================================ + +Certifi provides Mozilla's carefully curated collection of Root Certificates for +validating the trustworthiness of SSL certificates while verifying the identity +of TLS hosts. It has been extracted from the `Requests`_ project. + +Installation +------------ + +``certifi`` is available on PyPI. Simply install it with ``pip``:: + + $ pip install certifi + +Usage +----- + +To reference the installed certificate authority (CA) bundle, you can use the +built-in function:: + + >>> import certifi + + >>> certifi.where() + '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem' + +Or from the command line:: + + $ python -m certifi + /usr/local/lib/python3.7/site-packages/certifi/cacert.pem + +Enjoy! + +.. _`Requests`: https://requests.readthedocs.io/en/master/ + +Addition/Removal of Certificates +-------------------------------- + +Certifi does not support any addition/removal or other modification of the +CA trust store content. This project is intended to provide a reliable and +highly portable root of trust to python deployments. Look to upstream projects +for methods to use alternate trust. diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/RECORD b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..4bb1ab0bc07f021f5f0327d2118a833d763761a6 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/RECORD @@ -0,0 +1,12 @@ +certifi-2025.7.14.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +certifi-2025.7.14.dist-info/METADATA,sha256=7cmDKO0a-fVcP_WCfZ4DpLKgDMu_AEAYhTT5lswQToY,2423 +certifi-2025.7.14.dist-info/RECORD,, +certifi-2025.7.14.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +certifi-2025.7.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91 +certifi-2025.7.14.dist-info/licenses/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989 +certifi-2025.7.14.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8 +certifi/__init__.py,sha256=dvNDUdAXp-hzoYcf09PXzLmHIlPfypaBQPFp5esDXyo,94 +certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243 +certifi/cacert.pem,sha256=lm3cYJxEv9SoAx4Atc3NiT1D92d965vcID6H39f_93o,290057 +certifi/core.py,sha256=XFXycndG5pf37ayeF8N32HUuDafsyhkVMbO4BAPWHa0,3394 +certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/REQUESTED b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/WHEEL b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..e7fa31b6f3f78deb1022c1f7927f07d4d16da822 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/top_level.txt b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..963eac530b9bc28d704d1bc410299c68e3216d4d --- /dev/null +++ b/.venv/lib/python3.13/site-packages/certifi-2025.7.14.dist-info/top_level.txt @@ -0,0 +1 @@ +certifi diff --git a/.venv/lib/python3.13/site-packages/charset_normalizer/md.cpython-313-darwin.so b/.venv/lib/python3.13/site-packages/charset_normalizer/md.cpython-313-darwin.so new file mode 100644 index 0000000000000000000000000000000000000000..6034976cc3c96c29295ce28fa8b91dc9643eb8c3 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/charset_normalizer/md.cpython-313-darwin.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a1102507d05b258671b53d870ee68e9a33eda864291a5164f6e6ce23bf119f8 +size 115744 diff --git a/.venv/lib/python3.13/site-packages/charset_normalizer/md__mypyc.cpython-313-darwin.so b/.venv/lib/python3.13/site-packages/charset_normalizer/md__mypyc.cpython-313-darwin.so new file mode 100644 index 0000000000000000000000000000000000000000..478e1ef5419d43e2fa388a4449502bb0a511e382 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/charset_normalizer/md__mypyc.cpython-313-darwin.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fc72392e603976324f83e44c9f7c37af39b4ac8a77672432687358b29cfb4733 +size 482104 diff --git a/.venv/lib/python3.13/site-packages/hf_xet/hf_xet.abi3.so b/.venv/lib/python3.13/site-packages/hf_xet/hf_xet.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..ecefbbfdaba4885a3e86b99a7c76d5fdc0e8ed58 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/hf_xet/hf_xet.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:daa2bf24956945982f5f3d6f46d33137aa34f0968e142385a50107e08626ac8a +size 5469152 diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/__pycache__/hf_api.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/__pycache__/hf_api.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1b2af9ba0e6243a974b1e7ca095a0378ead09e7 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/__pycache__/hf_api.cpython-313.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3cd43d9cb39d49e9e44f33d74dbe08d12c0b96b9e8b77eec3b75c437a18b7d30 +size 419529 diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/_space_api.py b/.venv/lib/python3.13/site-packages/huggingface_hub/_space_api.py new file mode 100644 index 0000000000000000000000000000000000000000..05fccfbc1ebdfc14840a88751914b8fc0d1a498d --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/_space_api.py @@ -0,0 +1,168 @@ +# coding=utf-8 +# Copyright 2019-present, the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from dataclasses import dataclass +from datetime import datetime +from enum import Enum +from typing import Dict, Optional + +from huggingface_hub.utils import parse_datetime + + +class SpaceStage(str, Enum): + """ + Enumeration of possible stage of a Space on the Hub. + + Value can be compared to a string: + ```py + assert SpaceStage.BUILDING == "BUILDING" + ``` + + Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceInfo.ts#L61 (private url). + """ + + # Copied from moon-landing > server > repo_types > SpaceInfo.ts (private repo) + NO_APP_FILE = "NO_APP_FILE" + CONFIG_ERROR = "CONFIG_ERROR" + BUILDING = "BUILDING" + BUILD_ERROR = "BUILD_ERROR" + RUNNING = "RUNNING" + RUNNING_BUILDING = "RUNNING_BUILDING" + RUNTIME_ERROR = "RUNTIME_ERROR" + DELETING = "DELETING" + STOPPED = "STOPPED" + PAUSED = "PAUSED" + + +class SpaceHardware(str, Enum): + """ + Enumeration of hardwares available to run your Space on the Hub. + + Value can be compared to a string: + ```py + assert SpaceHardware.CPU_BASIC == "cpu-basic" + ``` + + Taken from https://github.com/huggingface-internal/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts (private url). + """ + + # CPU + CPU_BASIC = "cpu-basic" + CPU_UPGRADE = "cpu-upgrade" + CPU_XL = "cpu-xl" + + # ZeroGPU + ZERO_A10G = "zero-a10g" + + # GPU + T4_SMALL = "t4-small" + T4_MEDIUM = "t4-medium" + L4X1 = "l4x1" + L4X4 = "l4x4" + L40SX1 = "l40sx1" + L40SX4 = "l40sx4" + L40SX8 = "l40sx8" + A10G_SMALL = "a10g-small" + A10G_LARGE = "a10g-large" + A10G_LARGEX2 = "a10g-largex2" + A10G_LARGEX4 = "a10g-largex4" + A100_LARGE = "a100-large" + H100 = "h100" + H100X8 = "h100x8" + + +class SpaceStorage(str, Enum): + """ + Enumeration of persistent storage available for your Space on the Hub. + + Value can be compared to a string: + ```py + assert SpaceStorage.SMALL == "small" + ``` + + Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts#L24 (private url). + """ + + SMALL = "small" + MEDIUM = "medium" + LARGE = "large" + + +@dataclass +class SpaceRuntime: + """ + Contains information about the current runtime of a Space. + + Args: + stage (`str`): + Current stage of the space. Example: RUNNING. + hardware (`str` or `None`): + Current hardware of the space. Example: "cpu-basic". Can be `None` if Space + is `BUILDING` for the first time. + requested_hardware (`str` or `None`): + Requested hardware. Can be different than `hardware` especially if the request + has just been made. Example: "t4-medium". Can be `None` if no hardware has + been requested yet. + sleep_time (`int` or `None`): + Number of seconds the Space will be kept alive after the last request. By default (if value is `None`), the + Space will never go to sleep if it's running on an upgraded hardware, while it will go to sleep after 48 + hours on a free 'cpu-basic' hardware. For more details, see https://huggingface.co/docs/hub/spaces-gpus#sleep-time. + raw (`dict`): + Raw response from the server. Contains more information about the Space + runtime like number of replicas, number of cpu, memory size,... + """ + + stage: SpaceStage + hardware: Optional[SpaceHardware] + requested_hardware: Optional[SpaceHardware] + sleep_time: Optional[int] + storage: Optional[SpaceStorage] + raw: Dict + + def __init__(self, data: Dict) -> None: + self.stage = data["stage"] + self.hardware = data.get("hardware", {}).get("current") + self.requested_hardware = data.get("hardware", {}).get("requested") + self.sleep_time = data.get("gcTimeout") + self.storage = data.get("storage") + self.raw = data + + +@dataclass +class SpaceVariable: + """ + Contains information about the current variables of a Space. + + Args: + key (`str`): + Variable key. Example: `"MODEL_REPO_ID"` + value (`str`): + Variable value. Example: `"the_model_repo_id"`. + description (`str` or None): + Description of the variable. Example: `"Model Repo ID of the implemented model"`. + updatedAt (`datetime` or None): + datetime of the last update of the variable (if the variable has been updated at least once). + """ + + key: str + value: str + description: Optional[str] + updated_at: Optional[datetime] + + def __init__(self, key: str, values: Dict) -> None: + self.key = key + self.value = values["value"] + self.description = values.get("description") + updated_at = values.get("updatedAt") + self.updated_at = parse_datetime(updated_at) if updated_at is not None else None diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_payload.py b/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_payload.py new file mode 100644 index 0000000000000000000000000000000000000000..288f4b08b9428980e99ca06703442eab62fad277 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_payload.py @@ -0,0 +1,137 @@ +# coding=utf-8 +# Copyright 2023-present, the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Contains data structures to parse the webhooks payload.""" + +from typing import List, Literal, Optional + +from .utils import is_pydantic_available + + +if is_pydantic_available(): + from pydantic import BaseModel +else: + # Define a dummy BaseModel to avoid import errors when pydantic is not installed + # Import error will be raised when trying to use the class + + class BaseModel: # type: ignore [no-redef] + def __init__(self, *args, **kwargs) -> None: + raise ImportError( + "You must have `pydantic` installed to use `WebhookPayload`. This is an optional dependency that" + " should be installed separately. Please run `pip install --upgrade pydantic` and retry." + ) + + +# This is an adaptation of the ReportV3 interface implemented in moon-landing. V0, V1 and V2 have been ignored as they +# are not in used anymore. To keep in sync when format is updated in +# https://github.com/huggingface/moon-landing/blob/main/server/lib/HFWebhooks.ts (internal link). + + +WebhookEvent_T = Literal[ + "create", + "delete", + "move", + "update", +] +RepoChangeEvent_T = Literal[ + "add", + "move", + "remove", + "update", +] +RepoType_T = Literal[ + "dataset", + "model", + "space", +] +DiscussionStatus_T = Literal[ + "closed", + "draft", + "open", + "merged", +] +SupportedWebhookVersion = Literal[3] + + +class ObjectId(BaseModel): + id: str + + +class WebhookPayloadUrl(BaseModel): + web: str + api: Optional[str] = None + + +class WebhookPayloadMovedTo(BaseModel): + name: str + owner: ObjectId + + +class WebhookPayloadWebhook(ObjectId): + version: SupportedWebhookVersion + + +class WebhookPayloadEvent(BaseModel): + action: WebhookEvent_T + scope: str + + +class WebhookPayloadDiscussionChanges(BaseModel): + base: str + mergeCommitId: Optional[str] = None + + +class WebhookPayloadComment(ObjectId): + author: ObjectId + hidden: bool + content: Optional[str] = None + url: WebhookPayloadUrl + + +class WebhookPayloadDiscussion(ObjectId): + num: int + author: ObjectId + url: WebhookPayloadUrl + title: str + isPullRequest: bool + status: DiscussionStatus_T + changes: Optional[WebhookPayloadDiscussionChanges] = None + pinned: Optional[bool] = None + + +class WebhookPayloadRepo(ObjectId): + owner: ObjectId + head_sha: Optional[str] = None + name: str + private: bool + subdomain: Optional[str] = None + tags: Optional[List[str]] = None + type: Literal["dataset", "model", "space"] + url: WebhookPayloadUrl + + +class WebhookPayloadUpdatedRef(BaseModel): + ref: str + oldSha: Optional[str] = None + newSha: Optional[str] = None + + +class WebhookPayload(BaseModel): + event: WebhookPayloadEvent + repo: WebhookPayloadRepo + discussion: Optional[WebhookPayloadDiscussion] = None + comment: Optional[WebhookPayloadComment] = None + webhook: WebhookPayloadWebhook + movedTo: Optional[WebhookPayloadMovedTo] = None + updatedRefs: Optional[List[WebhookPayloadUpdatedRef]] = None diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_server.py b/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_server.py new file mode 100644 index 0000000000000000000000000000000000000000..a7bd6c86261b1cc26dfcfe3a65f5aec9851a1162 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/_webhooks_server.py @@ -0,0 +1,388 @@ +# coding=utf-8 +# Copyright 2023-present, the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Contains `WebhooksServer` and `webhook_endpoint` to create a webhook server easily.""" + +import atexit +import inspect +import os +from functools import wraps +from typing import TYPE_CHECKING, Any, Callable, Dict, Optional + +from .utils import experimental, is_fastapi_available, is_gradio_available + + +if TYPE_CHECKING: + import gradio as gr + from fastapi import Request + +if is_fastapi_available(): + from fastapi import FastAPI, Request + from fastapi.responses import JSONResponse +else: + # Will fail at runtime if FastAPI is not available + FastAPI = Request = JSONResponse = None # type: ignore [misc, assignment] + + +_global_app: Optional["WebhooksServer"] = None +_is_local = os.environ.get("SPACE_ID") is None + + +@experimental +class WebhooksServer: + """ + The [`WebhooksServer`] class lets you create an instance of a Gradio app that can receive Huggingface webhooks. + These webhooks can be registered using the [`~WebhooksServer.add_webhook`] decorator. Webhook endpoints are added to + the app as a POST endpoint to the FastAPI router. Once all the webhooks are registered, the `launch` method has to be + called to start the app. + + It is recommended to accept [`WebhookPayload`] as the first argument of the webhook function. It is a Pydantic + model that contains all the information about the webhook event. The data will be parsed automatically for you. + + Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to setup your + WebhooksServer and deploy it on a Space. + + + + `WebhooksServer` is experimental. Its API is subject to change in the future. + + + + + + You must have `gradio` installed to use `WebhooksServer` (`pip install --upgrade gradio`). + + + + Args: + ui (`gradio.Blocks`, optional): + A Gradio UI instance to be used as the Space landing page. If `None`, a UI displaying instructions + about the configured webhooks is created. + webhook_secret (`str`, optional): + A secret key to verify incoming webhook requests. You can set this value to any secret you want as long as + you also configure it in your [webhooks settings panel](https://huggingface.co/settings/webhooks). You + can also set this value as the `WEBHOOK_SECRET` environment variable. If no secret is provided, the + webhook endpoints are opened without any security. + + Example: + + ```python + import gradio as gr + from huggingface_hub import WebhooksServer, WebhookPayload + + with gr.Blocks() as ui: + ... + + app = WebhooksServer(ui=ui, webhook_secret="my_secret_key") + + @app.add_webhook("/say_hello") + async def hello(payload: WebhookPayload): + return {"message": "hello"} + + app.launch() + ``` + """ + + def __new__(cls, *args, **kwargs) -> "WebhooksServer": + if not is_gradio_available(): + raise ImportError( + "You must have `gradio` installed to use `WebhooksServer`. Please run `pip install --upgrade gradio`" + " first." + ) + if not is_fastapi_available(): + raise ImportError( + "You must have `fastapi` installed to use `WebhooksServer`. Please run `pip install --upgrade fastapi`" + " first." + ) + return super().__new__(cls) + + def __init__( + self, + ui: Optional["gr.Blocks"] = None, + webhook_secret: Optional[str] = None, + ) -> None: + self._ui = ui + + self.webhook_secret = webhook_secret or os.getenv("WEBHOOK_SECRET") + self.registered_webhooks: Dict[str, Callable] = {} + _warn_on_empty_secret(self.webhook_secret) + + def add_webhook(self, path: Optional[str] = None) -> Callable: + """ + Decorator to add a webhook to the [`WebhooksServer`] server. + + Args: + path (`str`, optional): + The URL path to register the webhook function. If not provided, the function name will be used as the + path. In any case, all webhooks are registered under `/webhooks`. + + Raises: + ValueError: If the provided path is already registered as a webhook. + + Example: + ```python + from huggingface_hub import WebhooksServer, WebhookPayload + + app = WebhooksServer() + + @app.add_webhook + async def trigger_training(payload: WebhookPayload): + if payload.repo.type == "dataset" and payload.event.action == "update": + # Trigger a training job if a dataset is updated + ... + + app.launch() + ``` + """ + # Usage: directly as decorator. Example: `@app.add_webhook` + if callable(path): + # If path is a function, it means it was used as a decorator without arguments + return self.add_webhook()(path) + + # Usage: provide a path. Example: `@app.add_webhook(...)` + @wraps(FastAPI.post) + def _inner_post(*args, **kwargs): + func = args[0] + abs_path = f"/webhooks/{(path or func.__name__).strip('/')}" + if abs_path in self.registered_webhooks: + raise ValueError(f"Webhook {abs_path} already exists.") + self.registered_webhooks[abs_path] = func + + return _inner_post + + def launch(self, prevent_thread_lock: bool = False, **launch_kwargs: Any) -> None: + """Launch the Gradio app and register webhooks to the underlying FastAPI server. + + Input parameters are forwarded to Gradio when launching the app. + """ + ui = self._ui or self._get_default_ui() + + # Start Gradio App + # - as non-blocking so that webhooks can be added afterwards + # - as shared if launch locally (to debug webhooks) + launch_kwargs.setdefault("share", _is_local) + self.fastapi_app, _, _ = ui.launch(prevent_thread_lock=True, **launch_kwargs) + + # Register webhooks to FastAPI app + for path, func in self.registered_webhooks.items(): + # Add secret check if required + if self.webhook_secret is not None: + func = _wrap_webhook_to_check_secret(func, webhook_secret=self.webhook_secret) + + # Add route to FastAPI app + self.fastapi_app.post(path)(func) + + # Print instructions and block main thread + space_host = os.environ.get("SPACE_HOST") + url = "https://" + space_host if space_host is not None else (ui.share_url or ui.local_url) + if url is None: + raise ValueError("Cannot find the URL of the app. Please provide a valid `ui` or update `gradio` version.") + url = url.strip("/") + message = "\nWebhooks are correctly setup and ready to use:" + message += "\n" + "\n".join(f" - POST {url}{webhook}" for webhook in self.registered_webhooks) + message += "\nGo to https://huggingface.co/settings/webhooks to setup your webhooks." + print(message) + + if not prevent_thread_lock: + ui.block_thread() + + def _get_default_ui(self) -> "gr.Blocks": + """Default UI if not provided (lists webhooks and provides basic instructions).""" + import gradio as gr + + with gr.Blocks() as ui: + gr.Markdown("# This is an app to process 🤗 Webhooks") + gr.Markdown( + "Webhooks are a foundation for MLOps-related features. They allow you to listen for new changes on" + " specific repos or to all repos belonging to particular set of users/organizations (not just your" + " repos, but any repo). Check out this [guide](https://huggingface.co/docs/hub/webhooks) to get to" + " know more about webhooks on the Huggingface Hub." + ) + gr.Markdown( + f"{len(self.registered_webhooks)} webhook(s) are registered:" + + "\n\n" + + "\n ".join( + f"- [{webhook_path}]({_get_webhook_doc_url(webhook.__name__, webhook_path)})" + for webhook_path, webhook in self.registered_webhooks.items() + ) + ) + gr.Markdown( + "Go to https://huggingface.co/settings/webhooks to setup your webhooks." + + "\nYou app is running locally. Please look at the logs to check the full URL you need to set." + if _is_local + else ( + "\nThis app is running on a Space. You can find the corresponding URL in the options menu" + " (top-right) > 'Embed the Space'. The URL looks like 'https://{username}-{repo_name}.hf.space'." + ) + ) + return ui + + +@experimental +def webhook_endpoint(path: Optional[str] = None) -> Callable: + """Decorator to start a [`WebhooksServer`] and register the decorated function as a webhook endpoint. + + This is a helper to get started quickly. If you need more flexibility (custom landing page or webhook secret), + you can use [`WebhooksServer`] directly. You can register multiple webhook endpoints (to the same server) by using + this decorator multiple times. + + Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to setup your + server and deploy it on a Space. + + + + `webhook_endpoint` is experimental. Its API is subject to change in the future. + + + + + + You must have `gradio` installed to use `webhook_endpoint` (`pip install --upgrade gradio`). + + + + Args: + path (`str`, optional): + The URL path to register the webhook function. If not provided, the function name will be used as the path. + In any case, all webhooks are registered under `/webhooks`. + + Examples: + The default usage is to register a function as a webhook endpoint. The function name will be used as the path. + The server will be started automatically at exit (i.e. at the end of the script). + + ```python + from huggingface_hub import webhook_endpoint, WebhookPayload + + @webhook_endpoint + async def trigger_training(payload: WebhookPayload): + if payload.repo.type == "dataset" and payload.event.action == "update": + # Trigger a training job if a dataset is updated + ... + + # Server is automatically started at the end of the script. + ``` + + Advanced usage: register a function as a webhook endpoint and start the server manually. This is useful if you + are running it in a notebook. + + ```python + from huggingface_hub import webhook_endpoint, WebhookPayload + + @webhook_endpoint + async def trigger_training(payload: WebhookPayload): + if payload.repo.type == "dataset" and payload.event.action == "update": + # Trigger a training job if a dataset is updated + ... + + # Start the server manually + trigger_training.launch() + ``` + """ + if callable(path): + # If path is a function, it means it was used as a decorator without arguments + return webhook_endpoint()(path) + + @wraps(WebhooksServer.add_webhook) + def _inner(func: Callable) -> Callable: + app = _get_global_app() + app.add_webhook(path)(func) + if len(app.registered_webhooks) == 1: + # Register `app.launch` to run at exit (only once) + atexit.register(app.launch) + + @wraps(app.launch) + def _launch_now(): + # Run the app directly (without waiting atexit) + atexit.unregister(app.launch) + app.launch() + + func.launch = _launch_now # type: ignore + return func + + return _inner + + +def _get_global_app() -> WebhooksServer: + global _global_app + if _global_app is None: + _global_app = WebhooksServer() + return _global_app + + +def _warn_on_empty_secret(webhook_secret: Optional[str]) -> None: + if webhook_secret is None: + print("Webhook secret is not defined. This means your webhook endpoints will be open to everyone.") + print( + "To add a secret, set `WEBHOOK_SECRET` as environment variable or pass it at initialization: " + "\n\t`app = WebhooksServer(webhook_secret='my_secret', ...)`" + ) + print( + "For more details about webhook secrets, please refer to" + " https://huggingface.co/docs/hub/webhooks#webhook-secret." + ) + else: + print("Webhook secret is correctly defined.") + + +def _get_webhook_doc_url(webhook_name: str, webhook_path: str) -> str: + """Returns the anchor to a given webhook in the docs (experimental)""" + return "/docs#/default/" + webhook_name + webhook_path.replace("/", "_") + "_post" + + +def _wrap_webhook_to_check_secret(func: Callable, webhook_secret: str) -> Callable: + """Wraps a webhook function to check the webhook secret before calling the function. + + This is a hacky way to add the `request` parameter to the function signature. Since FastAPI based itself on route + parameters to inject the values to the function, we need to hack the function signature to retrieve the `Request` + object (and hence the headers). A far cleaner solution would be to use a middleware. However, since + `fastapi==0.90.1`, a middleware cannot be added once the app has started. And since the FastAPI app is started by + Gradio internals (and not by us), we cannot add a middleware. + + This method is called only when a secret has been defined by the user. If a request is sent without the + "x-webhook-secret", the function will return a 401 error (unauthorized). If the header is sent but is incorrect, + the function will return a 403 error (forbidden). + + Inspired by https://stackoverflow.com/a/33112180. + """ + initial_sig = inspect.signature(func) + + @wraps(func) + async def _protected_func(request: Request, **kwargs): + request_secret = request.headers.get("x-webhook-secret") + if request_secret is None: + return JSONResponse({"error": "x-webhook-secret header not set."}, status_code=401) + if request_secret != webhook_secret: + return JSONResponse({"error": "Invalid webhook secret."}, status_code=403) + + # Inject `request` in kwargs if required + if "request" in initial_sig.parameters: + kwargs["request"] = request + + # Handle both sync and async routes + if inspect.iscoroutinefunction(func): + return await func(**kwargs) + else: + return func(**kwargs) + + # Update signature to include request + if "request" not in initial_sig.parameters: + _protected_func.__signature__ = initial_sig.replace( # type: ignore + parameters=( + inspect.Parameter(name="request", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Request), + ) + + tuple(initial_sig.parameters.values()) + ) + + # Return protected route + return _protected_func diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/community.py b/.venv/lib/python3.13/site-packages/huggingface_hub/community.py new file mode 100644 index 0000000000000000000000000000000000000000..16f2f02428dd5c2ce6437534af0397801bda45c5 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/community.py @@ -0,0 +1,355 @@ +""" +Data structures to interact with Discussions and Pull Requests on the Hub. + +See [the Discussions and Pull Requests guide](https://huggingface.co/docs/hub/repositories-pull-requests-discussions) +for more information on Pull Requests, Discussions, and the community tab. +""" + +from dataclasses import dataclass +from datetime import datetime +from typing import List, Literal, Optional, Union + +from . import constants +from .utils import parse_datetime + + +DiscussionStatus = Literal["open", "closed", "merged", "draft"] + + +@dataclass +class Discussion: + """ + A Discussion or Pull Request on the Hub. + + This dataclass is not intended to be instantiated directly. + + Attributes: + title (`str`): + The title of the Discussion / Pull Request + status (`str`): + The status of the Discussion / Pull Request. + It must be one of: + * `"open"` + * `"closed"` + * `"merged"` (only for Pull Requests ) + * `"draft"` (only for Pull Requests ) + num (`int`): + The number of the Discussion / Pull Request. + repo_id (`str`): + The id (`"{namespace}/{repo_name}"`) of the repo on which + the Discussion / Pull Request was open. + repo_type (`str`): + The type of the repo on which the Discussion / Pull Request was open. + Possible values are: `"model"`, `"dataset"`, `"space"`. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + is_pull_request (`bool`): + Whether or not this is a Pull Request. + created_at (`datetime`): + The `datetime` of creation of the Discussion / Pull Request. + endpoint (`str`): + Endpoint of the Hub. Default is https://huggingface.co. + git_reference (`str`, *optional*): + (property) Git reference to which changes can be pushed if this is a Pull Request, `None` otherwise. + url (`str`): + (property) URL of the discussion on the Hub. + """ + + title: str + status: DiscussionStatus + num: int + repo_id: str + repo_type: str + author: str + is_pull_request: bool + created_at: datetime + endpoint: str + + @property + def git_reference(self) -> Optional[str]: + """ + If this is a Pull Request , returns the git reference to which changes can be pushed. + Returns `None` otherwise. + """ + if self.is_pull_request: + return f"refs/pr/{self.num}" + return None + + @property + def url(self) -> str: + """Returns the URL of the discussion on the Hub.""" + if self.repo_type is None or self.repo_type == constants.REPO_TYPE_MODEL: + return f"{self.endpoint}/{self.repo_id}/discussions/{self.num}" + return f"{self.endpoint}/{self.repo_type}s/{self.repo_id}/discussions/{self.num}" + + +@dataclass +class DiscussionWithDetails(Discussion): + """ + Subclass of [`Discussion`]. + + Attributes: + title (`str`): + The title of the Discussion / Pull Request + status (`str`): + The status of the Discussion / Pull Request. + It can be one of: + * `"open"` + * `"closed"` + * `"merged"` (only for Pull Requests ) + * `"draft"` (only for Pull Requests ) + num (`int`): + The number of the Discussion / Pull Request. + repo_id (`str`): + The id (`"{namespace}/{repo_name}"`) of the repo on which + the Discussion / Pull Request was open. + repo_type (`str`): + The type of the repo on which the Discussion / Pull Request was open. + Possible values are: `"model"`, `"dataset"`, `"space"`. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + is_pull_request (`bool`): + Whether or not this is a Pull Request. + created_at (`datetime`): + The `datetime` of creation of the Discussion / Pull Request. + events (`list` of [`DiscussionEvent`]) + The list of [`DiscussionEvents`] in this Discussion or Pull Request. + conflicting_files (`Union[List[str], bool, None]`, *optional*): + A list of conflicting files if this is a Pull Request. + `None` if `self.is_pull_request` is `False`. + `True` if there are conflicting files but the list can't be retrieved. + target_branch (`str`, *optional*): + The branch into which changes are to be merged if this is a + Pull Request . `None` if `self.is_pull_request` is `False`. + merge_commit_oid (`str`, *optional*): + If this is a merged Pull Request , this is set to the OID / SHA of + the merge commit, `None` otherwise. + diff (`str`, *optional*): + The git diff if this is a Pull Request , `None` otherwise. + endpoint (`str`): + Endpoint of the Hub. Default is https://huggingface.co. + git_reference (`str`, *optional*): + (property) Git reference to which changes can be pushed if this is a Pull Request, `None` otherwise. + url (`str`): + (property) URL of the discussion on the Hub. + """ + + events: List["DiscussionEvent"] + conflicting_files: Union[List[str], bool, None] + target_branch: Optional[str] + merge_commit_oid: Optional[str] + diff: Optional[str] + + +@dataclass +class DiscussionEvent: + """ + An event in a Discussion or Pull Request. + + Use concrete classes: + * [`DiscussionComment`] + * [`DiscussionStatusChange`] + * [`DiscussionCommit`] + * [`DiscussionTitleChange`] + + Attributes: + id (`str`): + The ID of the event. An hexadecimal string. + type (`str`): + The type of the event. + created_at (`datetime`): + A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime) + object holding the creation timestamp for the event. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + """ + + id: str + type: str + created_at: datetime + author: str + + _event: dict + """Stores the original event data, in case we need to access it later.""" + + +@dataclass +class DiscussionComment(DiscussionEvent): + """A comment in a Discussion / Pull Request. + + Subclass of [`DiscussionEvent`]. + + + Attributes: + id (`str`): + The ID of the event. An hexadecimal string. + type (`str`): + The type of the event. + created_at (`datetime`): + A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime) + object holding the creation timestamp for the event. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + content (`str`): + The raw markdown content of the comment. Mentions, links and images are not rendered. + edited (`bool`): + Whether or not this comment has been edited. + hidden (`bool`): + Whether or not this comment has been hidden. + """ + + content: str + edited: bool + hidden: bool + + @property + def rendered(self) -> str: + """The rendered comment, as a HTML string""" + return self._event["data"]["latest"]["html"] + + @property + def last_edited_at(self) -> datetime: + """The last edit time, as a `datetime` object.""" + return parse_datetime(self._event["data"]["latest"]["updatedAt"]) + + @property + def last_edited_by(self) -> str: + """The last edit time, as a `datetime` object.""" + return self._event["data"]["latest"].get("author", {}).get("name", "deleted") + + @property + def edit_history(self) -> List[dict]: + """The edit history of the comment""" + return self._event["data"]["history"] + + @property + def number_of_edits(self) -> int: + return len(self.edit_history) + + +@dataclass +class DiscussionStatusChange(DiscussionEvent): + """A change of status in a Discussion / Pull Request. + + Subclass of [`DiscussionEvent`]. + + Attributes: + id (`str`): + The ID of the event. An hexadecimal string. + type (`str`): + The type of the event. + created_at (`datetime`): + A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime) + object holding the creation timestamp for the event. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + new_status (`str`): + The status of the Discussion / Pull Request after the change. + It can be one of: + * `"open"` + * `"closed"` + * `"merged"` (only for Pull Requests ) + """ + + new_status: str + + +@dataclass +class DiscussionCommit(DiscussionEvent): + """A commit in a Pull Request. + + Subclass of [`DiscussionEvent`]. + + Attributes: + id (`str`): + The ID of the event. An hexadecimal string. + type (`str`): + The type of the event. + created_at (`datetime`): + A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime) + object holding the creation timestamp for the event. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + summary (`str`): + The summary of the commit. + oid (`str`): + The OID / SHA of the commit, as a hexadecimal string. + """ + + summary: str + oid: str + + +@dataclass +class DiscussionTitleChange(DiscussionEvent): + """A rename event in a Discussion / Pull Request. + + Subclass of [`DiscussionEvent`]. + + Attributes: + id (`str`): + The ID of the event. An hexadecimal string. + type (`str`): + The type of the event. + created_at (`datetime`): + A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime) + object holding the creation timestamp for the event. + author (`str`): + The username of the Discussion / Pull Request author. + Can be `"deleted"` if the user has been deleted since. + old_title (`str`): + The previous title for the Discussion / Pull Request. + new_title (`str`): + The new title. + """ + + old_title: str + new_title: str + + +def deserialize_event(event: dict) -> DiscussionEvent: + """Instantiates a [`DiscussionEvent`] from a dict""" + event_id: str = event["id"] + event_type: str = event["type"] + created_at = parse_datetime(event["createdAt"]) + + common_args = dict( + id=event_id, + type=event_type, + created_at=created_at, + author=event.get("author", {}).get("name", "deleted"), + _event=event, + ) + + if event_type == "comment": + return DiscussionComment( + **common_args, + edited=event["data"]["edited"], + hidden=event["data"]["hidden"], + content=event["data"]["latest"]["raw"], + ) + if event_type == "status-change": + return DiscussionStatusChange( + **common_args, + new_status=event["data"]["status"], + ) + if event_type == "commit": + return DiscussionCommit( + **common_args, + summary=event["data"]["subject"], + oid=event["data"]["oid"], + ) + if event_type == "title-change": + return DiscussionTitleChange( + **common_args, + old_title=event["data"]["from"], + new_title=event["data"]["to"], + ) + + return DiscussionEvent(**common_args) diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/constants.py b/.venv/lib/python3.13/site-packages/huggingface_hub/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..9e28d84a4b9409d7252e97aee8efb609459eb7db --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/constants.py @@ -0,0 +1,293 @@ +import os +import re +import typing +from typing import Literal, Optional, Tuple + + +# Possible values for env variables + + +ENV_VARS_TRUE_VALUES = {"1", "ON", "YES", "TRUE"} +ENV_VARS_TRUE_AND_AUTO_VALUES = ENV_VARS_TRUE_VALUES.union({"AUTO"}) + + +def _is_true(value: Optional[str]) -> bool: + if value is None: + return False + return value.upper() in ENV_VARS_TRUE_VALUES + + +def _as_int(value: Optional[str]) -> Optional[int]: + if value is None: + return None + return int(value) + + +# Constants for file downloads + +PYTORCH_WEIGHTS_NAME = "pytorch_model.bin" +TF2_WEIGHTS_NAME = "tf_model.h5" +TF_WEIGHTS_NAME = "model.ckpt" +FLAX_WEIGHTS_NAME = "flax_model.msgpack" +CONFIG_NAME = "config.json" +REPOCARD_NAME = "README.md" +DEFAULT_ETAG_TIMEOUT = 10 +DEFAULT_DOWNLOAD_TIMEOUT = 10 +DEFAULT_REQUEST_TIMEOUT = 10 +DOWNLOAD_CHUNK_SIZE = 10 * 1024 * 1024 +HF_TRANSFER_CONCURRENCY = 100 +MAX_HTTP_DOWNLOAD_SIZE = 50 * 1000 * 1000 * 1000 # 50 GB + +# Constants for serialization + +PYTORCH_WEIGHTS_FILE_PATTERN = "pytorch_model{suffix}.bin" # Unsafe pickle: use safetensors instead +SAFETENSORS_WEIGHTS_FILE_PATTERN = "model{suffix}.safetensors" +TF2_WEIGHTS_FILE_PATTERN = "tf_model{suffix}.h5" + +# Constants for safetensors repos + +SAFETENSORS_SINGLE_FILE = "model.safetensors" +SAFETENSORS_INDEX_FILE = "model.safetensors.index.json" +SAFETENSORS_MAX_HEADER_LENGTH = 25_000_000 + +# Timeout of aquiring file lock and logging the attempt +FILELOCK_LOG_EVERY_SECONDS = 10 + +# Git-related constants + +DEFAULT_REVISION = "main" +REGEX_COMMIT_OID = re.compile(r"[A-Fa-f0-9]{5,40}") + +HUGGINGFACE_CO_URL_HOME = "https://huggingface.co/" + +_staging_mode = _is_true(os.environ.get("HUGGINGFACE_CO_STAGING")) + +_HF_DEFAULT_ENDPOINT = "https://huggingface.co" +_HF_DEFAULT_STAGING_ENDPOINT = "https://hub-ci.huggingface.co" +ENDPOINT = os.getenv("HF_ENDPOINT", _HF_DEFAULT_ENDPOINT).rstrip("/") +HUGGINGFACE_CO_URL_TEMPLATE = ENDPOINT + "/{repo_id}/resolve/{revision}/{filename}" + +if _staging_mode: + ENDPOINT = _HF_DEFAULT_STAGING_ENDPOINT + HUGGINGFACE_CO_URL_TEMPLATE = _HF_DEFAULT_STAGING_ENDPOINT + "/{repo_id}/resolve/{revision}/{filename}" + +HUGGINGFACE_HEADER_X_REPO_COMMIT = "X-Repo-Commit" +HUGGINGFACE_HEADER_X_LINKED_ETAG = "X-Linked-Etag" +HUGGINGFACE_HEADER_X_LINKED_SIZE = "X-Linked-Size" +HUGGINGFACE_HEADER_X_BILL_TO = "X-HF-Bill-To" + +INFERENCE_ENDPOINT = os.environ.get("HF_INFERENCE_ENDPOINT", "https://api-inference.huggingface.co") + +# See https://huggingface.co/docs/inference-endpoints/index +INFERENCE_ENDPOINTS_ENDPOINT = "https://api.endpoints.huggingface.cloud/v2" +INFERENCE_CATALOG_ENDPOINT = "https://endpoints.huggingface.co/api/catalog" + +# See https://api.endpoints.huggingface.cloud/#post-/v2/endpoint/-namespace- +INFERENCE_ENDPOINT_IMAGE_KEYS = [ + "custom", + "huggingface", + "huggingfaceNeuron", + "llamacpp", + "tei", + "tgi", + "tgiNeuron", +] + +# Proxy for third-party providers +INFERENCE_PROXY_TEMPLATE = "https://router.huggingface.co/{provider}" + +REPO_ID_SEPARATOR = "--" +# ^ this substring is not allowed in repo_ids on hf.co +# and is the canonical one we use for serialization of repo ids elsewhere. + + +REPO_TYPE_DATASET = "dataset" +REPO_TYPE_SPACE = "space" +REPO_TYPE_MODEL = "model" +REPO_TYPES = [None, REPO_TYPE_MODEL, REPO_TYPE_DATASET, REPO_TYPE_SPACE] +SPACES_SDK_TYPES = ["gradio", "streamlit", "docker", "static"] + +REPO_TYPES_URL_PREFIXES = { + REPO_TYPE_DATASET: "datasets/", + REPO_TYPE_SPACE: "spaces/", +} +REPO_TYPES_MAPPING = { + "datasets": REPO_TYPE_DATASET, + "spaces": REPO_TYPE_SPACE, + "models": REPO_TYPE_MODEL, +} + +DiscussionTypeFilter = Literal["all", "discussion", "pull_request"] +DISCUSSION_TYPES: Tuple[DiscussionTypeFilter, ...] = typing.get_args(DiscussionTypeFilter) +DiscussionStatusFilter = Literal["all", "open", "closed"] +DISCUSSION_STATUS: Tuple[DiscussionTypeFilter, ...] = typing.get_args(DiscussionStatusFilter) + +# Webhook subscription types +WEBHOOK_DOMAIN_T = Literal["repo", "discussions"] + +# default cache +default_home = os.path.join(os.path.expanduser("~"), ".cache") +HF_HOME = os.path.expandvars( + os.path.expanduser( + os.getenv( + "HF_HOME", + os.path.join(os.getenv("XDG_CACHE_HOME", default_home), "huggingface"), + ) + ) +) +hf_cache_home = HF_HOME # for backward compatibility. TODO: remove this in 1.0.0 + +default_cache_path = os.path.join(HF_HOME, "hub") +default_assets_cache_path = os.path.join(HF_HOME, "assets") + +# Legacy env variables +HUGGINGFACE_HUB_CACHE = os.getenv("HUGGINGFACE_HUB_CACHE", default_cache_path) +HUGGINGFACE_ASSETS_CACHE = os.getenv("HUGGINGFACE_ASSETS_CACHE", default_assets_cache_path) + +# New env variables +HF_HUB_CACHE = os.path.expandvars( + os.path.expanduser( + os.getenv( + "HF_HUB_CACHE", + HUGGINGFACE_HUB_CACHE, + ) + ) +) +HF_ASSETS_CACHE = os.path.expandvars( + os.path.expanduser( + os.getenv( + "HF_ASSETS_CACHE", + HUGGINGFACE_ASSETS_CACHE, + ) + ) +) + +HF_HUB_OFFLINE = _is_true(os.environ.get("HF_HUB_OFFLINE") or os.environ.get("TRANSFORMERS_OFFLINE")) + +# If set, log level will be set to DEBUG and all requests made to the Hub will be logged +# as curl commands for reproducibility. +HF_DEBUG = _is_true(os.environ.get("HF_DEBUG")) + +# Opt-out from telemetry requests +HF_HUB_DISABLE_TELEMETRY = ( + _is_true(os.environ.get("HF_HUB_DISABLE_TELEMETRY")) # HF-specific env variable + or _is_true(os.environ.get("DISABLE_TELEMETRY")) + or _is_true(os.environ.get("DO_NOT_TRACK")) # https://consoledonottrack.com/ +) + +HF_TOKEN_PATH = os.path.expandvars( + os.path.expanduser( + os.getenv( + "HF_TOKEN_PATH", + os.path.join(HF_HOME, "token"), + ) + ) +) +HF_STORED_TOKENS_PATH = os.path.join(os.path.dirname(HF_TOKEN_PATH), "stored_tokens") + +if _staging_mode: + # In staging mode, we use a different cache to ensure we don't mix up production and staging data or tokens + # In practice in `huggingface_hub` tests, we monkeypatch these values with temporary directories. The following + # lines are only used in third-party libraries tests (e.g. `transformers`, `diffusers`, etc.). + _staging_home = os.path.join(os.path.expanduser("~"), ".cache", "huggingface_staging") + HUGGINGFACE_HUB_CACHE = os.path.join(_staging_home, "hub") + HF_TOKEN_PATH = os.path.join(_staging_home, "token") + +# Here, `True` will disable progress bars globally without possibility of enabling it +# programmatically. `False` will enable them without possibility of disabling them. +# If environment variable is not set (None), then the user is free to enable/disable +# them programmatically. +# TL;DR: env variable has priority over code +__HF_HUB_DISABLE_PROGRESS_BARS = os.environ.get("HF_HUB_DISABLE_PROGRESS_BARS") +HF_HUB_DISABLE_PROGRESS_BARS: Optional[bool] = ( + _is_true(__HF_HUB_DISABLE_PROGRESS_BARS) if __HF_HUB_DISABLE_PROGRESS_BARS is not None else None +) + +# Disable warning on machines that do not support symlinks (e.g. Windows non-developer) +HF_HUB_DISABLE_SYMLINKS_WARNING: bool = _is_true(os.environ.get("HF_HUB_DISABLE_SYMLINKS_WARNING")) + +# Disable warning when using experimental features +HF_HUB_DISABLE_EXPERIMENTAL_WARNING: bool = _is_true(os.environ.get("HF_HUB_DISABLE_EXPERIMENTAL_WARNING")) + +# Disable sending the cached token by default is all HTTP requests to the Hub +HF_HUB_DISABLE_IMPLICIT_TOKEN: bool = _is_true(os.environ.get("HF_HUB_DISABLE_IMPLICIT_TOKEN")) + +# Enable fast-download using external dependency "hf_transfer" +# See: +# - https://pypi.org/project/hf-transfer/ +# - https://github.com/huggingface/hf_transfer (private) +HF_HUB_ENABLE_HF_TRANSFER: bool = _is_true(os.environ.get("HF_HUB_ENABLE_HF_TRANSFER")) + + +# UNUSED +# We don't use symlinks in local dir anymore. +HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD: int = ( + _as_int(os.environ.get("HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD")) or 5 * 1024 * 1024 +) + +# Used to override the etag timeout on a system level +HF_HUB_ETAG_TIMEOUT: int = _as_int(os.environ.get("HF_HUB_ETAG_TIMEOUT")) or DEFAULT_ETAG_TIMEOUT + +# Used to override the get request timeout on a system level +HF_HUB_DOWNLOAD_TIMEOUT: int = _as_int(os.environ.get("HF_HUB_DOWNLOAD_TIMEOUT")) or DEFAULT_DOWNLOAD_TIMEOUT + +# Allows to add information about the requester in the user-agent (eg. partner name) +HF_HUB_USER_AGENT_ORIGIN: Optional[str] = os.environ.get("HF_HUB_USER_AGENT_ORIGIN") + +# List frameworks that are handled by the InferenceAPI service. Useful to scan endpoints and check which models are +# deployed and running. Since 95% of the models are using the top 4 frameworks listed below, we scan only those by +# default. We still keep the full list of supported frameworks in case we want to scan all of them. +MAIN_INFERENCE_API_FRAMEWORKS = [ + "diffusers", + "sentence-transformers", + "text-generation-inference", + "transformers", +] + +ALL_INFERENCE_API_FRAMEWORKS = MAIN_INFERENCE_API_FRAMEWORKS + [ + "adapter-transformers", + "allennlp", + "asteroid", + "bertopic", + "doctr", + "espnet", + "fairseq", + "fastai", + "fasttext", + "flair", + "k2", + "keras", + "mindspore", + "nemo", + "open_clip", + "paddlenlp", + "peft", + "pyannote-audio", + "sklearn", + "spacy", + "span-marker", + "speechbrain", + "stanza", + "timm", +] + +# If OAuth didn't work after 2 redirects, there's likely a third-party cookie issue in the Space iframe view. +# In this case, we redirect the user to the non-iframe view. +OAUTH_MAX_REDIRECTS = 2 + +# OAuth-related environment variables injected by the Space +OAUTH_CLIENT_ID = os.environ.get("OAUTH_CLIENT_ID") +OAUTH_CLIENT_SECRET = os.environ.get("OAUTH_CLIENT_SECRET") +OAUTH_SCOPES = os.environ.get("OAUTH_SCOPES") +OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL") + +# Xet constants +HUGGINGFACE_HEADER_X_XET_ENDPOINT = "X-Xet-Cas-Url" +HUGGINGFACE_HEADER_X_XET_ACCESS_TOKEN = "X-Xet-Access-Token" +HUGGINGFACE_HEADER_X_XET_EXPIRATION = "X-Xet-Token-Expiration" +HUGGINGFACE_HEADER_X_XET_HASH = "X-Xet-Hash" +HUGGINGFACE_HEADER_X_XET_REFRESH_ROUTE = "X-Xet-Refresh-Route" +HUGGINGFACE_HEADER_LINK_XET_AUTH_KEY = "xet-auth" + +default_xet_cache_path = os.path.join(HF_HOME, "xet") +HF_XET_CACHE = os.getenv("HF_XET_CACHE", default_xet_cache_path) diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/file_download.py b/.venv/lib/python3.13/site-packages/huggingface_hub/file_download.py new file mode 100644 index 0000000000000000000000000000000000000000..98748fd4ddce9d66dcf9e3f451e3ff18129e4785 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/file_download.py @@ -0,0 +1,1803 @@ +import copy +import errno +import inspect +import os +import re +import shutil +import stat +import time +import uuid +import warnings +from dataclasses import dataclass +from pathlib import Path +from typing import Any, BinaryIO, Dict, Literal, NoReturn, Optional, Tuple, Union +from urllib.parse import quote, urlparse + +import requests + +from . import ( + __version__, # noqa: F401 # for backward compatibility + constants, +) +from ._local_folder import get_local_download_paths, read_download_metadata, write_download_metadata +from .constants import ( + HUGGINGFACE_CO_URL_TEMPLATE, # noqa: F401 # for backward compatibility + HUGGINGFACE_HUB_CACHE, # noqa: F401 # for backward compatibility +) +from .errors import ( + EntryNotFoundError, + FileMetadataError, + GatedRepoError, + HfHubHTTPError, + LocalEntryNotFoundError, + RepositoryNotFoundError, + RevisionNotFoundError, +) +from .utils import ( + OfflineModeIsEnabled, + SoftTemporaryDirectory, + WeakFileLock, + XetFileData, + build_hf_headers, + get_fastai_version, # noqa: F401 # for backward compatibility + get_fastcore_version, # noqa: F401 # for backward compatibility + get_graphviz_version, # noqa: F401 # for backward compatibility + get_jinja_version, # noqa: F401 # for backward compatibility + get_pydot_version, # noqa: F401 # for backward compatibility + get_tf_version, # noqa: F401 # for backward compatibility + get_torch_version, # noqa: F401 # for backward compatibility + hf_raise_for_status, + is_fastai_available, # noqa: F401 # for backward compatibility + is_fastcore_available, # noqa: F401 # for backward compatibility + is_graphviz_available, # noqa: F401 # for backward compatibility + is_jinja_available, # noqa: F401 # for backward compatibility + is_pydot_available, # noqa: F401 # for backward compatibility + is_tf_available, # noqa: F401 # for backward compatibility + is_torch_available, # noqa: F401 # for backward compatibility + logging, + parse_xet_file_data_from_response, + refresh_xet_connection_info, + reset_sessions, + tqdm, + validate_hf_hub_args, +) +from .utils._http import _adjust_range_header, http_backoff +from .utils._runtime import _PY_VERSION, is_xet_available # noqa: F401 # for backward compatibility +from .utils._typing import HTTP_METHOD_T +from .utils.sha import sha_fileobj +from .utils.tqdm import _get_progress_bar_context + + +logger = logging.get_logger(__name__) + +# Return value when trying to load a file from cache but the file does not exist in the distant repo. +_CACHED_NO_EXIST = object() +_CACHED_NO_EXIST_T = Any + +# Regex to get filename from a "Content-Disposition" header for CDN-served files +HEADER_FILENAME_PATTERN = re.compile(r'filename="(?P.*?)";') + +# Regex to check if the revision IS directly a commit_hash +REGEX_COMMIT_HASH = re.compile(r"^[0-9a-f]{40}$") + +# Regex to check if the file etag IS a valid sha256 +REGEX_SHA256 = re.compile(r"^[0-9a-f]{64}$") + +_are_symlinks_supported_in_dir: Dict[str, bool] = {} + + +def are_symlinks_supported(cache_dir: Union[str, Path, None] = None) -> bool: + """Return whether the symlinks are supported on the machine. + + Since symlinks support can change depending on the mounted disk, we need to check + on the precise cache folder. By default, the default HF cache directory is checked. + + Args: + cache_dir (`str`, `Path`, *optional*): + Path to the folder where cached files are stored. + + Returns: [bool] Whether symlinks are supported in the directory. + """ + # Defaults to HF cache + if cache_dir is None: + cache_dir = constants.HF_HUB_CACHE + cache_dir = str(Path(cache_dir).expanduser().resolve()) # make it unique + + # Check symlink compatibility only once (per cache directory) at first time use + if cache_dir not in _are_symlinks_supported_in_dir: + _are_symlinks_supported_in_dir[cache_dir] = True + + os.makedirs(cache_dir, exist_ok=True) + with SoftTemporaryDirectory(dir=cache_dir) as tmpdir: + src_path = Path(tmpdir) / "dummy_file_src" + src_path.touch() + dst_path = Path(tmpdir) / "dummy_file_dst" + + # Relative source path as in `_create_symlink`` + relative_src = os.path.relpath(src_path, start=os.path.dirname(dst_path)) + try: + os.symlink(relative_src, dst_path) + except OSError: + # Likely running on Windows + _are_symlinks_supported_in_dir[cache_dir] = False + + if not constants.HF_HUB_DISABLE_SYMLINKS_WARNING: + message = ( + "`huggingface_hub` cache-system uses symlinks by default to" + " efficiently store duplicated files but your machine does not" + f" support them in {cache_dir}. Caching files will still work" + " but in a degraded version that might require more space on" + " your disk. This warning can be disabled by setting the" + " `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For" + " more details, see" + " https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations." + ) + if os.name == "nt": + message += ( + "\nTo support symlinks on Windows, you either need to" + " activate Developer Mode or to run Python as an" + " administrator. In order to activate developer mode," + " see this article:" + " https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development" + ) + warnings.warn(message) + + return _are_symlinks_supported_in_dir[cache_dir] + + +@dataclass(frozen=True) +class HfFileMetadata: + """Data structure containing information about a file versioned on the Hub. + + Returned by [`get_hf_file_metadata`] based on a URL. + + Args: + commit_hash (`str`, *optional*): + The commit_hash related to the file. + etag (`str`, *optional*): + Etag of the file on the server. + location (`str`): + Location where to download the file. Can be a Hub url or not (CDN). + size (`size`): + Size of the file. In case of an LFS file, contains the size of the actual + LFS file, not the pointer. + xet_file_data (`XetFileData`, *optional*): + Xet information for the file. This is only set if the file is stored using Xet storage. + """ + + commit_hash: Optional[str] + etag: Optional[str] + location: str + size: Optional[int] + xet_file_data: Optional[XetFileData] + + +@validate_hf_hub_args +def hf_hub_url( + repo_id: str, + filename: str, + *, + subfolder: Optional[str] = None, + repo_type: Optional[str] = None, + revision: Optional[str] = None, + endpoint: Optional[str] = None, +) -> str: + """Construct the URL of a file from the given information. + + The resolved address can either be a huggingface.co-hosted url, or a link to + Cloudfront (a Content Delivery Network, or CDN) for large files which are + more than a few MBs. + + Args: + repo_id (`str`): + A namespace (user or an organization) name and a repo name separated + by a `/`. + filename (`str`): + The name of the file in the repo. + subfolder (`str`, *optional*): + An optional value corresponding to a folder inside the repo. + repo_type (`str`, *optional*): + Set to `"dataset"` or `"space"` if downloading from a dataset or space, + `None` or `"model"` if downloading from a model. Default is `None`. + revision (`str`, *optional*): + An optional Git revision id which can be a branch name, a tag, or a + commit hash. + + Example: + + ```python + >>> from huggingface_hub import hf_hub_url + + >>> hf_hub_url( + ... repo_id="julien-c/EsperBERTo-small", filename="pytorch_model.bin" + ... ) + 'https://huggingface.co/julien-c/EsperBERTo-small/resolve/main/pytorch_model.bin' + ``` + + + + Notes: + + Cloudfront is replicated over the globe so downloads are way faster for + the end user (and it also lowers our bandwidth costs). + + Cloudfront aggressively caches files by default (default TTL is 24 + hours), however this is not an issue here because we implement a + git-based versioning system on huggingface.co, which means that we store + the files on S3/Cloudfront in a content-addressable way (i.e., the file + name is its hash). Using content-addressable filenames means cache can't + ever be stale. + + In terms of client-side caching from this library, we base our caching + on the objects' entity tag (`ETag`), which is an identifier of a + specific version of a resource [1]_. An object's ETag is: its git-sha1 + if stored in git, or its sha256 if stored in git-lfs. + + + + References: + + - [1] https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag + """ + if subfolder == "": + subfolder = None + if subfolder is not None: + filename = f"{subfolder}/{filename}" + + if repo_type not in constants.REPO_TYPES: + raise ValueError("Invalid repo type") + + if repo_type in constants.REPO_TYPES_URL_PREFIXES: + repo_id = constants.REPO_TYPES_URL_PREFIXES[repo_type] + repo_id + + if revision is None: + revision = constants.DEFAULT_REVISION + url = HUGGINGFACE_CO_URL_TEMPLATE.format( + repo_id=repo_id, revision=quote(revision, safe=""), filename=quote(filename) + ) + # Update endpoint if provided + if endpoint is not None and url.startswith(constants.ENDPOINT): + url = endpoint + url[len(constants.ENDPOINT) :] + return url + + +def _request_wrapper( + method: HTTP_METHOD_T, url: str, *, follow_relative_redirects: bool = False, **params +) -> requests.Response: + """Wrapper around requests methods to follow relative redirects if `follow_relative_redirects=True` even when + `allow_redirection=False`. + + A backoff mechanism retries the HTTP call on 429, 503 and 504 errors. + + Args: + method (`str`): + HTTP method, such as 'GET' or 'HEAD'. + url (`str`): + The URL of the resource to fetch. + follow_relative_redirects (`bool`, *optional*, defaults to `False`) + If True, relative redirection (redirection to the same site) will be resolved even when `allow_redirection` + kwarg is set to False. Useful when we want to follow a redirection to a renamed repository without + following redirection to a CDN. + **params (`dict`, *optional*): + Params to pass to `requests.request`. + """ + # Recursively follow relative redirects + if follow_relative_redirects: + response = _request_wrapper( + method=method, + url=url, + follow_relative_redirects=False, + **params, + ) + + # If redirection, we redirect only relative paths. + # This is useful in case of a renamed repository. + if 300 <= response.status_code <= 399: + parsed_target = urlparse(response.headers["Location"]) + if parsed_target.netloc == "": + # This means it is a relative 'location' headers, as allowed by RFC 7231. + # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource') + # We want to follow this relative redirect ! + # + # Highly inspired by `resolve_redirects` from requests library. + # See https://github.com/psf/requests/blob/main/requests/sessions.py#L159 + next_url = urlparse(url)._replace(path=parsed_target.path).geturl() + return _request_wrapper(method=method, url=next_url, follow_relative_redirects=True, **params) + return response + + # Perform request and return if status_code is not in the retry list. + response = http_backoff(method=method, url=url, **params, retry_on_exceptions=(), retry_on_status_codes=(429,)) + hf_raise_for_status(response) + return response + + +def _get_file_length_from_http_response(response: requests.Response) -> Optional[int]: + """ + Get the length of the file from the HTTP response headers. + + This function extracts the file size from the HTTP response headers, either from the + `Content-Range` or `Content-Length` header, if available (in that order). + The HTTP response object containing the headers. + `int` or `None`: The length of the file in bytes if the information is available, + otherwise `None`. + + Args: + response (`requests.Response`): + The HTTP response object. + + Returns: + `int` or `None`: The length of the file in bytes, or None if not available. + """ + + content_range = response.headers.get("Content-Range") + if content_range is not None: + return int(content_range.rsplit("/")[-1]) + + content_length = response.headers.get("Content-Length") + if content_length is not None: + return int(content_length) + + return None + + +def http_get( + url: str, + temp_file: BinaryIO, + *, + proxies: Optional[Dict] = None, + resume_size: int = 0, + headers: Optional[Dict[str, Any]] = None, + expected_size: Optional[int] = None, + displayed_filename: Optional[str] = None, + _nb_retries: int = 5, + _tqdm_bar: Optional[tqdm] = None, +) -> None: + """ + Download a remote file. Do not gobble up errors, and will return errors tailored to the Hugging Face Hub. + + If ConnectionError (SSLError) or ReadTimeout happen while streaming data from the server, it is most likely a + transient error (network outage?). We log a warning message and try to resume the download a few times before + giving up. The method gives up after 5 attempts if no new data has being received from the server. + + Args: + url (`str`): + The URL of the file to download. + temp_file (`BinaryIO`): + The file-like object where to save the file. + proxies (`dict`, *optional*): + Dictionary mapping protocol to the URL of the proxy passed to `requests.request`. + resume_size (`int`, *optional*): + The number of bytes already downloaded. If set to 0 (default), the whole file is download. If set to a + positive number, the download will resume at the given position. + headers (`dict`, *optional*): + Dictionary of HTTP Headers to send with the request. + expected_size (`int`, *optional*): + The expected size of the file to download. If set, the download will raise an error if the size of the + received content is different from the expected one. + displayed_filename (`str`, *optional*): + The filename of the file that is being downloaded. Value is used only to display a nice progress bar. If + not set, the filename is guessed from the URL or the `Content-Disposition` header. + """ + if expected_size is not None and resume_size == expected_size: + # If the file is already fully downloaded, we don't need to download it again. + return + + has_custom_range_header = headers is not None and any(h.lower() == "range" for h in headers) + hf_transfer = None + if constants.HF_HUB_ENABLE_HF_TRANSFER: + if resume_size != 0: + warnings.warn("'hf_transfer' does not support `resume_size`: falling back to regular download method") + elif proxies is not None: + warnings.warn("'hf_transfer' does not support `proxies`: falling back to regular download method") + elif has_custom_range_header: + warnings.warn("'hf_transfer' ignores custom 'Range' headers; falling back to regular download method") + else: + try: + import hf_transfer # type: ignore[no-redef] + except ImportError: + raise ValueError( + "Fast download using 'hf_transfer' is enabled" + " (HF_HUB_ENABLE_HF_TRANSFER=1) but 'hf_transfer' package is not" + " available in your environment. Try `pip install hf_transfer`." + ) + + initial_headers = headers + headers = copy.deepcopy(headers) or {} + if resume_size > 0: + headers["Range"] = _adjust_range_header(headers.get("Range"), resume_size) + elif expected_size and expected_size > constants.MAX_HTTP_DOWNLOAD_SIZE: + # Any files over 50GB will not be available through basic http request. + # Setting the range header to 0-0 will force the server to return the file size in the Content-Range header. + # Since hf_transfer splits the download into chunks, the process will succeed afterwards. + if hf_transfer: + headers["Range"] = "bytes=0-0" + else: + raise ValueError( + "The file is too large to be downloaded using the regular download method. Use `hf_transfer` or `hf_xet` instead." + " Try `pip install hf_transfer` or `pip install hf_xet`." + ) + + r = _request_wrapper( + method="GET", url=url, stream=True, proxies=proxies, headers=headers, timeout=constants.HF_HUB_DOWNLOAD_TIMEOUT + ) + + hf_raise_for_status(r) + content_length = _get_file_length_from_http_response(r) + + # NOTE: 'total' is the total number of bytes to download, not the number of bytes in the file. + # If the file is compressed, the number of bytes in the saved file will be higher than 'total'. + total = resume_size + int(content_length) if content_length is not None else None + + if displayed_filename is None: + displayed_filename = url + content_disposition = r.headers.get("Content-Disposition") + if content_disposition is not None: + match = HEADER_FILENAME_PATTERN.search(content_disposition) + if match is not None: + # Means file is on CDN + displayed_filename = match.groupdict()["filename"] + + # Truncate filename if too long to display + if len(displayed_filename) > 40: + displayed_filename = f"(…){displayed_filename[-40:]}" + + consistency_error_message = ( + f"Consistency check failed: file should be of size {expected_size} but has size" + f" {{actual_size}} ({displayed_filename}).\nThis is usually due to network issues while downloading the file." + " Please retry with `force_download=True`." + ) + progress_cm = _get_progress_bar_context( + desc=displayed_filename, + log_level=logger.getEffectiveLevel(), + total=total, + initial=resume_size, + name="huggingface_hub.http_get", + _tqdm_bar=_tqdm_bar, + ) + + with progress_cm as progress: + if hf_transfer and total is not None and total > 5 * constants.DOWNLOAD_CHUNK_SIZE: + supports_callback = "callback" in inspect.signature(hf_transfer.download).parameters + if not supports_callback: + warnings.warn( + "You are using an outdated version of `hf_transfer`. " + "Consider upgrading to latest version to enable progress bars " + "using `pip install -U hf_transfer`." + ) + try: + hf_transfer.download( + url=url, + filename=temp_file.name, + max_files=constants.HF_TRANSFER_CONCURRENCY, + chunk_size=constants.DOWNLOAD_CHUNK_SIZE, + headers=initial_headers, + parallel_failures=3, + max_retries=5, + **({"callback": progress.update} if supports_callback else {}), + ) + except Exception as e: + raise RuntimeError( + "An error occurred while downloading using `hf_transfer`. Consider" + " disabling HF_HUB_ENABLE_HF_TRANSFER for better error handling." + ) from e + if not supports_callback: + progress.update(total) + if expected_size is not None and expected_size != os.path.getsize(temp_file.name): + raise EnvironmentError( + consistency_error_message.format( + actual_size=os.path.getsize(temp_file.name), + ) + ) + return + new_resume_size = resume_size + try: + for chunk in r.iter_content(chunk_size=constants.DOWNLOAD_CHUNK_SIZE): + if chunk: # filter out keep-alive new chunks + progress.update(len(chunk)) + temp_file.write(chunk) + new_resume_size += len(chunk) + # Some data has been downloaded from the server so we reset the number of retries. + _nb_retries = 5 + except (requests.ConnectionError, requests.ReadTimeout) as e: + # If ConnectionError (SSLError) or ReadTimeout happen while streaming data from the server, it is most likely + # a transient error (network outage?). We log a warning message and try to resume the download a few times + # before giving up. Tre retry mechanism is basic but should be enough in most cases. + if _nb_retries <= 0: + logger.warning("Error while downloading from %s: %s\nMax retries exceeded.", url, str(e)) + raise + logger.warning("Error while downloading from %s: %s\nTrying to resume download...", url, str(e)) + time.sleep(1) + reset_sessions() # In case of SSLError it's best to reset the shared requests.Session objects + return http_get( + url=url, + temp_file=temp_file, + proxies=proxies, + resume_size=new_resume_size, + headers=initial_headers, + expected_size=expected_size, + _nb_retries=_nb_retries - 1, + _tqdm_bar=_tqdm_bar, + ) + + if expected_size is not None and expected_size != temp_file.tell(): + raise EnvironmentError( + consistency_error_message.format( + actual_size=temp_file.tell(), + ) + ) + + +def xet_get( + *, + incomplete_path: Path, + xet_file_data: XetFileData, + headers: Dict[str, str], + expected_size: Optional[int] = None, + displayed_filename: Optional[str] = None, + _tqdm_bar: Optional[tqdm] = None, +) -> None: + """ + Download a file using Xet storage service. + + Args: + incomplete_path (`Path`): + The path to the file to download. + xet_file_data (`XetFileData`): + The file metadata needed to make the request to the xet storage service. + headers (`Dict[str, str]`): + The headers to send to the xet storage service. + expected_size (`int`, *optional*): + The expected size of the file to download. If set, the download will raise an error if the size of the + received content is different from the expected one. + displayed_filename (`str`, *optional*): + The filename of the file that is being downloaded. Value is used only to display a nice progress bar. If + not set, the filename is guessed from the URL or the `Content-Disposition` header. + + **How it works:** + The file download system uses Xet storage, which is a content-addressable storage system that breaks files into chunks + for efficient storage and transfer. + + `hf_xet.download_files` manages downloading files by: + - Taking a list of files to download (each with its unique content hash) + - Connecting to a storage server (CAS server) that knows how files are chunked + - Using authentication to ensure secure access + - Providing progress updates during download + + Authentication works by regularly refreshing access tokens through `refresh_xet_connection_info` to maintain a valid + connection to the storage server. + + The download process works like this: + 1. Create a local cache folder at `~/.cache/huggingface/xet/chunk-cache` to store reusable file chunks + 2. Download files in parallel: + 2.1. Prepare to write the file to disk + 2.2. Ask the server "how is this file split into chunks?" using the file's unique hash + The server responds with: + - Which chunks make up the complete file + - Where each chunk can be downloaded from + 2.3. For each needed chunk: + - Checks if we already have it in our local cache + - If not, download it from cloud storage (S3) + - Save it to cache for future use + - Assemble the chunks in order to recreate the original file + + """ + try: + from hf_xet import PyXetDownloadInfo, download_files # type: ignore[no-redef] + except ImportError: + raise ValueError( + "To use optimized download using Xet storage, you need to install the hf_xet package. " + 'Try `pip install "huggingface_hub[hf_xet]"` or `pip install hf_xet`.' + ) + + connection_info = refresh_xet_connection_info(file_data=xet_file_data, headers=headers) + + def token_refresher() -> Tuple[str, int]: + connection_info = refresh_xet_connection_info(file_data=xet_file_data, headers=headers) + if connection_info is None: + raise ValueError("Failed to refresh token using xet metadata.") + return connection_info.access_token, connection_info.expiration_unix_epoch + + xet_download_info = [ + PyXetDownloadInfo( + destination_path=str(incomplete_path.absolute()), hash=xet_file_data.file_hash, file_size=expected_size + ) + ] + + if not displayed_filename: + displayed_filename = incomplete_path.name + + # Truncate filename if too long to display + if len(displayed_filename) > 40: + displayed_filename = f"{displayed_filename[:40]}(…)" + + progress_cm = _get_progress_bar_context( + desc=displayed_filename, + log_level=logger.getEffectiveLevel(), + total=expected_size, + initial=0, + name="huggingface_hub.xet_get", + _tqdm_bar=_tqdm_bar, + ) + + with progress_cm as progress: + + def progress_updater(progress_bytes: float): + progress.update(progress_bytes) + + download_files( + xet_download_info, + endpoint=connection_info.endpoint, + token_info=(connection_info.access_token, connection_info.expiration_unix_epoch), + token_refresher=token_refresher, + progress_updater=[progress_updater], + ) + + +def _normalize_etag(etag: Optional[str]) -> Optional[str]: + """Normalize ETag HTTP header, so it can be used to create nice filepaths. + + The HTTP spec allows two forms of ETag: + ETag: W/"" + ETag: "" + + For now, we only expect the second form from the server, but we want to be future-proof so we support both. For + more context, see `TestNormalizeEtag` tests and https://github.com/huggingface/huggingface_hub/pull/1428. + + Args: + etag (`str`, *optional*): HTTP header + + Returns: + `str` or `None`: string that can be used as a nice directory name. + Returns `None` if input is None. + """ + if etag is None: + return None + return etag.lstrip("W/").strip('"') + + +def _create_relative_symlink(src: str, dst: str, new_blob: bool = False) -> None: + """Alias method used in `transformers` conversion script.""" + return _create_symlink(src=src, dst=dst, new_blob=new_blob) + + +def _create_symlink(src: str, dst: str, new_blob: bool = False) -> None: + """Create a symbolic link named dst pointing to src. + + By default, it will try to create a symlink using a relative path. Relative paths have 2 advantages: + - If the cache_folder is moved (example: back-up on a shared drive), relative paths within the cache folder will + not break. + - Relative paths seems to be better handled on Windows. Issue was reported 3 times in less than a week when + changing from relative to absolute paths. See https://github.com/huggingface/huggingface_hub/issues/1398, + https://github.com/huggingface/diffusers/issues/2729 and https://github.com/huggingface/transformers/pull/22228. + NOTE: The issue with absolute paths doesn't happen on admin mode. + When creating a symlink from the cache to a local folder, it is possible that a relative path cannot be created. + This happens when paths are not on the same volume. In that case, we use absolute paths. + + + The result layout looks something like + └── [ 128] snapshots + ├── [ 128] 2439f60ef33a0d46d85da5001d52aeda5b00ce9f + │ ├── [ 52] README.md -> ../../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812 + │ └── [ 76] pytorch_model.bin -> ../../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd + + If symlinks cannot be created on this platform (most likely to be Windows), the workaround is to avoid symlinks by + having the actual file in `dst`. If it is a new file (`new_blob=True`), we move it to `dst`. If it is not a new file + (`new_blob=False`), we don't know if the blob file is already referenced elsewhere. To avoid breaking existing + cache, the file is duplicated on the disk. + + In case symlinks are not supported, a warning message is displayed to the user once when loading `huggingface_hub`. + The warning message can be disabled with the `DISABLE_SYMLINKS_WARNING` environment variable. + """ + try: + os.remove(dst) + except OSError: + pass + + abs_src = os.path.abspath(os.path.expanduser(src)) + abs_dst = os.path.abspath(os.path.expanduser(dst)) + abs_dst_folder = os.path.dirname(abs_dst) + + # Use relative_dst in priority + try: + relative_src = os.path.relpath(abs_src, abs_dst_folder) + except ValueError: + # Raised on Windows if src and dst are not on the same volume. This is the case when creating a symlink to a + # local_dir instead of within the cache directory. + # See https://docs.python.org/3/library/os.path.html#os.path.relpath + relative_src = None + + try: + commonpath = os.path.commonpath([abs_src, abs_dst]) + _support_symlinks = are_symlinks_supported(commonpath) + except ValueError: + # Raised if src and dst are not on the same volume. Symlinks will still work on Linux/Macos. + # See https://docs.python.org/3/library/os.path.html#os.path.commonpath + _support_symlinks = os.name != "nt" + except PermissionError: + # Permission error means src and dst are not in the same volume (e.g. destination path has been provided + # by the user via `local_dir`. Let's test symlink support there) + _support_symlinks = are_symlinks_supported(abs_dst_folder) + except OSError as e: + # OS error (errno=30) means that the commonpath is readonly on Linux/MacOS. + if e.errno == errno.EROFS: + _support_symlinks = are_symlinks_supported(abs_dst_folder) + else: + raise + + # Symlinks are supported => let's create a symlink. + if _support_symlinks: + src_rel_or_abs = relative_src or abs_src + logger.debug(f"Creating pointer from {src_rel_or_abs} to {abs_dst}") + try: + os.symlink(src_rel_or_abs, abs_dst) + return + except FileExistsError: + if os.path.islink(abs_dst) and os.path.realpath(abs_dst) == os.path.realpath(abs_src): + # `abs_dst` already exists and is a symlink to the `abs_src` blob. It is most likely that the file has + # been cached twice concurrently (exactly between `os.remove` and `os.symlink`). Do nothing. + return + else: + # Very unlikely to happen. Means a file `dst` has been created exactly between `os.remove` and + # `os.symlink` and is not a symlink to the `abs_src` blob file. Raise exception. + raise + except PermissionError: + # Permission error means src and dst are not in the same volume (e.g. download to local dir) and symlink + # is supported on both volumes but not between them. Let's just make a hard copy in that case. + pass + + # Symlinks are not supported => let's move or copy the file. + if new_blob: + logger.info(f"Symlink not supported. Moving file from {abs_src} to {abs_dst}") + shutil.move(abs_src, abs_dst, copy_function=_copy_no_matter_what) + else: + logger.info(f"Symlink not supported. Copying file from {abs_src} to {abs_dst}") + shutil.copyfile(abs_src, abs_dst) + + +def _cache_commit_hash_for_specific_revision(storage_folder: str, revision: str, commit_hash: str) -> None: + """Cache reference between a revision (tag, branch or truncated commit hash) and the corresponding commit hash. + + Does nothing if `revision` is already a proper `commit_hash` or reference is already cached. + """ + if revision != commit_hash: + ref_path = Path(storage_folder) / "refs" / revision + ref_path.parent.mkdir(parents=True, exist_ok=True) + if not ref_path.exists() or commit_hash != ref_path.read_text(): + # Update ref only if has been updated. Could cause useless error in case + # repo is already cached and user doesn't have write access to cache folder. + # See https://github.com/huggingface/huggingface_hub/issues/1216. + ref_path.write_text(commit_hash) + + +@validate_hf_hub_args +def repo_folder_name(*, repo_id: str, repo_type: str) -> str: + """Return a serialized version of a hf.co repo name and type, safe for disk storage + as a single non-nested folder. + + Example: models--julien-c--EsperBERTo-small + """ + # remove all `/` occurrences to correctly convert repo to directory name + parts = [f"{repo_type}s", *repo_id.split("/")] + return constants.REPO_ID_SEPARATOR.join(parts) + + +def _check_disk_space(expected_size: int, target_dir: Union[str, Path]) -> None: + """Check disk usage and log a warning if there is not enough disk space to download the file. + + Args: + expected_size (`int`): + The expected size of the file in bytes. + target_dir (`str`): + The directory where the file will be stored after downloading. + """ + + target_dir = Path(target_dir) # format as `Path` + for path in [target_dir] + list(target_dir.parents): # first check target_dir, then each parents one by one + try: + target_dir_free = shutil.disk_usage(path).free + if target_dir_free < expected_size: + warnings.warn( + "Not enough free disk space to download the file. " + f"The expected file size is: {expected_size / 1e6:.2f} MB. " + f"The target location {target_dir} only has {target_dir_free / 1e6:.2f} MB free disk space." + ) + return + except OSError: # raise on anything: file does not exist or space disk cannot be checked + pass + + +@validate_hf_hub_args +def hf_hub_download( + repo_id: str, + filename: str, + *, + subfolder: Optional[str] = None, + repo_type: Optional[str] = None, + revision: Optional[str] = None, + library_name: Optional[str] = None, + library_version: Optional[str] = None, + cache_dir: Union[str, Path, None] = None, + local_dir: Union[str, Path, None] = None, + user_agent: Union[Dict, str, None] = None, + force_download: bool = False, + proxies: Optional[Dict] = None, + etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT, + token: Union[bool, str, None] = None, + local_files_only: bool = False, + headers: Optional[Dict[str, str]] = None, + endpoint: Optional[str] = None, + resume_download: Optional[bool] = None, + force_filename: Optional[str] = None, + local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto", +) -> str: + """Download a given file if it's not already present in the local cache. + + The new cache file layout looks like this: + - The cache directory contains one subfolder per repo_id (namespaced by repo type) + - inside each repo folder: + - refs is a list of the latest known revision => commit_hash pairs + - blobs contains the actual file blobs (identified by their git-sha or sha256, depending on + whether they're LFS files or not) + - snapshots contains one subfolder per commit, each "commit" contains the subset of the files + that have been resolved at that particular commit. Each filename is a symlink to the blob + at that particular commit. + + ``` + [ 96] . + └── [ 160] models--julien-c--EsperBERTo-small + ├── [ 160] blobs + │ ├── [321M] 403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd + │ ├── [ 398] 7cb18dc9bafbfcf74629a4b760af1b160957a83e + │ └── [1.4K] d7edf6bd2a681fb0175f7735299831ee1b22b812 + ├── [ 96] refs + │ └── [ 40] main + └── [ 128] snapshots + ├── [ 128] 2439f60ef33a0d46d85da5001d52aeda5b00ce9f + │ ├── [ 52] README.md -> ../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812 + │ └── [ 76] pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd + └── [ 128] bbc77c8132af1cc5cf678da3f1ddf2de43606d48 + ├── [ 52] README.md -> ../../blobs/7cb18dc9bafbfcf74629a4b760af1b160957a83e + └── [ 76] pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd + ``` + + If `local_dir` is provided, the file structure from the repo will be replicated in this location. When using this + option, the `cache_dir` will not be used and a `.cache/huggingface/` folder will be created at the root of `local_dir` + to store some metadata related to the downloaded files. While this mechanism is not as robust as the main + cache-system, it's optimized for regularly pulling the latest version of a repository. + + Args: + repo_id (`str`): + A user or an organization name and a repo name separated by a `/`. + filename (`str`): + The name of the file in the repo. + subfolder (`str`, *optional*): + An optional value corresponding to a folder inside the model repo. + repo_type (`str`, *optional*): + Set to `"dataset"` or `"space"` if downloading from a dataset or space, + `None` or `"model"` if downloading from a model. Default is `None`. + revision (`str`, *optional*): + An optional Git revision id which can be a branch name, a tag, or a + commit hash. + library_name (`str`, *optional*): + The name of the library to which the object corresponds. + library_version (`str`, *optional*): + The version of the library. + cache_dir (`str`, `Path`, *optional*): + Path to the folder where cached files are stored. + local_dir (`str` or `Path`, *optional*): + If provided, the downloaded file will be placed under this directory. + user_agent (`dict`, `str`, *optional*): + The user-agent info in the form of a dictionary or a string. + force_download (`bool`, *optional*, defaults to `False`): + Whether the file should be downloaded even if it already exists in + the local cache. + proxies (`dict`, *optional*): + Dictionary mapping protocol to the URL of the proxy passed to + `requests.request`. + etag_timeout (`float`, *optional*, defaults to `10`): + When fetching ETag, how many seconds to wait for the server to send + data before giving up which is passed to `requests.request`. + token (`str`, `bool`, *optional*): + A token to be used for the download. + - If `True`, the token is read from the HuggingFace config + folder. + - If a string, it's used as the authentication token. + local_files_only (`bool`, *optional*, defaults to `False`): + If `True`, avoid downloading the file and return the path to the + local cached file if it exists. + headers (`dict`, *optional*): + Additional headers to be sent with the request. + + Returns: + `str`: Local path of file or if networking is off, last version of file cached on disk. + + Raises: + [`~utils.RepositoryNotFoundError`] + If the repository to download from cannot be found. This may be because it doesn't exist, + or because it is set to `private` and you do not have access. + [`~utils.RevisionNotFoundError`] + If the revision to download from cannot be found. + [`~utils.EntryNotFoundError`] + If the file to download cannot be found. + [`~utils.LocalEntryNotFoundError`] + If network is disabled or unavailable and file is not found in cache. + [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError) + If `token=True` but the token cannot be found. + [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError) + If ETag cannot be determined. + [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) + If some parameter value is invalid. + + """ + if constants.HF_HUB_ETAG_TIMEOUT != constants.DEFAULT_ETAG_TIMEOUT: + # Respect environment variable above user value + etag_timeout = constants.HF_HUB_ETAG_TIMEOUT + + if force_filename is not None: + warnings.warn( + "The `force_filename` parameter is deprecated as a new caching system, " + "which keeps the filenames as they are on the Hub, is now in place.", + FutureWarning, + ) + if resume_download is not None: + warnings.warn( + "`resume_download` is deprecated and will be removed in version 1.0.0. " + "Downloads always resume when possible. " + "If you want to force a new download, use `force_download=True`.", + FutureWarning, + ) + + if cache_dir is None: + cache_dir = constants.HF_HUB_CACHE + if revision is None: + revision = constants.DEFAULT_REVISION + if isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + if isinstance(local_dir, Path): + local_dir = str(local_dir) + + if subfolder == "": + subfolder = None + if subfolder is not None: + # This is used to create a URL, and not a local path, hence the forward slash. + filename = f"{subfolder}/{filename}" + + if repo_type is None: + repo_type = "model" + if repo_type not in constants.REPO_TYPES: + raise ValueError(f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES)}") + + hf_headers = build_hf_headers( + token=token, + library_name=library_name, + library_version=library_version, + user_agent=user_agent, + headers=headers, + ) + + if local_dir is not None: + if local_dir_use_symlinks != "auto": + warnings.warn( + "`local_dir_use_symlinks` parameter is deprecated and will be ignored. " + "The process to download files to a local folder has been updated and do " + "not rely on symlinks anymore. You only need to pass a destination folder " + "as`local_dir`.\n" + "For more details, check out https://huggingface.co/docs/huggingface_hub/main/en/guides/download#download-files-to-local-folder." + ) + + return _hf_hub_download_to_local_dir( + # Destination + local_dir=local_dir, + # File info + repo_id=repo_id, + repo_type=repo_type, + filename=filename, + revision=revision, + # HTTP info + endpoint=endpoint, + etag_timeout=etag_timeout, + headers=hf_headers, + proxies=proxies, + token=token, + # Additional options + cache_dir=cache_dir, + force_download=force_download, + local_files_only=local_files_only, + ) + else: + return _hf_hub_download_to_cache_dir( + # Destination + cache_dir=cache_dir, + # File info + repo_id=repo_id, + filename=filename, + repo_type=repo_type, + revision=revision, + # HTTP info + endpoint=endpoint, + etag_timeout=etag_timeout, + headers=hf_headers, + proxies=proxies, + token=token, + # Additional options + local_files_only=local_files_only, + force_download=force_download, + ) + + +def _hf_hub_download_to_cache_dir( + *, + # Destination + cache_dir: str, + # File info + repo_id: str, + filename: str, + repo_type: str, + revision: str, + # HTTP info + endpoint: Optional[str], + etag_timeout: float, + headers: Dict[str, str], + proxies: Optional[Dict], + token: Optional[Union[bool, str]], + # Additional options + local_files_only: bool, + force_download: bool, +) -> str: + """Download a given file to a cache folder, if not already present. + + Method should not be called directly. Please use `hf_hub_download` instead. + """ + locks_dir = os.path.join(cache_dir, ".locks") + storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type)) + + # cross platform transcription of filename, to be used as a local file path. + relative_filename = os.path.join(*filename.split("/")) + if os.name == "nt": + if relative_filename.startswith("..\\") or "\\..\\" in relative_filename: + raise ValueError( + f"Invalid filename: cannot handle filename '{relative_filename}' on Windows. Please ask the repository" + " owner to rename this file." + ) + + # if user provides a commit_hash and they already have the file on disk, shortcut everything. + if REGEX_COMMIT_HASH.match(revision): + pointer_path = _get_pointer_path(storage_folder, revision, relative_filename) + if os.path.exists(pointer_path) and not force_download: + return pointer_path + + # Try to get metadata (etag, commit_hash, url, size) from the server. + # If we can't, a HEAD request error is returned. + (url_to_download, etag, commit_hash, expected_size, xet_file_data, head_call_error) = _get_metadata_or_catch_error( + repo_id=repo_id, + filename=filename, + repo_type=repo_type, + revision=revision, + endpoint=endpoint, + proxies=proxies, + etag_timeout=etag_timeout, + headers=headers, + token=token, + local_files_only=local_files_only, + storage_folder=storage_folder, + relative_filename=relative_filename, + ) + + # etag can be None for several reasons: + # 1. we passed local_files_only. + # 2. we don't have a connection + # 3. Hub is down (HTTP 500, 503, 504) + # 4. repo is not found -for example private or gated- and invalid/missing token sent + # 5. Hub is blocked by a firewall or proxy is not set correctly. + # => Try to get the last downloaded one from the specified revision. + # + # If the specified revision is a commit hash, look inside "snapshots". + # If the specified revision is a branch or tag, look inside "refs". + if head_call_error is not None: + # Couldn't make a HEAD call => let's try to find a local file + if not force_download: + commit_hash = None + if REGEX_COMMIT_HASH.match(revision): + commit_hash = revision + else: + ref_path = os.path.join(storage_folder, "refs", revision) + if os.path.isfile(ref_path): + with open(ref_path) as f: + commit_hash = f.read() + + # Return pointer file if exists + if commit_hash is not None: + pointer_path = _get_pointer_path(storage_folder, commit_hash, relative_filename) + if os.path.exists(pointer_path) and not force_download: + return pointer_path + + # Otherwise, raise appropriate error + _raise_on_head_call_error(head_call_error, force_download, local_files_only) + + # From now on, etag, commit_hash, url and size are not None. + assert etag is not None, "etag must have been retrieved from server" + assert commit_hash is not None, "commit_hash must have been retrieved from server" + assert url_to_download is not None, "file location must have been retrieved from server" + assert expected_size is not None, "expected_size must have been retrieved from server" + blob_path = os.path.join(storage_folder, "blobs", etag) + pointer_path = _get_pointer_path(storage_folder, commit_hash, relative_filename) + + os.makedirs(os.path.dirname(blob_path), exist_ok=True) + os.makedirs(os.path.dirname(pointer_path), exist_ok=True) + + # if passed revision is not identical to commit_hash + # then revision has to be a branch name or tag name. + # In that case store a ref. + _cache_commit_hash_for_specific_revision(storage_folder, revision, commit_hash) + + # Prevent parallel downloads of the same file with a lock. + # etag could be duplicated across repos, + lock_path = os.path.join(locks_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type), f"{etag}.lock") + + # Some Windows versions do not allow for paths longer than 255 characters. + # In this case, we must specify it as an extended path by using the "\\?\" prefix. + if os.name == "nt" and len(os.path.abspath(lock_path)) > 255: + lock_path = "\\\\?\\" + os.path.abspath(lock_path) + + if os.name == "nt" and len(os.path.abspath(blob_path)) > 255: + blob_path = "\\\\?\\" + os.path.abspath(blob_path) + + Path(lock_path).parent.mkdir(parents=True, exist_ok=True) + + # pointer already exists -> immediate return + if not force_download and os.path.exists(pointer_path): + return pointer_path + + # Blob exists but pointer must be (safely) created -> take the lock + if not force_download and os.path.exists(blob_path): + with WeakFileLock(lock_path): + if not os.path.exists(pointer_path): + _create_symlink(blob_path, pointer_path, new_blob=False) + return pointer_path + + # Local file doesn't exist or etag isn't a match => retrieve file from remote (or cache) + + with WeakFileLock(lock_path): + _download_to_tmp_and_move( + incomplete_path=Path(blob_path + ".incomplete"), + destination_path=Path(blob_path), + url_to_download=url_to_download, + proxies=proxies, + headers=headers, + expected_size=expected_size, + filename=filename, + force_download=force_download, + etag=etag, + xet_file_data=xet_file_data, + ) + if not os.path.exists(pointer_path): + _create_symlink(blob_path, pointer_path, new_blob=True) + + return pointer_path + + +def _hf_hub_download_to_local_dir( + *, + # Destination + local_dir: Union[str, Path], + # File info + repo_id: str, + repo_type: str, + filename: str, + revision: str, + # HTTP info + endpoint: Optional[str], + etag_timeout: float, + headers: Dict[str, str], + proxies: Optional[Dict], + token: Union[bool, str, None], + # Additional options + cache_dir: str, + force_download: bool, + local_files_only: bool, +) -> str: + """Download a given file to a local folder, if not already present. + + Method should not be called directly. Please use `hf_hub_download` instead. + """ + # Some Windows versions do not allow for paths longer than 255 characters. + # In this case, we must specify it as an extended path by using the "\\?\" prefix. + if os.name == "nt" and len(os.path.abspath(local_dir)) > 255: + local_dir = "\\\\?\\" + os.path.abspath(local_dir) + local_dir = Path(local_dir) + paths = get_local_download_paths(local_dir=local_dir, filename=filename) + local_metadata = read_download_metadata(local_dir=local_dir, filename=filename) + + # Local file exists + metadata exists + commit_hash matches => return file + if ( + not force_download + and REGEX_COMMIT_HASH.match(revision) + and paths.file_path.is_file() + and local_metadata is not None + and local_metadata.commit_hash == revision + ): + return str(paths.file_path) + + # Local file doesn't exist or commit_hash doesn't match => we need the etag + (url_to_download, etag, commit_hash, expected_size, xet_file_data, head_call_error) = _get_metadata_or_catch_error( + repo_id=repo_id, + filename=filename, + repo_type=repo_type, + revision=revision, + endpoint=endpoint, + proxies=proxies, + etag_timeout=etag_timeout, + headers=headers, + token=token, + local_files_only=local_files_only, + ) + + if head_call_error is not None: + # No HEAD call but local file exists => default to local file + if not force_download and paths.file_path.is_file(): + logger.warning( + f"Couldn't access the Hub to check for update but local file already exists. Defaulting to existing file. (error: {head_call_error})" + ) + return str(paths.file_path) + # Otherwise => raise + _raise_on_head_call_error(head_call_error, force_download, local_files_only) + + # From now on, etag, commit_hash, url and size are not None. + assert etag is not None, "etag must have been retrieved from server" + assert commit_hash is not None, "commit_hash must have been retrieved from server" + assert url_to_download is not None, "file location must have been retrieved from server" + assert expected_size is not None, "expected_size must have been retrieved from server" + + # Local file exists => check if it's up-to-date + if not force_download and paths.file_path.is_file(): + # etag matches => update metadata and return file + if local_metadata is not None and local_metadata.etag == etag: + write_download_metadata(local_dir=local_dir, filename=filename, commit_hash=commit_hash, etag=etag) + return str(paths.file_path) + + # metadata is outdated + etag is a sha256 + # => means it's an LFS file (large) + # => let's compute local hash and compare + # => if match, update metadata and return file + if local_metadata is None and REGEX_SHA256.match(etag) is not None: + with open(paths.file_path, "rb") as f: + file_hash = sha_fileobj(f).hex() + if file_hash == etag: + write_download_metadata(local_dir=local_dir, filename=filename, commit_hash=commit_hash, etag=etag) + return str(paths.file_path) + + # Local file doesn't exist or etag isn't a match => retrieve file from remote (or cache) + + # If we are lucky enough, the file is already in the cache => copy it + if not force_download: + cached_path = try_to_load_from_cache( + repo_id=repo_id, + filename=filename, + cache_dir=cache_dir, + revision=commit_hash, + repo_type=repo_type, + ) + if isinstance(cached_path, str): + with WeakFileLock(paths.lock_path): + paths.file_path.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(cached_path, paths.file_path) + write_download_metadata(local_dir=local_dir, filename=filename, commit_hash=commit_hash, etag=etag) + return str(paths.file_path) + + # Otherwise, let's download the file! + with WeakFileLock(paths.lock_path): + paths.file_path.unlink(missing_ok=True) # delete outdated file first + _download_to_tmp_and_move( + incomplete_path=paths.incomplete_path(etag), + destination_path=paths.file_path, + url_to_download=url_to_download, + proxies=proxies, + headers=headers, + expected_size=expected_size, + filename=filename, + force_download=force_download, + etag=etag, + xet_file_data=xet_file_data, + ) + + write_download_metadata(local_dir=local_dir, filename=filename, commit_hash=commit_hash, etag=etag) + return str(paths.file_path) + + +@validate_hf_hub_args +def try_to_load_from_cache( + repo_id: str, + filename: str, + cache_dir: Union[str, Path, None] = None, + revision: Optional[str] = None, + repo_type: Optional[str] = None, +) -> Union[str, _CACHED_NO_EXIST_T, None]: + """ + Explores the cache to return the latest cached file for a given revision if found. + + This function will not raise any exception if the file in not cached. + + Args: + cache_dir (`str` or `os.PathLike`): + The folder where the cached files lie. + repo_id (`str`): + The ID of the repo on huggingface.co. + filename (`str`): + The filename to look for inside `repo_id`. + revision (`str`, *optional*): + The specific model version to use. Will default to `"main"` if it's not provided and no `commit_hash` is + provided either. + repo_type (`str`, *optional*): + The type of the repository. Will default to `"model"`. + + Returns: + `Optional[str]` or `_CACHED_NO_EXIST`: + Will return `None` if the file was not cached. Otherwise: + - The exact path to the cached file if it's found in the cache + - A special value `_CACHED_NO_EXIST` if the file does not exist at the given commit hash and this fact was + cached. + + Example: + + ```python + from huggingface_hub import try_to_load_from_cache, _CACHED_NO_EXIST + + filepath = try_to_load_from_cache() + if isinstance(filepath, str): + # file exists and is cached + ... + elif filepath is _CACHED_NO_EXIST: + # non-existence of file is cached + ... + else: + # file is not cached + ... + ``` + """ + if revision is None: + revision = "main" + if repo_type is None: + repo_type = "model" + if repo_type not in constants.REPO_TYPES: + raise ValueError(f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES)}") + if cache_dir is None: + cache_dir = constants.HF_HUB_CACHE + + object_id = repo_id.replace("/", "--") + repo_cache = os.path.join(cache_dir, f"{repo_type}s--{object_id}") + if not os.path.isdir(repo_cache): + # No cache for this model + return None + + refs_dir = os.path.join(repo_cache, "refs") + snapshots_dir = os.path.join(repo_cache, "snapshots") + no_exist_dir = os.path.join(repo_cache, ".no_exist") + + # Resolve refs (for instance to convert main to the associated commit sha) + if os.path.isdir(refs_dir): + revision_file = os.path.join(refs_dir, revision) + if os.path.isfile(revision_file): + with open(revision_file) as f: + revision = f.read() + + # Check if file is cached as "no_exist" + if os.path.isfile(os.path.join(no_exist_dir, revision, filename)): + return _CACHED_NO_EXIST + + # Check if revision folder exists + if not os.path.exists(snapshots_dir): + return None + cached_shas = os.listdir(snapshots_dir) + if revision not in cached_shas: + # No cache for this revision and we won't try to return a random revision + return None + + # Check if file exists in cache + cached_file = os.path.join(snapshots_dir, revision, filename) + return cached_file if os.path.isfile(cached_file) else None + + +@validate_hf_hub_args +def get_hf_file_metadata( + url: str, + token: Union[bool, str, None] = None, + proxies: Optional[Dict] = None, + timeout: Optional[float] = constants.DEFAULT_REQUEST_TIMEOUT, + library_name: Optional[str] = None, + library_version: Optional[str] = None, + user_agent: Union[Dict, str, None] = None, + headers: Optional[Dict[str, str]] = None, +) -> HfFileMetadata: + """Fetch metadata of a file versioned on the Hub for a given url. + + Args: + url (`str`): + File url, for example returned by [`hf_hub_url`]. + token (`str` or `bool`, *optional*): + A token to be used for the download. + - If `True`, the token is read from the HuggingFace config + folder. + - If `False` or `None`, no token is provided. + - If a string, it's used as the authentication token. + proxies (`dict`, *optional*): + Dictionary mapping protocol to the URL of the proxy passed to + `requests.request`. + timeout (`float`, *optional*, defaults to 10): + How many seconds to wait for the server to send metadata before giving up. + library_name (`str`, *optional*): + The name of the library to which the object corresponds. + library_version (`str`, *optional*): + The version of the library. + user_agent (`dict`, `str`, *optional*): + The user-agent info in the form of a dictionary or a string. + headers (`dict`, *optional*): + Additional headers to be sent with the request. + + Returns: + A [`HfFileMetadata`] object containing metadata such as location, etag, size and + commit_hash. + """ + hf_headers = build_hf_headers( + token=token, + library_name=library_name, + library_version=library_version, + user_agent=user_agent, + headers=headers, + ) + hf_headers["Accept-Encoding"] = "identity" # prevent any compression => we want to know the real size of the file + + # Retrieve metadata + r = _request_wrapper( + method="HEAD", + url=url, + headers=hf_headers, + allow_redirects=False, + follow_relative_redirects=True, + proxies=proxies, + timeout=timeout, + ) + hf_raise_for_status(r) + + # Return + return HfFileMetadata( + commit_hash=r.headers.get(constants.HUGGINGFACE_HEADER_X_REPO_COMMIT), + # We favor a custom header indicating the etag of the linked resource, and + # we fallback to the regular etag header. + etag=_normalize_etag(r.headers.get(constants.HUGGINGFACE_HEADER_X_LINKED_ETAG) or r.headers.get("ETag")), + # Either from response headers (if redirected) or defaults to request url + # Do not use directly `url`, as `_request_wrapper` might have followed relative + # redirects. + location=r.headers.get("Location") or r.request.url, # type: ignore + size=_int_or_none( + r.headers.get(constants.HUGGINGFACE_HEADER_X_LINKED_SIZE) or r.headers.get("Content-Length") + ), + xet_file_data=parse_xet_file_data_from_response(r), # type: ignore + ) + + +def _get_metadata_or_catch_error( + *, + repo_id: str, + filename: str, + repo_type: str, + revision: str, + endpoint: Optional[str], + proxies: Optional[Dict], + etag_timeout: Optional[float], + headers: Dict[str, str], # mutated inplace! + token: Union[bool, str, None], + local_files_only: bool, + relative_filename: Optional[str] = None, # only used to store `.no_exists` in cache + storage_folder: Optional[str] = None, # only used to store `.no_exists` in cache +) -> Union[ + # Either an exception is caught and returned + Tuple[None, None, None, None, None, Exception], + # Or the metadata is returned as + # `(url_to_download, etag, commit_hash, expected_size, xet_file_data, None)` + Tuple[str, str, str, int, Optional[XetFileData], None], +]: + """Get metadata for a file on the Hub, safely handling network issues. + + Returns either the etag, commit_hash and expected size of the file, or the error + raised while fetching the metadata. + + NOTE: This function mutates `headers` inplace! It removes the `authorization` header + if the file is a LFS blob and the domain of the url is different from the + domain of the location (typically an S3 bucket). + """ + if local_files_only: + return ( + None, + None, + None, + None, + None, + OfflineModeIsEnabled( + f"Cannot access file since 'local_files_only=True' as been set. (repo_id: {repo_id}, repo_type: {repo_type}, revision: {revision}, filename: {filename})" + ), + ) + + url = hf_hub_url(repo_id, filename, repo_type=repo_type, revision=revision, endpoint=endpoint) + url_to_download: str = url + etag: Optional[str] = None + commit_hash: Optional[str] = None + expected_size: Optional[int] = None + head_error_call: Optional[Exception] = None + xet_file_data: Optional[XetFileData] = None + + # Try to get metadata from the server. + # Do not raise yet if the file is not found or not accessible. + if not local_files_only: + try: + try: + metadata = get_hf_file_metadata( + url=url, proxies=proxies, timeout=etag_timeout, headers=headers, token=token + ) + except EntryNotFoundError as http_error: + if storage_folder is not None and relative_filename is not None: + # Cache the non-existence of the file + commit_hash = http_error.response.headers.get(constants.HUGGINGFACE_HEADER_X_REPO_COMMIT) + if commit_hash is not None: + no_exist_file_path = Path(storage_folder) / ".no_exist" / commit_hash / relative_filename + try: + no_exist_file_path.parent.mkdir(parents=True, exist_ok=True) + no_exist_file_path.touch() + except OSError as e: + logger.error( + f"Could not cache non-existence of file. Will ignore error and continue. Error: {e}" + ) + _cache_commit_hash_for_specific_revision(storage_folder, revision, commit_hash) + raise + + # Commit hash must exist + commit_hash = metadata.commit_hash + if commit_hash is None: + raise FileMetadataError( + "Distant resource does not seem to be on huggingface.co. It is possible that a configuration issue" + " prevents you from downloading resources from https://huggingface.co. Please check your firewall" + " and proxy settings and make sure your SSL certificates are updated." + ) + + # Etag must exist + # If we don't have any of those, raise an error. + etag = metadata.etag + if etag is None: + raise FileMetadataError( + "Distant resource does not have an ETag, we won't be able to reliably ensure reproducibility." + ) + + # Size must exist + expected_size = metadata.size + if expected_size is None: + raise FileMetadataError("Distant resource does not have a Content-Length.") + + xet_file_data = metadata.xet_file_data + + # In case of a redirect, save an extra redirect on the request.get call, + # and ensure we download the exact atomic version even if it changed + # between the HEAD and the GET (unlikely, but hey). + # + # If url domain is different => we are downloading from a CDN => url is signed => don't send auth + # If url domain is the same => redirect due to repo rename AND downloading a regular file => keep auth + if xet_file_data is None and url != metadata.location: + url_to_download = metadata.location + if urlparse(url).netloc != urlparse(metadata.location).netloc: + # Remove authorization header when downloading a LFS blob + headers.pop("authorization", None) + except (requests.exceptions.SSLError, requests.exceptions.ProxyError): + # Actually raise for those subclasses of ConnectionError + raise + except ( + requests.exceptions.ConnectionError, + requests.exceptions.Timeout, + OfflineModeIsEnabled, + ) as error: + # Otherwise, our Internet connection is down. + # etag is None + head_error_call = error + except (RevisionNotFoundError, EntryNotFoundError): + # The repo was found but the revision or entry doesn't exist on the Hub (never existed or got deleted) + raise + except requests.HTTPError as error: + # Multiple reasons for an http error: + # - Repository is private and invalid/missing token sent + # - Repository is gated and invalid/missing token sent + # - Hub is down (error 500 or 504) + # => let's switch to 'local_files_only=True' to check if the files are already cached. + # (if it's not the case, the error will be re-raised) + head_error_call = error + except FileMetadataError as error: + # Multiple reasons for a FileMetadataError: + # - Wrong network configuration (proxy, firewall, SSL certificates) + # - Inconsistency on the Hub + # => let's switch to 'local_files_only=True' to check if the files are already cached. + # (if it's not the case, the error will be re-raised) + head_error_call = error + + if not (local_files_only or etag is not None or head_error_call is not None): + raise RuntimeError("etag is empty due to uncovered problems") + + return (url_to_download, etag, commit_hash, expected_size, xet_file_data, head_error_call) # type: ignore [return-value] + + +def _raise_on_head_call_error(head_call_error: Exception, force_download: bool, local_files_only: bool) -> NoReturn: + """Raise an appropriate error when the HEAD call failed and we cannot locate a local file.""" + # No head call => we cannot force download. + if force_download: + if local_files_only: + raise ValueError("Cannot pass 'force_download=True' and 'local_files_only=True' at the same time.") + elif isinstance(head_call_error, OfflineModeIsEnabled): + raise ValueError("Cannot pass 'force_download=True' when offline mode is enabled.") from head_call_error + else: + raise ValueError("Force download failed due to the above error.") from head_call_error + + # No head call + couldn't find an appropriate file on disk => raise an error. + if local_files_only: + raise LocalEntryNotFoundError( + "Cannot find the requested files in the disk cache and outgoing traffic has been disabled. To enable" + " hf.co look-ups and downloads online, set 'local_files_only' to False." + ) + elif isinstance(head_call_error, (RepositoryNotFoundError, GatedRepoError)) or ( + isinstance(head_call_error, HfHubHTTPError) and head_call_error.response.status_code == 401 + ): + # Repo not found or gated => let's raise the actual error + # Unauthorized => likely a token issue => let's raise the actual error + raise head_call_error + else: + # Otherwise: most likely a connection issue or Hub downtime => let's warn the user + raise LocalEntryNotFoundError( + "An error happened while trying to locate the file on the Hub and we cannot find the requested files" + " in the local cache. Please check your connection and try again or make sure your Internet connection" + " is on." + ) from head_call_error + + +def _download_to_tmp_and_move( + incomplete_path: Path, + destination_path: Path, + url_to_download: str, + proxies: Optional[Dict], + headers: Dict[str, str], + expected_size: Optional[int], + filename: str, + force_download: bool, + etag: Optional[str], + xet_file_data: Optional[XetFileData], +) -> None: + """Download content from a URL to a destination path. + + Internal logic: + - return early if file is already downloaded + - resume download if possible (from incomplete file) + - do not resume download if `force_download=True` or `HF_HUB_ENABLE_HF_TRANSFER=True` + - check disk space before downloading + - download content to a temporary file + - set correct permissions on temporary file + - move the temporary file to the destination path + + Both `incomplete_path` and `destination_path` must be on the same volume to avoid a local copy. + """ + if destination_path.exists() and not force_download: + # Do nothing if already exists (except if force_download=True) + return + + if incomplete_path.exists() and (force_download or (constants.HF_HUB_ENABLE_HF_TRANSFER and not proxies)): + # By default, we will try to resume the download if possible. + # However, if the user has set `force_download=True` or if `hf_transfer` is enabled, then we should + # not resume the download => delete the incomplete file. + message = f"Removing incomplete file '{incomplete_path}'" + if force_download: + message += " (force_download=True)" + elif constants.HF_HUB_ENABLE_HF_TRANSFER and not proxies: + message += " (hf_transfer=True)" + logger.info(message) + incomplete_path.unlink(missing_ok=True) + + with incomplete_path.open("ab") as f: + resume_size = f.tell() + message = f"Downloading '{filename}' to '{incomplete_path}'" + if resume_size > 0 and expected_size is not None: + message += f" (resume from {resume_size}/{expected_size})" + logger.info(message) + + if expected_size is not None: # might be None if HTTP header not set correctly + # Check disk space in both tmp and destination path + _check_disk_space(expected_size, incomplete_path.parent) + _check_disk_space(expected_size, destination_path.parent) + + if xet_file_data is not None and is_xet_available(): + logger.debug("Xet Storage is enabled for this repo. Downloading file from Xet Storage..") + xet_get( + incomplete_path=incomplete_path, + xet_file_data=xet_file_data, + headers=headers, + expected_size=expected_size, + displayed_filename=filename, + ) + else: + if xet_file_data is not None: + logger.warning( + "Xet Storage is enabled for this repo, but the 'hf_xet' package is not installed. " + "Falling back to regular HTTP download. " + "For better performance, install the package with: `pip install huggingface_hub[hf_xet]` or `pip install hf_xet`" + ) + + http_get( + url_to_download, + f, + proxies=proxies, + resume_size=resume_size, + headers=headers, + expected_size=expected_size, + ) + + logger.info(f"Download complete. Moving file to {destination_path}") + _chmod_and_move(incomplete_path, destination_path) + + +def _int_or_none(value: Optional[str]) -> Optional[int]: + try: + return int(value) # type: ignore + except (TypeError, ValueError): + return None + + +def _chmod_and_move(src: Path, dst: Path) -> None: + """Set correct permission before moving a blob from tmp directory to cache dir. + + Do not take into account the `umask` from the process as there is no convenient way + to get it that is thread-safe. + + See: + - About umask: https://docs.python.org/3/library/os.html#os.umask + - Thread-safety: https://stackoverflow.com/a/70343066 + - About solution: https://github.com/huggingface/huggingface_hub/pull/1220#issuecomment-1326211591 + - Fix issue: https://github.com/huggingface/huggingface_hub/issues/1141 + - Fix issue: https://github.com/huggingface/huggingface_hub/issues/1215 + """ + # Get umask by creating a temporary file in the cached repo folder. + tmp_file = dst.parent.parent / f"tmp_{uuid.uuid4()}" + try: + tmp_file.touch() + cache_dir_mode = Path(tmp_file).stat().st_mode + os.chmod(str(src), stat.S_IMODE(cache_dir_mode)) + except OSError as e: + logger.warning( + f"Could not set the permissions on the file '{src}'. Error: {e}.\nContinuing without setting permissions." + ) + finally: + try: + tmp_file.unlink() + except OSError: + # fails if `tmp_file.touch()` failed => do nothing + # See https://github.com/huggingface/huggingface_hub/issues/2359 + pass + + shutil.move(str(src), str(dst), copy_function=_copy_no_matter_what) + + +def _copy_no_matter_what(src: str, dst: str) -> None: + """Copy file from src to dst. + + If `shutil.copy2` fails, fallback to `shutil.copyfile`. + """ + try: + # Copy file with metadata and permission + # Can fail e.g. if dst is an S3 mount + shutil.copy2(src, dst) + except OSError: + # Copy only file content + shutil.copyfile(src, dst) + + +def _get_pointer_path(storage_folder: str, revision: str, relative_filename: str) -> str: + # Using `os.path.abspath` instead of `Path.resolve()` to avoid resolving symlinks + snapshot_path = os.path.join(storage_folder, "snapshots") + pointer_path = os.path.join(snapshot_path, revision, relative_filename) + if Path(os.path.abspath(snapshot_path)) not in Path(os.path.abspath(pointer_path)).parents: + raise ValueError( + "Invalid pointer path: cannot create pointer path in snapshot folder if" + f" `storage_folder='{storage_folder}'`, `revision='{revision}'` and" + f" `relative_filename='{relative_filename}'`." + ) + return pointer_path diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/hub_mixin.py b/.venv/lib/python3.13/site-packages/huggingface_hub/hub_mixin.py new file mode 100644 index 0000000000000000000000000000000000000000..ca1bb1b8884e9ae30a0394d8a35f900f4d08b583 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/hub_mixin.py @@ -0,0 +1,851 @@ +import inspect +import json +import os +from dataclasses import Field, asdict, dataclass, is_dataclass +from pathlib import Path +from typing import Any, Callable, ClassVar, Dict, List, Optional, Protocol, Tuple, Type, TypeVar, Union + +import packaging.version + +from . import constants +from .errors import EntryNotFoundError, HfHubHTTPError +from .file_download import hf_hub_download +from .hf_api import HfApi +from .repocard import ModelCard, ModelCardData +from .utils import ( + SoftTemporaryDirectory, + is_jsonable, + is_safetensors_available, + is_simple_optional_type, + is_torch_available, + logging, + unwrap_simple_optional_type, + validate_hf_hub_args, +) + + +if is_torch_available(): + import torch # type: ignore + +if is_safetensors_available(): + import safetensors + from safetensors.torch import load_model as load_model_as_safetensor + from safetensors.torch import save_model as save_model_as_safetensor + + +logger = logging.get_logger(__name__) + + +# Type alias for dataclass instances, copied from https://github.com/python/typeshed/blob/9f28171658b9ca6c32a7cb93fbb99fc92b17858b/stdlib/_typeshed/__init__.pyi#L349 +class DataclassInstance(Protocol): + __dataclass_fields__: ClassVar[Dict[str, Field]] + + +# Generic variable that is either ModelHubMixin or a subclass thereof +T = TypeVar("T", bound="ModelHubMixin") +# Generic variable to represent an args type +ARGS_T = TypeVar("ARGS_T") +ENCODER_T = Callable[[ARGS_T], Any] +DECODER_T = Callable[[Any], ARGS_T] +CODER_T = Tuple[ENCODER_T, DECODER_T] + + +DEFAULT_MODEL_CARD = """ +--- +# For reference on model card metadata, see the spec: https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1 +# Doc / guide: https://huggingface.co/docs/hub/model-cards +{{ card_data }} +--- + +This model has been pushed to the Hub using the [PytorchModelHubMixin](https://huggingface.co/docs/huggingface_hub/package_reference/mixins#huggingface_hub.PyTorchModelHubMixin) integration: +- Code: {{ repo_url | default("[More Information Needed]", true) }} +- Paper: {{ paper_url | default("[More Information Needed]", true) }} +- Docs: {{ docs_url | default("[More Information Needed]", true) }} +""" + + +@dataclass +class MixinInfo: + model_card_template: str + model_card_data: ModelCardData + docs_url: Optional[str] = None + paper_url: Optional[str] = None + repo_url: Optional[str] = None + + +class ModelHubMixin: + """ + A generic mixin to integrate ANY machine learning framework with the Hub. + + To integrate your framework, your model class must inherit from this class. Custom logic for saving/loading models + have to be overwritten in [`_from_pretrained`] and [`_save_pretrained`]. [`PyTorchModelHubMixin`] is a good example + of mixin integration with the Hub. Check out our [integration guide](../guides/integrations) for more instructions. + + When inheriting from [`ModelHubMixin`], you can define class-level attributes. These attributes are not passed to + `__init__` but to the class definition itself. This is useful to define metadata about the library integrating + [`ModelHubMixin`]. + + For more details on how to integrate the mixin with your library, checkout the [integration guide](../guides/integrations). + + Args: + repo_url (`str`, *optional*): + URL of the library repository. Used to generate model card. + paper_url (`str`, *optional*): + URL of the library paper. Used to generate model card. + docs_url (`str`, *optional*): + URL of the library documentation. Used to generate model card. + model_card_template (`str`, *optional*): + Template of the model card. Used to generate model card. Defaults to a generic template. + language (`str` or `List[str]`, *optional*): + Language supported by the library. Used to generate model card. + library_name (`str`, *optional*): + Name of the library integrating ModelHubMixin. Used to generate model card. + license (`str`, *optional*): + License of the library integrating ModelHubMixin. Used to generate model card. + E.g: "apache-2.0" + license_name (`str`, *optional*): + Name of the library integrating ModelHubMixin. Used to generate model card. + Only used if `license` is set to `other`. + E.g: "coqui-public-model-license". + license_link (`str`, *optional*): + URL to the license of the library integrating ModelHubMixin. Used to generate model card. + Only used if `license` is set to `other` and `license_name` is set. + E.g: "https://coqui.ai/cpml". + pipeline_tag (`str`, *optional*): + Tag of the pipeline. Used to generate model card. E.g. "text-classification". + tags (`List[str]`, *optional*): + Tags to be added to the model card. Used to generate model card. E.g. ["computer-vision"] + coders (`Dict[Type, Tuple[Callable, Callable]]`, *optional*): + Dictionary of custom types and their encoders/decoders. Used to encode/decode arguments that are not + jsonable by default. E.g dataclasses, argparse.Namespace, OmegaConf, etc. + + Example: + + ```python + >>> from huggingface_hub import ModelHubMixin + + # Inherit from ModelHubMixin + >>> class MyCustomModel( + ... ModelHubMixin, + ... library_name="my-library", + ... tags=["computer-vision"], + ... repo_url="https://github.com/huggingface/my-cool-library", + ... paper_url="https://arxiv.org/abs/2304.12244", + ... docs_url="https://huggingface.co/docs/my-cool-library", + ... # ^ optional metadata to generate model card + ... ): + ... def __init__(self, size: int = 512, device: str = "cpu"): + ... # define how to initialize your model + ... super().__init__() + ... ... + ... + ... def _save_pretrained(self, save_directory: Path) -> None: + ... # define how to serialize your model + ... ... + ... + ... @classmethod + ... def from_pretrained( + ... cls: Type[T], + ... pretrained_model_name_or_path: Union[str, Path], + ... *, + ... force_download: bool = False, + ... resume_download: Optional[bool] = None, + ... proxies: Optional[Dict] = None, + ... token: Optional[Union[str, bool]] = None, + ... cache_dir: Optional[Union[str, Path]] = None, + ... local_files_only: bool = False, + ... revision: Optional[str] = None, + ... **model_kwargs, + ... ) -> T: + ... # define how to deserialize your model + ... ... + + >>> model = MyCustomModel(size=256, device="gpu") + + # Save model weights to local directory + >>> model.save_pretrained("my-awesome-model") + + # Push model weights to the Hub + >>> model.push_to_hub("my-awesome-model") + + # Download and initialize weights from the Hub + >>> reloaded_model = MyCustomModel.from_pretrained("username/my-awesome-model") + >>> reloaded_model.size + 256 + + # Model card has been correctly populated + >>> from huggingface_hub import ModelCard + >>> card = ModelCard.load("username/my-awesome-model") + >>> card.data.tags + ["x-custom-tag", "pytorch_model_hub_mixin", "model_hub_mixin"] + >>> card.data.library_name + "my-library" + ``` + """ + + _hub_mixin_config: Optional[Union[dict, DataclassInstance]] = None + # ^ optional config attribute automatically set in `from_pretrained` + _hub_mixin_info: MixinInfo + # ^ information about the library integrating ModelHubMixin (used to generate model card) + _hub_mixin_inject_config: bool # whether `_from_pretrained` expects `config` or not + _hub_mixin_init_parameters: Dict[str, inspect.Parameter] # __init__ parameters + _hub_mixin_jsonable_default_values: Dict[str, Any] # default values for __init__ parameters + _hub_mixin_jsonable_custom_types: Tuple[Type, ...] # custom types that can be encoded/decoded + _hub_mixin_coders: Dict[Type, CODER_T] # encoders/decoders for custom types + # ^ internal values to handle config + + def __init_subclass__( + cls, + *, + # Generic info for model card + repo_url: Optional[str] = None, + paper_url: Optional[str] = None, + docs_url: Optional[str] = None, + # Model card template + model_card_template: str = DEFAULT_MODEL_CARD, + # Model card metadata + language: Optional[List[str]] = None, + library_name: Optional[str] = None, + license: Optional[str] = None, + license_name: Optional[str] = None, + license_link: Optional[str] = None, + pipeline_tag: Optional[str] = None, + tags: Optional[List[str]] = None, + # How to encode/decode arguments with custom type into a JSON config? + coders: Optional[ + Dict[Type, CODER_T] + # Key is a type. + # Value is a tuple (encoder, decoder). + # Example: {MyCustomType: (lambda x: x.value, lambda data: MyCustomType(data))} + ] = None, + ) -> None: + """Inspect __init__ signature only once when subclassing + handle modelcard.""" + super().__init_subclass__() + + # Will be reused when creating modelcard + tags = tags or [] + tags.append("model_hub_mixin") + + # Initialize MixinInfo if not existent + info = MixinInfo(model_card_template=model_card_template, model_card_data=ModelCardData()) + + # If parent class has a MixinInfo, inherit from it as a copy + if hasattr(cls, "_hub_mixin_info"): + # Inherit model card template from parent class if not explicitly set + if model_card_template == DEFAULT_MODEL_CARD: + info.model_card_template = cls._hub_mixin_info.model_card_template + + # Inherit from parent model card data + info.model_card_data = ModelCardData(**cls._hub_mixin_info.model_card_data.to_dict()) + + # Inherit other info + info.docs_url = cls._hub_mixin_info.docs_url + info.paper_url = cls._hub_mixin_info.paper_url + info.repo_url = cls._hub_mixin_info.repo_url + cls._hub_mixin_info = info + + # Update MixinInfo with metadata + if model_card_template is not None and model_card_template != DEFAULT_MODEL_CARD: + info.model_card_template = model_card_template + if repo_url is not None: + info.repo_url = repo_url + if paper_url is not None: + info.paper_url = paper_url + if docs_url is not None: + info.docs_url = docs_url + if language is not None: + info.model_card_data.language = language + if library_name is not None: + info.model_card_data.library_name = library_name + if license is not None: + info.model_card_data.license = license + if license_name is not None: + info.model_card_data.license_name = license_name + if license_link is not None: + info.model_card_data.license_link = license_link + if pipeline_tag is not None: + info.model_card_data.pipeline_tag = pipeline_tag + if tags is not None: + if info.model_card_data.tags is not None: + info.model_card_data.tags.extend(tags) + else: + info.model_card_data.tags = tags + + info.model_card_data.tags = sorted(set(info.model_card_data.tags)) + + # Handle encoders/decoders for args + cls._hub_mixin_coders = coders or {} + cls._hub_mixin_jsonable_custom_types = tuple(cls._hub_mixin_coders.keys()) + + # Inspect __init__ signature to handle config + cls._hub_mixin_init_parameters = dict(inspect.signature(cls.__init__).parameters) + cls._hub_mixin_jsonable_default_values = { + param.name: cls._encode_arg(param.default) + for param in cls._hub_mixin_init_parameters.values() + if param.default is not inspect.Parameter.empty and cls._is_jsonable(param.default) + } + cls._hub_mixin_inject_config = "config" in inspect.signature(cls._from_pretrained).parameters + + def __new__(cls: Type[T], *args, **kwargs) -> T: + """Create a new instance of the class and handle config. + + 3 cases: + - If `self._hub_mixin_config` is already set, do nothing. + - If `config` is passed as a dataclass, set it as `self._hub_mixin_config`. + - Otherwise, build `self._hub_mixin_config` from default values and passed values. + """ + instance = super().__new__(cls) + + # If `config` is already set, return early + if instance._hub_mixin_config is not None: + return instance + + # Infer passed values + passed_values = { + **{ + key: value + for key, value in zip( + # [1:] to skip `self` parameter + list(cls._hub_mixin_init_parameters)[1:], + args, + ) + }, + **kwargs, + } + + # If config passed as dataclass => set it and return early + if is_dataclass(passed_values.get("config")): + instance._hub_mixin_config = passed_values["config"] + return instance + + # Otherwise, build config from default + passed values + init_config = { + # default values + **cls._hub_mixin_jsonable_default_values, + # passed values + **{ + key: cls._encode_arg(value) # Encode custom types as jsonable value + for key, value in passed_values.items() + if instance._is_jsonable(value) # Only if jsonable or we have a custom encoder + }, + } + passed_config = init_config.pop("config", {}) + + # Populate `init_config` with provided config + if isinstance(passed_config, dict): + init_config.update(passed_config) + + # Set `config` attribute and return + if init_config != {}: + instance._hub_mixin_config = init_config + return instance + + @classmethod + def _is_jsonable(cls, value: Any) -> bool: + """Check if a value is JSON serializable.""" + if is_dataclass(value): + return True + if isinstance(value, cls._hub_mixin_jsonable_custom_types): + return True + return is_jsonable(value) + + @classmethod + def _encode_arg(cls, arg: Any) -> Any: + """Encode an argument into a JSON serializable format.""" + if is_dataclass(arg): + return asdict(arg) # type: ignore[arg-type] + for type_, (encoder, _) in cls._hub_mixin_coders.items(): + if isinstance(arg, type_): + if arg is None: + return None + return encoder(arg) + return arg + + @classmethod + def _decode_arg(cls, expected_type: Type[ARGS_T], value: Any) -> Optional[ARGS_T]: + """Decode a JSON serializable value into an argument.""" + if is_simple_optional_type(expected_type): + if value is None: + return None + expected_type = unwrap_simple_optional_type(expected_type) + # Dataclass => handle it + if is_dataclass(expected_type): + return _load_dataclass(expected_type, value) # type: ignore[return-value] + # Otherwise => check custom decoders + for type_, (_, decoder) in cls._hub_mixin_coders.items(): + if inspect.isclass(expected_type) and issubclass(expected_type, type_): + return decoder(value) + # Otherwise => don't decode + return value + + def save_pretrained( + self, + save_directory: Union[str, Path], + *, + config: Optional[Union[dict, DataclassInstance]] = None, + repo_id: Optional[str] = None, + push_to_hub: bool = False, + model_card_kwargs: Optional[Dict[str, Any]] = None, + **push_to_hub_kwargs, + ) -> Optional[str]: + """ + Save weights in local directory. + + Args: + save_directory (`str` or `Path`): + Path to directory in which the model weights and configuration will be saved. + config (`dict` or `DataclassInstance`, *optional*): + Model configuration specified as a key/value dictionary or a dataclass instance. + push_to_hub (`bool`, *optional*, defaults to `False`): + Whether or not to push your model to the Huggingface Hub after saving it. + repo_id (`str`, *optional*): + ID of your repository on the Hub. Used only if `push_to_hub=True`. Will default to the folder name if + not provided. + model_card_kwargs (`Dict[str, Any]`, *optional*): + Additional arguments passed to the model card template to customize the model card. + push_to_hub_kwargs: + Additional key word arguments passed along to the [`~ModelHubMixin.push_to_hub`] method. + Returns: + `str` or `None`: url of the commit on the Hub if `push_to_hub=True`, `None` otherwise. + """ + save_directory = Path(save_directory) + save_directory.mkdir(parents=True, exist_ok=True) + + # Remove config.json if already exists. After `_save_pretrained` we don't want to overwrite config.json + # as it might have been saved by the custom `_save_pretrained` already. However we do want to overwrite + # an existing config.json if it was not saved by `_save_pretrained`. + config_path = save_directory / constants.CONFIG_NAME + config_path.unlink(missing_ok=True) + + # save model weights/files (framework-specific) + self._save_pretrained(save_directory) + + # save config (if provided and if not serialized yet in `_save_pretrained`) + if config is None: + config = self._hub_mixin_config + if config is not None: + if is_dataclass(config): + config = asdict(config) # type: ignore[arg-type] + if not config_path.exists(): + config_str = json.dumps(config, sort_keys=True, indent=2) + config_path.write_text(config_str) + + # save model card + model_card_path = save_directory / "README.md" + model_card_kwargs = model_card_kwargs if model_card_kwargs is not None else {} + if not model_card_path.exists(): # do not overwrite if already exists + self.generate_model_card(**model_card_kwargs).save(save_directory / "README.md") + + # push to the Hub if required + if push_to_hub: + kwargs = push_to_hub_kwargs.copy() # soft-copy to avoid mutating input + if config is not None: # kwarg for `push_to_hub` + kwargs["config"] = config + if repo_id is None: + repo_id = save_directory.name # Defaults to `save_directory` name + return self.push_to_hub(repo_id=repo_id, model_card_kwargs=model_card_kwargs, **kwargs) + return None + + def _save_pretrained(self, save_directory: Path) -> None: + """ + Overwrite this method in subclass to define how to save your model. + Check out our [integration guide](../guides/integrations) for instructions. + + Args: + save_directory (`str` or `Path`): + Path to directory in which the model weights and configuration will be saved. + """ + raise NotImplementedError + + @classmethod + @validate_hf_hub_args + def from_pretrained( + cls: Type[T], + pretrained_model_name_or_path: Union[str, Path], + *, + force_download: bool = False, + resume_download: Optional[bool] = None, + proxies: Optional[Dict] = None, + token: Optional[Union[str, bool]] = None, + cache_dir: Optional[Union[str, Path]] = None, + local_files_only: bool = False, + revision: Optional[str] = None, + **model_kwargs, + ) -> T: + """ + Download a model from the Huggingface Hub and instantiate it. + + Args: + pretrained_model_name_or_path (`str`, `Path`): + - Either the `model_id` (string) of a model hosted on the Hub, e.g. `bigscience/bloom`. + - Or a path to a `directory` containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., `../path/to/my_model_directory/`. + revision (`str`, *optional*): + Revision of the model on the Hub. Can be a branch name, a git tag or any commit id. + Defaults to the latest commit on `main` branch. + force_download (`bool`, *optional*, defaults to `False`): + Whether to force (re-)downloading the model weights and configuration files from the Hub, overriding + the existing cache. + proxies (`Dict[str, str]`, *optional*): + A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128', + 'http://hostname': 'foo.bar:4012'}`. The proxies are used on every request. + token (`str` or `bool`, *optional*): + The token to use as HTTP bearer authorization for remote files. By default, it will use the token + cached when running `huggingface-cli login`. + cache_dir (`str`, `Path`, *optional*): + Path to the folder where cached files are stored. + local_files_only (`bool`, *optional*, defaults to `False`): + If `True`, avoid downloading the file and return the path to the local cached file if it exists. + model_kwargs (`Dict`, *optional*): + Additional kwargs to pass to the model during initialization. + """ + model_id = str(pretrained_model_name_or_path) + config_file: Optional[str] = None + if os.path.isdir(model_id): + if constants.CONFIG_NAME in os.listdir(model_id): + config_file = os.path.join(model_id, constants.CONFIG_NAME) + else: + logger.warning(f"{constants.CONFIG_NAME} not found in {Path(model_id).resolve()}") + else: + try: + config_file = hf_hub_download( + repo_id=model_id, + filename=constants.CONFIG_NAME, + revision=revision, + cache_dir=cache_dir, + force_download=force_download, + proxies=proxies, + resume_download=resume_download, + token=token, + local_files_only=local_files_only, + ) + except HfHubHTTPError as e: + logger.info(f"{constants.CONFIG_NAME} not found on the HuggingFace Hub: {str(e)}") + + # Read config + config = None + if config_file is not None: + with open(config_file, "r", encoding="utf-8") as f: + config = json.load(f) + + # Decode custom types in config + for key, value in config.items(): + if key in cls._hub_mixin_init_parameters: + expected_type = cls._hub_mixin_init_parameters[key].annotation + if expected_type is not inspect.Parameter.empty: + config[key] = cls._decode_arg(expected_type, value) + + # Populate model_kwargs from config + for param in cls._hub_mixin_init_parameters.values(): + if param.name not in model_kwargs and param.name in config: + model_kwargs[param.name] = config[param.name] + + # Check if `config` argument was passed at init + if "config" in cls._hub_mixin_init_parameters and "config" not in model_kwargs: + # Decode `config` argument if it was passed + config_annotation = cls._hub_mixin_init_parameters["config"].annotation + config = cls._decode_arg(config_annotation, config) + + # Forward config to model initialization + model_kwargs["config"] = config + + # Inject config if `**kwargs` are expected + if is_dataclass(cls): + for key in cls.__dataclass_fields__: + if key not in model_kwargs and key in config: + model_kwargs[key] = config[key] + elif any(param.kind == inspect.Parameter.VAR_KEYWORD for param in cls._hub_mixin_init_parameters.values()): + for key, value in config.items(): + if key not in model_kwargs: + model_kwargs[key] = value + + # Finally, also inject if `_from_pretrained` expects it + if cls._hub_mixin_inject_config and "config" not in model_kwargs: + model_kwargs["config"] = config + + instance = cls._from_pretrained( + model_id=str(model_id), + revision=revision, + cache_dir=cache_dir, + force_download=force_download, + proxies=proxies, + resume_download=resume_download, + local_files_only=local_files_only, + token=token, + **model_kwargs, + ) + + # Implicitly set the config as instance attribute if not already set by the class + # This way `config` will be available when calling `save_pretrained` or `push_to_hub`. + if config is not None and (getattr(instance, "_hub_mixin_config", None) in (None, {})): + instance._hub_mixin_config = config + + return instance + + @classmethod + def _from_pretrained( + cls: Type[T], + *, + model_id: str, + revision: Optional[str], + cache_dir: Optional[Union[str, Path]], + force_download: bool, + proxies: Optional[Dict], + resume_download: Optional[bool], + local_files_only: bool, + token: Optional[Union[str, bool]], + **model_kwargs, + ) -> T: + """Overwrite this method in subclass to define how to load your model from pretrained. + + Use [`hf_hub_download`] or [`snapshot_download`] to download files from the Hub before loading them. Most + args taken as input can be directly passed to those 2 methods. If needed, you can add more arguments to this + method using "model_kwargs". For example [`PyTorchModelHubMixin._from_pretrained`] takes as input a `map_location` + parameter to set on which device the model should be loaded. + + Check out our [integration guide](../guides/integrations) for more instructions. + + Args: + model_id (`str`): + ID of the model to load from the Huggingface Hub (e.g. `bigscience/bloom`). + revision (`str`, *optional*): + Revision of the model on the Hub. Can be a branch name, a git tag or any commit id. Defaults to the + latest commit on `main` branch. + force_download (`bool`, *optional*, defaults to `False`): + Whether to force (re-)downloading the model weights and configuration files from the Hub, overriding + the existing cache. + proxies (`Dict[str, str]`, *optional*): + A dictionary of proxy servers to use by protocol or endpoint (e.g., `{'http': 'foo.bar:3128', + 'http://hostname': 'foo.bar:4012'}`). + token (`str` or `bool`, *optional*): + The token to use as HTTP bearer authorization for remote files. By default, it will use the token + cached when running `huggingface-cli login`. + cache_dir (`str`, `Path`, *optional*): + Path to the folder where cached files are stored. + local_files_only (`bool`, *optional*, defaults to `False`): + If `True`, avoid downloading the file and return the path to the local cached file if it exists. + model_kwargs: + Additional keyword arguments passed along to the [`~ModelHubMixin._from_pretrained`] method. + """ + raise NotImplementedError + + @validate_hf_hub_args + def push_to_hub( + self, + repo_id: str, + *, + config: Optional[Union[dict, DataclassInstance]] = None, + commit_message: str = "Push model using huggingface_hub.", + private: Optional[bool] = None, + token: Optional[str] = None, + branch: Optional[str] = None, + create_pr: Optional[bool] = None, + allow_patterns: Optional[Union[List[str], str]] = None, + ignore_patterns: Optional[Union[List[str], str]] = None, + delete_patterns: Optional[Union[List[str], str]] = None, + model_card_kwargs: Optional[Dict[str, Any]] = None, + ) -> str: + """ + Upload model checkpoint to the Hub. + + Use `allow_patterns` and `ignore_patterns` to precisely filter which files should be pushed to the hub. Use + `delete_patterns` to delete existing remote files in the same commit. See [`upload_folder`] reference for more + details. + + Args: + repo_id (`str`): + ID of the repository to push to (example: `"username/my-model"`). + config (`dict` or `DataclassInstance`, *optional*): + Model configuration specified as a key/value dictionary or a dataclass instance. + commit_message (`str`, *optional*): + Message to commit while pushing. + private (`bool`, *optional*): + Whether the repository created should be private. + If `None` (default), the repo will be public unless the organization's default is private. + token (`str`, *optional*): + The token to use as HTTP bearer authorization for remote files. By default, it will use the token + cached when running `huggingface-cli login`. + branch (`str`, *optional*): + The git branch on which to push the model. This defaults to `"main"`. + create_pr (`boolean`, *optional*): + Whether or not to create a Pull Request from `branch` with that commit. Defaults to `False`. + allow_patterns (`List[str]` or `str`, *optional*): + If provided, only files matching at least one pattern are pushed. + ignore_patterns (`List[str]` or `str`, *optional*): + If provided, files matching any of the patterns are not pushed. + delete_patterns (`List[str]` or `str`, *optional*): + If provided, remote files matching any of the patterns will be deleted from the repo. + model_card_kwargs (`Dict[str, Any]`, *optional*): + Additional arguments passed to the model card template to customize the model card. + + Returns: + The url of the commit of your model in the given repository. + """ + api = HfApi(token=token) + repo_id = api.create_repo(repo_id=repo_id, private=private, exist_ok=True).repo_id + + # Push the files to the repo in a single commit + with SoftTemporaryDirectory() as tmp: + saved_path = Path(tmp) / repo_id + self.save_pretrained(saved_path, config=config, model_card_kwargs=model_card_kwargs) + return api.upload_folder( + repo_id=repo_id, + repo_type="model", + folder_path=saved_path, + commit_message=commit_message, + revision=branch, + create_pr=create_pr, + allow_patterns=allow_patterns, + ignore_patterns=ignore_patterns, + delete_patterns=delete_patterns, + ) + + def generate_model_card(self, *args, **kwargs) -> ModelCard: + card = ModelCard.from_template( + card_data=self._hub_mixin_info.model_card_data, + template_str=self._hub_mixin_info.model_card_template, + repo_url=self._hub_mixin_info.repo_url, + paper_url=self._hub_mixin_info.paper_url, + docs_url=self._hub_mixin_info.docs_url, + **kwargs, + ) + return card + + +class PyTorchModelHubMixin(ModelHubMixin): + """ + Implementation of [`ModelHubMixin`] to provide model Hub upload/download capabilities to PyTorch models. The model + is set in evaluation mode by default using `model.eval()` (dropout modules are deactivated). To train the model, + you should first set it back in training mode with `model.train()`. + + See [`ModelHubMixin`] for more details on how to use the mixin. + + Example: + + ```python + >>> import torch + >>> import torch.nn as nn + >>> from huggingface_hub import PyTorchModelHubMixin + + >>> class MyModel( + ... nn.Module, + ... PyTorchModelHubMixin, + ... library_name="keras-nlp", + ... repo_url="https://github.com/keras-team/keras-nlp", + ... paper_url="https://arxiv.org/abs/2304.12244", + ... docs_url="https://keras.io/keras_nlp/", + ... # ^ optional metadata to generate model card + ... ): + ... def __init__(self, hidden_size: int = 512, vocab_size: int = 30000, output_size: int = 4): + ... super().__init__() + ... self.param = nn.Parameter(torch.rand(hidden_size, vocab_size)) + ... self.linear = nn.Linear(output_size, vocab_size) + + ... def forward(self, x): + ... return self.linear(x + self.param) + >>> model = MyModel(hidden_size=256) + + # Save model weights to local directory + >>> model.save_pretrained("my-awesome-model") + + # Push model weights to the Hub + >>> model.push_to_hub("my-awesome-model") + + # Download and initialize weights from the Hub + >>> model = MyModel.from_pretrained("username/my-awesome-model") + >>> model.hidden_size + 256 + ``` + """ + + def __init_subclass__(cls, *args, tags: Optional[List[str]] = None, **kwargs) -> None: + tags = tags or [] + tags.append("pytorch_model_hub_mixin") + kwargs["tags"] = tags + return super().__init_subclass__(*args, **kwargs) + + def _save_pretrained(self, save_directory: Path) -> None: + """Save weights from a Pytorch model to a local directory.""" + model_to_save = self.module if hasattr(self, "module") else self # type: ignore + save_model_as_safetensor(model_to_save, str(save_directory / constants.SAFETENSORS_SINGLE_FILE)) # type: ignore [arg-type] + + @classmethod + def _from_pretrained( + cls, + *, + model_id: str, + revision: Optional[str], + cache_dir: Optional[Union[str, Path]], + force_download: bool, + proxies: Optional[Dict], + resume_download: Optional[bool], + local_files_only: bool, + token: Union[str, bool, None], + map_location: str = "cpu", + strict: bool = False, + **model_kwargs, + ): + """Load Pytorch pretrained weights and return the loaded model.""" + model = cls(**model_kwargs) + if os.path.isdir(model_id): + print("Loading weights from local directory") + model_file = os.path.join(model_id, constants.SAFETENSORS_SINGLE_FILE) + return cls._load_as_safetensor(model, model_file, map_location, strict) + else: + try: + model_file = hf_hub_download( + repo_id=model_id, + filename=constants.SAFETENSORS_SINGLE_FILE, + revision=revision, + cache_dir=cache_dir, + force_download=force_download, + proxies=proxies, + resume_download=resume_download, + token=token, + local_files_only=local_files_only, + ) + return cls._load_as_safetensor(model, model_file, map_location, strict) + except EntryNotFoundError: + model_file = hf_hub_download( + repo_id=model_id, + filename=constants.PYTORCH_WEIGHTS_NAME, + revision=revision, + cache_dir=cache_dir, + force_download=force_download, + proxies=proxies, + resume_download=resume_download, + token=token, + local_files_only=local_files_only, + ) + return cls._load_as_pickle(model, model_file, map_location, strict) + + @classmethod + def _load_as_pickle(cls, model: T, model_file: str, map_location: str, strict: bool) -> T: + state_dict = torch.load(model_file, map_location=torch.device(map_location), weights_only=True) + model.load_state_dict(state_dict, strict=strict) # type: ignore + model.eval() # type: ignore + return model + + @classmethod + def _load_as_safetensor(cls, model: T, model_file: str, map_location: str, strict: bool) -> T: + if packaging.version.parse(safetensors.__version__) < packaging.version.parse("0.4.3"): # type: ignore [attr-defined] + load_model_as_safetensor(model, model_file, strict=strict) # type: ignore [arg-type] + if map_location != "cpu": + logger.warning( + "Loading model weights on other devices than 'cpu' is not supported natively in your version of safetensors." + " This means that the model is loaded on 'cpu' first and then copied to the device." + " This leads to a slower loading time." + " Please update safetensors to version 0.4.3 or above for improved performance." + ) + model.to(map_location) # type: ignore [attr-defined] + else: + safetensors.torch.load_model(model, model_file, strict=strict, device=map_location) # type: ignore [arg-type] + return model + + +def _load_dataclass(datacls: Type[DataclassInstance], data: dict) -> DataclassInstance: + """Load a dataclass instance from a dictionary. + + Fields not expected by the dataclass are ignored. + """ + return datacls(**{k: v for k, v in data.items() if k in datacls.__dataclass_fields__}) diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/__init__.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..63f6a653d6a1b1b76ebd4ca77634be47db4ee877 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/__init__.py @@ -0,0 +1,191 @@ +# This file is auto-generated by `utils/generate_inference_types.py`. +# Do not modify it manually. +# +# ruff: noqa: F401 + +from .audio_classification import ( + AudioClassificationInput, + AudioClassificationOutputElement, + AudioClassificationOutputTransform, + AudioClassificationParameters, +) +from .audio_to_audio import AudioToAudioInput, AudioToAudioOutputElement +from .automatic_speech_recognition import ( + AutomaticSpeechRecognitionEarlyStoppingEnum, + AutomaticSpeechRecognitionGenerationParameters, + AutomaticSpeechRecognitionInput, + AutomaticSpeechRecognitionOutput, + AutomaticSpeechRecognitionOutputChunk, + AutomaticSpeechRecognitionParameters, +) +from .base import BaseInferenceType +from .chat_completion import ( + ChatCompletionInput, + ChatCompletionInputFunctionDefinition, + ChatCompletionInputFunctionName, + ChatCompletionInputGrammarType, + ChatCompletionInputJSONSchema, + ChatCompletionInputMessage, + ChatCompletionInputMessageChunk, + ChatCompletionInputMessageChunkType, + ChatCompletionInputResponseFormatJSONObject, + ChatCompletionInputResponseFormatJSONSchema, + ChatCompletionInputResponseFormatText, + ChatCompletionInputStreamOptions, + ChatCompletionInputTool, + ChatCompletionInputToolCall, + ChatCompletionInputToolChoiceClass, + ChatCompletionInputToolChoiceEnum, + ChatCompletionInputURL, + ChatCompletionOutput, + ChatCompletionOutputComplete, + ChatCompletionOutputFunctionDefinition, + ChatCompletionOutputLogprob, + ChatCompletionOutputLogprobs, + ChatCompletionOutputMessage, + ChatCompletionOutputToolCall, + ChatCompletionOutputTopLogprob, + ChatCompletionOutputUsage, + ChatCompletionStreamOutput, + ChatCompletionStreamOutputChoice, + ChatCompletionStreamOutputDelta, + ChatCompletionStreamOutputDeltaToolCall, + ChatCompletionStreamOutputFunction, + ChatCompletionStreamOutputLogprob, + ChatCompletionStreamOutputLogprobs, + ChatCompletionStreamOutputTopLogprob, + ChatCompletionStreamOutputUsage, +) +from .depth_estimation import DepthEstimationInput, DepthEstimationOutput +from .document_question_answering import ( + DocumentQuestionAnsweringInput, + DocumentQuestionAnsweringInputData, + DocumentQuestionAnsweringOutputElement, + DocumentQuestionAnsweringParameters, +) +from .feature_extraction import FeatureExtractionInput, FeatureExtractionInputTruncationDirection +from .fill_mask import FillMaskInput, FillMaskOutputElement, FillMaskParameters +from .image_classification import ( + ImageClassificationInput, + ImageClassificationOutputElement, + ImageClassificationOutputTransform, + ImageClassificationParameters, +) +from .image_segmentation import ( + ImageSegmentationInput, + ImageSegmentationOutputElement, + ImageSegmentationParameters, + ImageSegmentationSubtask, +) +from .image_to_image import ImageToImageInput, ImageToImageOutput, ImageToImageParameters, ImageToImageTargetSize +from .image_to_text import ( + ImageToTextEarlyStoppingEnum, + ImageToTextGenerationParameters, + ImageToTextInput, + ImageToTextOutput, + ImageToTextParameters, +) +from .object_detection import ( + ObjectDetectionBoundingBox, + ObjectDetectionInput, + ObjectDetectionOutputElement, + ObjectDetectionParameters, +) +from .question_answering import ( + QuestionAnsweringInput, + QuestionAnsweringInputData, + QuestionAnsweringOutputElement, + QuestionAnsweringParameters, +) +from .sentence_similarity import SentenceSimilarityInput, SentenceSimilarityInputData +from .summarization import ( + SummarizationInput, + SummarizationOutput, + SummarizationParameters, + SummarizationTruncationStrategy, +) +from .table_question_answering import ( + Padding, + TableQuestionAnsweringInput, + TableQuestionAnsweringInputData, + TableQuestionAnsweringOutputElement, + TableQuestionAnsweringParameters, +) +from .text2text_generation import ( + Text2TextGenerationInput, + Text2TextGenerationOutput, + Text2TextGenerationParameters, + Text2TextGenerationTruncationStrategy, +) +from .text_classification import ( + TextClassificationInput, + TextClassificationOutputElement, + TextClassificationOutputTransform, + TextClassificationParameters, +) +from .text_generation import ( + TextGenerationInput, + TextGenerationInputGenerateParameters, + TextGenerationInputGrammarType, + TextGenerationOutput, + TextGenerationOutputBestOfSequence, + TextGenerationOutputDetails, + TextGenerationOutputFinishReason, + TextGenerationOutputPrefillToken, + TextGenerationOutputToken, + TextGenerationStreamOutput, + TextGenerationStreamOutputStreamDetails, + TextGenerationStreamOutputToken, + TypeEnum, +) +from .text_to_audio import ( + TextToAudioEarlyStoppingEnum, + TextToAudioGenerationParameters, + TextToAudioInput, + TextToAudioOutput, + TextToAudioParameters, +) +from .text_to_image import TextToImageInput, TextToImageOutput, TextToImageParameters +from .text_to_speech import ( + TextToSpeechEarlyStoppingEnum, + TextToSpeechGenerationParameters, + TextToSpeechInput, + TextToSpeechOutput, + TextToSpeechParameters, +) +from .text_to_video import TextToVideoInput, TextToVideoOutput, TextToVideoParameters +from .token_classification import ( + TokenClassificationAggregationStrategy, + TokenClassificationInput, + TokenClassificationOutputElement, + TokenClassificationParameters, +) +from .translation import TranslationInput, TranslationOutput, TranslationParameters, TranslationTruncationStrategy +from .video_classification import ( + VideoClassificationInput, + VideoClassificationOutputElement, + VideoClassificationOutputTransform, + VideoClassificationParameters, +) +from .visual_question_answering import ( + VisualQuestionAnsweringInput, + VisualQuestionAnsweringInputData, + VisualQuestionAnsweringOutputElement, + VisualQuestionAnsweringParameters, +) +from .zero_shot_classification import ( + ZeroShotClassificationInput, + ZeroShotClassificationOutputElement, + ZeroShotClassificationParameters, +) +from .zero_shot_image_classification import ( + ZeroShotImageClassificationInput, + ZeroShotImageClassificationOutputElement, + ZeroShotImageClassificationParameters, +) +from .zero_shot_object_detection import ( + ZeroShotObjectDetectionBoundingBox, + ZeroShotObjectDetectionInput, + ZeroShotObjectDetectionOutputElement, + ZeroShotObjectDetectionParameters, +) diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..053055787bce933e1fbd393cfbc00d81c43c8c2d --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_classification.py @@ -0,0 +1,43 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +AudioClassificationOutputTransform = Literal["sigmoid", "softmax", "none"] + + +@dataclass_with_extra +class AudioClassificationParameters(BaseInferenceType): + """Additional inference parameters for Audio Classification""" + + function_to_apply: Optional["AudioClassificationOutputTransform"] = None + """The function to apply to the model outputs in order to retrieve the scores.""" + top_k: Optional[int] = None + """When specified, limits the output to the top K most probable classes.""" + + +@dataclass_with_extra +class AudioClassificationInput(BaseInferenceType): + """Inputs for Audio Classification inference""" + + inputs: str + """The input audio data as a base64-encoded string. If no `parameters` are provided, you can + also provide the audio data as a raw bytes payload. + """ + parameters: Optional[AudioClassificationParameters] = None + """Additional inference parameters for Audio Classification""" + + +@dataclass_with_extra +class AudioClassificationOutputElement(BaseInferenceType): + """Outputs for Audio Classification inference""" + + label: str + """The predicted class label.""" + score: float + """The corresponding probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_to_audio.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_to_audio.py new file mode 100644 index 0000000000000000000000000000000000000000..43f376b5345fab6b854b028d1c17416c020d7bc1 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/audio_to_audio.py @@ -0,0 +1,30 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class AudioToAudioInput(BaseInferenceType): + """Inputs for Audio to Audio inference""" + + inputs: Any + """The input audio data""" + + +@dataclass_with_extra +class AudioToAudioOutputElement(BaseInferenceType): + """Outputs of inference for the Audio To Audio task + A generated audio file with its label. + """ + + blob: Any + """The generated audio file.""" + content_type: str + """The content type of audio file.""" + label: str + """The label of the audio file.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py new file mode 100644 index 0000000000000000000000000000000000000000..f6bfd28256c82309b160f337aba5a54e2dd11872 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/automatic_speech_recognition.py @@ -0,0 +1,113 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List, Literal, Optional, Union + +from .base import BaseInferenceType, dataclass_with_extra + + +AutomaticSpeechRecognitionEarlyStoppingEnum = Literal["never"] + + +@dataclass_with_extra +class AutomaticSpeechRecognitionGenerationParameters(BaseInferenceType): + """Parametrization of the text generation process""" + + do_sample: Optional[bool] = None + """Whether to use sampling instead of greedy decoding when generating new tokens.""" + early_stopping: Optional[Union[bool, "AutomaticSpeechRecognitionEarlyStoppingEnum"]] = None + """Controls the stopping condition for beam-based methods.""" + epsilon_cutoff: Optional[float] = None + """If set to float strictly between 0 and 1, only tokens with a conditional probability + greater than epsilon_cutoff will be sampled. In the paper, suggested values range from + 3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language + Model Desmoothing](https://hf.co/papers/2210.15191) for more details. + """ + eta_cutoff: Optional[float] = None + """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to + float strictly between 0 and 1, a token is only considered if it is greater than either + eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter + term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In + the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model. + See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191) + for more details. + """ + max_length: Optional[int] = None + """The maximum length (in tokens) of the generated text, including the input.""" + max_new_tokens: Optional[int] = None + """The maximum number of tokens to generate. Takes precedence over max_length.""" + min_length: Optional[int] = None + """The minimum length (in tokens) of the generated text, including the input.""" + min_new_tokens: Optional[int] = None + """The minimum number of tokens to generate. Takes precedence over min_length.""" + num_beam_groups: Optional[int] = None + """Number of groups to divide num_beams into in order to ensure diversity among different + groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details. + """ + num_beams: Optional[int] = None + """Number of beams to use for beam search.""" + penalty_alpha: Optional[float] = None + """The value balances the model confidence and the degeneration penalty in contrastive + search decoding. + """ + temperature: Optional[float] = None + """The value used to modulate the next token probabilities.""" + top_k: Optional[int] = None + """The number of highest probability vocabulary tokens to keep for top-k-filtering.""" + top_p: Optional[float] = None + """If set to float < 1, only the smallest set of most probable tokens with probabilities + that add up to top_p or higher are kept for generation. + """ + typical_p: Optional[float] = None + """Local typicality measures how similar the conditional probability of predicting a target + token next is to the expected conditional probability of predicting a random token next, + given the partial text already generated. If set to float < 1, the smallest set of the + most locally typical tokens with probabilities that add up to typical_p or higher are + kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details. + """ + use_cache: Optional[bool] = None + """Whether the model should use the past last key/values attentions to speed up decoding""" + + +@dataclass_with_extra +class AutomaticSpeechRecognitionParameters(BaseInferenceType): + """Additional inference parameters for Automatic Speech Recognition""" + + generation_parameters: Optional[AutomaticSpeechRecognitionGenerationParameters] = None + """Parametrization of the text generation process""" + return_timestamps: Optional[bool] = None + """Whether to output corresponding timestamps with the generated text""" + + +@dataclass_with_extra +class AutomaticSpeechRecognitionInput(BaseInferenceType): + """Inputs for Automatic Speech Recognition inference""" + + inputs: str + """The input audio data as a base64-encoded string. If no `parameters` are provided, you can + also provide the audio data as a raw bytes payload. + """ + parameters: Optional[AutomaticSpeechRecognitionParameters] = None + """Additional inference parameters for Automatic Speech Recognition""" + + +@dataclass_with_extra +class AutomaticSpeechRecognitionOutputChunk(BaseInferenceType): + text: str + """A chunk of text identified by the model""" + timestamp: List[float] + """The start and end timestamps corresponding with the text""" + + +@dataclass_with_extra +class AutomaticSpeechRecognitionOutput(BaseInferenceType): + """Outputs of inference for the Automatic Speech Recognition task""" + + text: str + """The recognized text.""" + chunks: Optional[List[AutomaticSpeechRecognitionOutputChunk]] = None + """When returnTimestamps is enabled, chunks contains a list of audio chunks identified by + the model. + """ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/base.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/base.py new file mode 100644 index 0000000000000000000000000000000000000000..1f0c4687ceccbfb738da3f38c583c2516d065a01 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/base.py @@ -0,0 +1,161 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Contains a base class for all inference types.""" + +import inspect +import json +from dataclasses import asdict, dataclass +from typing import Any, Dict, List, Type, TypeVar, Union, get_args + + +T = TypeVar("T", bound="BaseInferenceType") + + +def _repr_with_extra(self): + fields = list(self.__dataclass_fields__.keys()) + other_fields = list(k for k in self.__dict__ if k not in fields) + return f"{self.__class__.__name__}({', '.join(f'{k}={self.__dict__[k]!r}' for k in fields + other_fields)})" + + +def dataclass_with_extra(cls: Type[T]) -> Type[T]: + """Decorator to add a custom __repr__ method to a dataclass, showing all fields, including extra ones. + + This decorator only works with dataclasses that inherit from `BaseInferenceType`. + """ + cls = dataclass(cls) + cls.__repr__ = _repr_with_extra # type: ignore[method-assign] + return cls + + +@dataclass +class BaseInferenceType(dict): + """Base class for all inference types. + + Object is a dataclass and a dict for backward compatibility but plan is to remove the dict part in the future. + + Handle parsing from dict, list and json strings in a permissive way to ensure future-compatibility (e.g. all fields + are made optional, and non-expected fields are added as dict attributes). + """ + + @classmethod + def parse_obj_as_list(cls: Type[T], data: Union[bytes, str, List, Dict]) -> List[T]: + """Alias to parse server response and return a single instance. + + See `parse_obj` for more details. + """ + output = cls.parse_obj(data) + if not isinstance(output, list): + raise ValueError(f"Invalid input data for {cls}. Expected a list, but got {type(output)}.") + return output + + @classmethod + def parse_obj_as_instance(cls: Type[T], data: Union[bytes, str, List, Dict]) -> T: + """Alias to parse server response and return a single instance. + + See `parse_obj` for more details. + """ + output = cls.parse_obj(data) + if isinstance(output, list): + raise ValueError(f"Invalid input data for {cls}. Expected a single instance, but got a list.") + return output + + @classmethod + def parse_obj(cls: Type[T], data: Union[bytes, str, List, Dict]) -> Union[List[T], T]: + """Parse server response as a dataclass or list of dataclasses. + + To enable future-compatibility, we want to handle cases where the server return more fields than expected. + In such cases, we don't want to raise an error but still create the dataclass object. Remaining fields are + added as dict attributes. + """ + # Parse server response (from bytes) + if isinstance(data, bytes): + data = data.decode() + if isinstance(data, str): + data = json.loads(data) + + # If a list, parse each item individually + if isinstance(data, List): + return [cls.parse_obj(d) for d in data] # type: ignore [misc] + + # At this point, we expect a dict + if not isinstance(data, dict): + raise ValueError(f"Invalid data type: {type(data)}") + + init_values = {} + other_values = {} + for key, value in data.items(): + key = normalize_key(key) + if key in cls.__dataclass_fields__ and cls.__dataclass_fields__[key].init: + if isinstance(value, dict) or isinstance(value, list): + field_type = cls.__dataclass_fields__[key].type + + # if `field_type` is a `BaseInferenceType`, parse it + if inspect.isclass(field_type) and issubclass(field_type, BaseInferenceType): + value = field_type.parse_obj(value) + + # otherwise, recursively parse nested dataclasses (if possible) + # `get_args` returns handle Union and Optional for us + else: + expected_types = get_args(field_type) + for expected_type in expected_types: + if getattr(expected_type, "_name", None) == "List": + expected_type = get_args(expected_type)[ + 0 + ] # assume same type for all items in the list + if inspect.isclass(expected_type) and issubclass(expected_type, BaseInferenceType): + value = expected_type.parse_obj(value) + break + init_values[key] = value + else: + other_values[key] = value + + # Make all missing fields default to None + # => ensure that dataclass initialization will never fail even if the server does not return all fields. + for key in cls.__dataclass_fields__: + if key not in init_values: + init_values[key] = None + + # Initialize dataclass with expected values + item = cls(**init_values) + + # Add remaining fields as dict attributes + item.update(other_values) + + # Add remaining fields as extra dataclass fields. + # They won't be part of the dataclass fields but will be accessible as attributes. + # Use @dataclass_with_extra to show them in __repr__. + item.__dict__.update(other_values) + return item + + def __post_init__(self): + self.update(asdict(self)) + + def __setitem__(self, __key: Any, __value: Any) -> None: + # Hacky way to keep dataclass values in sync when dict is updated + super().__setitem__(__key, __value) + if __key in self.__dataclass_fields__ and getattr(self, __key, None) != __value: + self.__setattr__(__key, __value) + return + + def __setattr__(self, __name: str, __value: Any) -> None: + # Hacky way to keep dict values is sync when dataclass is updated + super().__setattr__(__name, __value) + if self.get(__name) != __value: + self[__name] = __value + return + + +def normalize_key(key: str) -> str: + # e.g "content-type" -> "content_type", "Accept" -> "accept" + return key.replace("-", "_").replace(" ", "_").lower() diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/depth_estimation.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/depth_estimation.py new file mode 100644 index 0000000000000000000000000000000000000000..1e09bdffa194f97444e484de6e930f67ac030207 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/depth_estimation.py @@ -0,0 +1,28 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Dict, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class DepthEstimationInput(BaseInferenceType): + """Inputs for Depth Estimation inference""" + + inputs: Any + """The input image data""" + parameters: Optional[Dict[str, Any]] = None + """Additional inference parameters for Depth Estimation""" + + +@dataclass_with_extra +class DepthEstimationOutput(BaseInferenceType): + """Outputs of inference for the Depth Estimation task""" + + depth: Any + """The predicted depth as an image""" + predicted_depth: Any + """The predicted depth as a tensor""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/document_question_answering.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/document_question_answering.py new file mode 100644 index 0000000000000000000000000000000000000000..2457d2c8c237f055f660e0e8291d846bb036949d --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/document_question_answering.py @@ -0,0 +1,80 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, List, Optional, Union + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class DocumentQuestionAnsweringInputData(BaseInferenceType): + """One (document, question) pair to answer""" + + image: Any + """The image on which the question is asked""" + question: str + """A question to ask of the document""" + + +@dataclass_with_extra +class DocumentQuestionAnsweringParameters(BaseInferenceType): + """Additional inference parameters for Document Question Answering""" + + doc_stride: Optional[int] = None + """If the words in the document are too long to fit with the question for the model, it will + be split in several chunks with some overlap. This argument controls the size of that + overlap. + """ + handle_impossible_answer: Optional[bool] = None + """Whether to accept impossible as an answer""" + lang: Optional[str] = None + """Language to use while running OCR. Defaults to english.""" + max_answer_len: Optional[int] = None + """The maximum length of predicted answers (e.g., only answers with a shorter length are + considered). + """ + max_question_len: Optional[int] = None + """The maximum length of the question after tokenization. It will be truncated if needed.""" + max_seq_len: Optional[int] = None + """The maximum length of the total sentence (context + question) in tokens of each chunk + passed to the model. The context will be split in several chunks (using doc_stride as + overlap) if needed. + """ + top_k: Optional[int] = None + """The number of answers to return (will be chosen by order of likelihood). Can return less + than top_k answers if there are not enough options available within the context. + """ + word_boxes: Optional[List[Union[List[float], str]]] = None + """A list of words and bounding boxes (normalized 0->1000). If provided, the inference will + skip the OCR step and use the provided bounding boxes instead. + """ + + +@dataclass_with_extra +class DocumentQuestionAnsweringInput(BaseInferenceType): + """Inputs for Document Question Answering inference""" + + inputs: DocumentQuestionAnsweringInputData + """One (document, question) pair to answer""" + parameters: Optional[DocumentQuestionAnsweringParameters] = None + """Additional inference parameters for Document Question Answering""" + + +@dataclass_with_extra +class DocumentQuestionAnsweringOutputElement(BaseInferenceType): + """Outputs of inference for the Document Question Answering task""" + + answer: str + """The answer to the question.""" + end: int + """The end word index of the answer (in the OCR’d version of the input or provided word + boxes). + """ + score: float + """The probability associated to the answer.""" + start: int + """The start word index of the answer (in the OCR’d version of the input or provided word + boxes). + """ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/feature_extraction.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/feature_extraction.py new file mode 100644 index 0000000000000000000000000000000000000000..e965ddbac2af0a5bf73e662a7c18c847611d18a1 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/feature_extraction.py @@ -0,0 +1,36 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List, Literal, Optional, Union + +from .base import BaseInferenceType, dataclass_with_extra + + +FeatureExtractionInputTruncationDirection = Literal["Left", "Right"] + + +@dataclass_with_extra +class FeatureExtractionInput(BaseInferenceType): + """Feature Extraction Input. + Auto-generated from TEI specs. + For more details, check out + https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tei-import.ts. + """ + + inputs: Union[List[str], str] + """The text or list of texts to embed.""" + normalize: Optional[bool] = None + prompt_name: Optional[str] = None + """The name of the prompt that should be used by for encoding. If not set, no prompt + will be applied. + Must be a key in the `sentence-transformers` configuration `prompts` dictionary. + For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ", + ...}, + then the sentence "What is the capital of France?" will be encoded as + "query: What is the capital of France?" because the prompt text will be prepended before + any text to encode. + """ + truncate: Optional[bool] = None + truncation_direction: Optional["FeatureExtractionInputTruncationDirection"] = None diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_image.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_image.py new file mode 100644 index 0000000000000000000000000000000000000000..e99e719f8b837c76392b58d33ca19f9b615e857e --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_image.py @@ -0,0 +1,56 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class ImageToImageTargetSize(BaseInferenceType): + """The size in pixel of the output image.""" + + height: int + width: int + + +@dataclass_with_extra +class ImageToImageParameters(BaseInferenceType): + """Additional inference parameters for Image To Image""" + + guidance_scale: Optional[float] = None + """For diffusion models. A higher guidance scale value encourages the model to generate + images closely linked to the text prompt at the expense of lower image quality. + """ + negative_prompt: Optional[str] = None + """One prompt to guide what NOT to include in image generation.""" + num_inference_steps: Optional[int] = None + """For diffusion models. The number of denoising steps. More denoising steps usually lead to + a higher quality image at the expense of slower inference. + """ + prompt: Optional[str] = None + """The text prompt to guide the image generation.""" + target_size: Optional[ImageToImageTargetSize] = None + """The size in pixel of the output image.""" + + +@dataclass_with_extra +class ImageToImageInput(BaseInferenceType): + """Inputs for Image To Image inference""" + + inputs: str + """The input image data as a base64-encoded string. If no `parameters` are provided, you can + also provide the image data as a raw bytes payload. + """ + parameters: Optional[ImageToImageParameters] = None + """Additional inference parameters for Image To Image""" + + +@dataclass_with_extra +class ImageToImageOutput(BaseInferenceType): + """Outputs of inference for the Image To Image task""" + + image: Any + """The output image returned as raw bytes in the payload.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_text.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_text.py new file mode 100644 index 0000000000000000000000000000000000000000..b65e0e0068e80dbcab5a4706fb5d49be2538c4ca --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/image_to_text.py @@ -0,0 +1,100 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Literal, Optional, Union + +from .base import BaseInferenceType, dataclass_with_extra + + +ImageToTextEarlyStoppingEnum = Literal["never"] + + +@dataclass_with_extra +class ImageToTextGenerationParameters(BaseInferenceType): + """Parametrization of the text generation process""" + + do_sample: Optional[bool] = None + """Whether to use sampling instead of greedy decoding when generating new tokens.""" + early_stopping: Optional[Union[bool, "ImageToTextEarlyStoppingEnum"]] = None + """Controls the stopping condition for beam-based methods.""" + epsilon_cutoff: Optional[float] = None + """If set to float strictly between 0 and 1, only tokens with a conditional probability + greater than epsilon_cutoff will be sampled. In the paper, suggested values range from + 3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language + Model Desmoothing](https://hf.co/papers/2210.15191) for more details. + """ + eta_cutoff: Optional[float] = None + """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to + float strictly between 0 and 1, a token is only considered if it is greater than either + eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter + term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In + the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model. + See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191) + for more details. + """ + max_length: Optional[int] = None + """The maximum length (in tokens) of the generated text, including the input.""" + max_new_tokens: Optional[int] = None + """The maximum number of tokens to generate. Takes precedence over max_length.""" + min_length: Optional[int] = None + """The minimum length (in tokens) of the generated text, including the input.""" + min_new_tokens: Optional[int] = None + """The minimum number of tokens to generate. Takes precedence over min_length.""" + num_beam_groups: Optional[int] = None + """Number of groups to divide num_beams into in order to ensure diversity among different + groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details. + """ + num_beams: Optional[int] = None + """Number of beams to use for beam search.""" + penalty_alpha: Optional[float] = None + """The value balances the model confidence and the degeneration penalty in contrastive + search decoding. + """ + temperature: Optional[float] = None + """The value used to modulate the next token probabilities.""" + top_k: Optional[int] = None + """The number of highest probability vocabulary tokens to keep for top-k-filtering.""" + top_p: Optional[float] = None + """If set to float < 1, only the smallest set of most probable tokens with probabilities + that add up to top_p or higher are kept for generation. + """ + typical_p: Optional[float] = None + """Local typicality measures how similar the conditional probability of predicting a target + token next is to the expected conditional probability of predicting a random token next, + given the partial text already generated. If set to float < 1, the smallest set of the + most locally typical tokens with probabilities that add up to typical_p or higher are + kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details. + """ + use_cache: Optional[bool] = None + """Whether the model should use the past last key/values attentions to speed up decoding""" + + +@dataclass_with_extra +class ImageToTextParameters(BaseInferenceType): + """Additional inference parameters for Image To Text""" + + generation_parameters: Optional[ImageToTextGenerationParameters] = None + """Parametrization of the text generation process""" + max_new_tokens: Optional[int] = None + """The amount of maximum tokens to generate.""" + + +@dataclass_with_extra +class ImageToTextInput(BaseInferenceType): + """Inputs for Image To Text inference""" + + inputs: Any + """The input image data""" + parameters: Optional[ImageToTextParameters] = None + """Additional inference parameters for Image To Text""" + + +@dataclass_with_extra +class ImageToTextOutput(BaseInferenceType): + """Outputs of inference for the Image To Text task""" + + generated_text: Any + image_to_text_output_generated_text: Optional[str] = None + """The generated text.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/object_detection.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/object_detection.py new file mode 100644 index 0000000000000000000000000000000000000000..75f3ebcfe1199462d0df60879b5ba6e517f7001e --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/object_detection.py @@ -0,0 +1,58 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class ObjectDetectionParameters(BaseInferenceType): + """Additional inference parameters for Object Detection""" + + threshold: Optional[float] = None + """The probability necessary to make a prediction.""" + + +@dataclass_with_extra +class ObjectDetectionInput(BaseInferenceType): + """Inputs for Object Detection inference""" + + inputs: str + """The input image data as a base64-encoded string. If no `parameters` are provided, you can + also provide the image data as a raw bytes payload. + """ + parameters: Optional[ObjectDetectionParameters] = None + """Additional inference parameters for Object Detection""" + + +@dataclass_with_extra +class ObjectDetectionBoundingBox(BaseInferenceType): + """The predicted bounding box. Coordinates are relative to the top left corner of the input + image. + """ + + xmax: int + """The x-coordinate of the bottom-right corner of the bounding box.""" + xmin: int + """The x-coordinate of the top-left corner of the bounding box.""" + ymax: int + """The y-coordinate of the bottom-right corner of the bounding box.""" + ymin: int + """The y-coordinate of the top-left corner of the bounding box.""" + + +@dataclass_with_extra +class ObjectDetectionOutputElement(BaseInferenceType): + """Outputs of inference for the Object Detection task""" + + box: ObjectDetectionBoundingBox + """The predicted bounding box. Coordinates are relative to the top left corner of the input + image. + """ + label: str + """The predicted label for the bounding box.""" + score: float + """The associated score / probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/sentence_similarity.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/sentence_similarity.py new file mode 100644 index 0000000000000000000000000000000000000000..66e8bb4d9322d4847556b7a17dc17bd208a37d0c --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/sentence_similarity.py @@ -0,0 +1,27 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Dict, List, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class SentenceSimilarityInputData(BaseInferenceType): + sentences: List[str] + """A list of strings which will be compared against the source_sentence.""" + source_sentence: str + """The string that you wish to compare the other strings with. This can be a phrase, + sentence, or longer passage, depending on the model being used. + """ + + +@dataclass_with_extra +class SentenceSimilarityInput(BaseInferenceType): + """Inputs for Sentence similarity inference""" + + inputs: SentenceSimilarityInputData + parameters: Optional[Dict[str, Any]] = None + """Additional inference parameters for Sentence Similarity""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/summarization.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/summarization.py new file mode 100644 index 0000000000000000000000000000000000000000..33eae6fcba0e8724babf145f93be005868429c33 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/summarization.py @@ -0,0 +1,41 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Dict, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +SummarizationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"] + + +@dataclass_with_extra +class SummarizationParameters(BaseInferenceType): + """Additional inference parameters for summarization.""" + + clean_up_tokenization_spaces: Optional[bool] = None + """Whether to clean up the potential extra spaces in the text output.""" + generate_parameters: Optional[Dict[str, Any]] = None + """Additional parametrization of the text generation algorithm.""" + truncation: Optional["SummarizationTruncationStrategy"] = None + """The truncation strategy to use.""" + + +@dataclass_with_extra +class SummarizationInput(BaseInferenceType): + """Inputs for Summarization inference""" + + inputs: str + """The input text to summarize.""" + parameters: Optional[SummarizationParameters] = None + """Additional inference parameters for summarization.""" + + +@dataclass_with_extra +class SummarizationOutput(BaseInferenceType): + """Outputs of inference for the Summarization task""" + + summary_text: str + """The summarized text.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/table_question_answering.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/table_question_answering.py new file mode 100644 index 0000000000000000000000000000000000000000..10e208eeeb50a689d2826a160432a2b005ec006c --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/table_question_answering.py @@ -0,0 +1,62 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Dict, List, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class TableQuestionAnsweringInputData(BaseInferenceType): + """One (table, question) pair to answer""" + + question: str + """The question to be answered about the table""" + table: Dict[str, List[str]] + """The table to serve as context for the questions""" + + +Padding = Literal["do_not_pad", "longest", "max_length"] + + +@dataclass_with_extra +class TableQuestionAnsweringParameters(BaseInferenceType): + """Additional inference parameters for Table Question Answering""" + + padding: Optional["Padding"] = None + """Activates and controls padding.""" + sequential: Optional[bool] = None + """Whether to do inference sequentially or as a batch. Batching is faster, but models like + SQA require the inference to be done sequentially to extract relations within sequences, + given their conversational nature. + """ + truncation: Optional[bool] = None + """Activates and controls truncation.""" + + +@dataclass_with_extra +class TableQuestionAnsweringInput(BaseInferenceType): + """Inputs for Table Question Answering inference""" + + inputs: TableQuestionAnsweringInputData + """One (table, question) pair to answer""" + parameters: Optional[TableQuestionAnsweringParameters] = None + """Additional inference parameters for Table Question Answering""" + + +@dataclass_with_extra +class TableQuestionAnsweringOutputElement(BaseInferenceType): + """Outputs of inference for the Table Question Answering task""" + + answer: str + """The answer of the question given the table. If there is an aggregator, the answer will be + preceded by `AGGREGATOR >`. + """ + cells: List[str] + """List of strings made up of the answer cell values.""" + coordinates: List[List[int]] + """Coordinates of the cells of the answers.""" + aggregator: Optional[str] = None + """If the model has an aggregator, this returns the aggregator.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..9a172b23f844fa58f757a644d52138a18e7b6ddb --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_classification.py @@ -0,0 +1,41 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +TextClassificationOutputTransform = Literal["sigmoid", "softmax", "none"] + + +@dataclass_with_extra +class TextClassificationParameters(BaseInferenceType): + """Additional inference parameters for Text Classification""" + + function_to_apply: Optional["TextClassificationOutputTransform"] = None + """The function to apply to the model outputs in order to retrieve the scores.""" + top_k: Optional[int] = None + """When specified, limits the output to the top K most probable classes.""" + + +@dataclass_with_extra +class TextClassificationInput(BaseInferenceType): + """Inputs for Text Classification inference""" + + inputs: str + """The text to classify""" + parameters: Optional[TextClassificationParameters] = None + """Additional inference parameters for Text Classification""" + + +@dataclass_with_extra +class TextClassificationOutputElement(BaseInferenceType): + """Outputs of inference for the Text Classification task""" + + label: str + """The predicted class label.""" + score: float + """The corresponding probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_generation.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_generation.py new file mode 100644 index 0000000000000000000000000000000000000000..9b79cc691dce3a6d42aef716d4a93a719f2d600c --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_generation.py @@ -0,0 +1,168 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, List, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +TypeEnum = Literal["json", "regex", "json_schema"] + + +@dataclass_with_extra +class TextGenerationInputGrammarType(BaseInferenceType): + type: "TypeEnum" + value: Any + """A string that represents a [JSON Schema](https://json-schema.org/). + JSON Schema is a declarative language that allows to annotate JSON documents + with types and descriptions. + """ + + +@dataclass_with_extra +class TextGenerationInputGenerateParameters(BaseInferenceType): + adapter_id: Optional[str] = None + """Lora adapter id""" + best_of: Optional[int] = None + """Generate best_of sequences and return the one if the highest token logprobs.""" + decoder_input_details: Optional[bool] = None + """Whether to return decoder input token logprobs and ids.""" + details: Optional[bool] = None + """Whether to return generation details.""" + do_sample: Optional[bool] = None + """Activate logits sampling.""" + frequency_penalty: Optional[float] = None + """The parameter for frequency penalty. 1.0 means no penalty + Penalize new tokens based on their existing frequency in the text so far, + decreasing the model's likelihood to repeat the same line verbatim. + """ + grammar: Optional[TextGenerationInputGrammarType] = None + max_new_tokens: Optional[int] = None + """Maximum number of tokens to generate.""" + repetition_penalty: Optional[float] = None + """The parameter for repetition penalty. 1.0 means no penalty. + See [this paper](https://arxiv.org/pdf/1909.05858.pdf) for more details. + """ + return_full_text: Optional[bool] = None + """Whether to prepend the prompt to the generated text""" + seed: Optional[int] = None + """Random sampling seed.""" + stop: Optional[List[str]] = None + """Stop generating tokens if a member of `stop` is generated.""" + temperature: Optional[float] = None + """The value used to module the logits distribution.""" + top_k: Optional[int] = None + """The number of highest probability vocabulary tokens to keep for top-k-filtering.""" + top_n_tokens: Optional[int] = None + """The number of highest probability vocabulary tokens to keep for top-n-filtering.""" + top_p: Optional[float] = None + """Top-p value for nucleus sampling.""" + truncate: Optional[int] = None + """Truncate inputs tokens to the given size.""" + typical_p: Optional[float] = None + """Typical Decoding mass + See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) + for more information. + """ + watermark: Optional[bool] = None + """Watermarking with [A Watermark for Large Language + Models](https://arxiv.org/abs/2301.10226). + """ + + +@dataclass_with_extra +class TextGenerationInput(BaseInferenceType): + """Text Generation Input. + Auto-generated from TGI specs. + For more details, check out + https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts. + """ + + inputs: str + parameters: Optional[TextGenerationInputGenerateParameters] = None + stream: Optional[bool] = None + + +TextGenerationOutputFinishReason = Literal["length", "eos_token", "stop_sequence"] + + +@dataclass_with_extra +class TextGenerationOutputPrefillToken(BaseInferenceType): + id: int + logprob: float + text: str + + +@dataclass_with_extra +class TextGenerationOutputToken(BaseInferenceType): + id: int + logprob: float + special: bool + text: str + + +@dataclass_with_extra +class TextGenerationOutputBestOfSequence(BaseInferenceType): + finish_reason: "TextGenerationOutputFinishReason" + generated_text: str + generated_tokens: int + prefill: List[TextGenerationOutputPrefillToken] + tokens: List[TextGenerationOutputToken] + seed: Optional[int] = None + top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None + + +@dataclass_with_extra +class TextGenerationOutputDetails(BaseInferenceType): + finish_reason: "TextGenerationOutputFinishReason" + generated_tokens: int + prefill: List[TextGenerationOutputPrefillToken] + tokens: List[TextGenerationOutputToken] + best_of_sequences: Optional[List[TextGenerationOutputBestOfSequence]] = None + seed: Optional[int] = None + top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None + + +@dataclass_with_extra +class TextGenerationOutput(BaseInferenceType): + """Text Generation Output. + Auto-generated from TGI specs. + For more details, check out + https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts. + """ + + generated_text: str + details: Optional[TextGenerationOutputDetails] = None + + +@dataclass_with_extra +class TextGenerationStreamOutputStreamDetails(BaseInferenceType): + finish_reason: "TextGenerationOutputFinishReason" + generated_tokens: int + input_length: int + seed: Optional[int] = None + + +@dataclass_with_extra +class TextGenerationStreamOutputToken(BaseInferenceType): + id: int + logprob: float + special: bool + text: str + + +@dataclass_with_extra +class TextGenerationStreamOutput(BaseInferenceType): + """Text Generation Stream Output. + Auto-generated from TGI specs. + For more details, check out + https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts. + """ + + index: int + token: TextGenerationStreamOutputToken + details: Optional[TextGenerationStreamOutputStreamDetails] = None + generated_text: Optional[str] = None + top_tokens: Optional[List[TextGenerationStreamOutputToken]] = None diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_to_speech.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_to_speech.py new file mode 100644 index 0000000000000000000000000000000000000000..ce2db8f3f901cc99b5d2fcbb362c4b07b2a718e0 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/text_to_speech.py @@ -0,0 +1,99 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Literal, Optional, Union + +from .base import BaseInferenceType, dataclass_with_extra + + +TextToSpeechEarlyStoppingEnum = Literal["never"] + + +@dataclass_with_extra +class TextToSpeechGenerationParameters(BaseInferenceType): + """Parametrization of the text generation process""" + + do_sample: Optional[bool] = None + """Whether to use sampling instead of greedy decoding when generating new tokens.""" + early_stopping: Optional[Union[bool, "TextToSpeechEarlyStoppingEnum"]] = None + """Controls the stopping condition for beam-based methods.""" + epsilon_cutoff: Optional[float] = None + """If set to float strictly between 0 and 1, only tokens with a conditional probability + greater than epsilon_cutoff will be sampled. In the paper, suggested values range from + 3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language + Model Desmoothing](https://hf.co/papers/2210.15191) for more details. + """ + eta_cutoff: Optional[float] = None + """Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to + float strictly between 0 and 1, a token is only considered if it is greater than either + eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter + term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In + the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model. + See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191) + for more details. + """ + max_length: Optional[int] = None + """The maximum length (in tokens) of the generated text, including the input.""" + max_new_tokens: Optional[int] = None + """The maximum number of tokens to generate. Takes precedence over max_length.""" + min_length: Optional[int] = None + """The minimum length (in tokens) of the generated text, including the input.""" + min_new_tokens: Optional[int] = None + """The minimum number of tokens to generate. Takes precedence over min_length.""" + num_beam_groups: Optional[int] = None + """Number of groups to divide num_beams into in order to ensure diversity among different + groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details. + """ + num_beams: Optional[int] = None + """Number of beams to use for beam search.""" + penalty_alpha: Optional[float] = None + """The value balances the model confidence and the degeneration penalty in contrastive + search decoding. + """ + temperature: Optional[float] = None + """The value used to modulate the next token probabilities.""" + top_k: Optional[int] = None + """The number of highest probability vocabulary tokens to keep for top-k-filtering.""" + top_p: Optional[float] = None + """If set to float < 1, only the smallest set of most probable tokens with probabilities + that add up to top_p or higher are kept for generation. + """ + typical_p: Optional[float] = None + """Local typicality measures how similar the conditional probability of predicting a target + token next is to the expected conditional probability of predicting a random token next, + given the partial text already generated. If set to float < 1, the smallest set of the + most locally typical tokens with probabilities that add up to typical_p or higher are + kept for generation. See [this paper](https://hf.co/papers/2202.00666) for more details. + """ + use_cache: Optional[bool] = None + """Whether the model should use the past last key/values attentions to speed up decoding""" + + +@dataclass_with_extra +class TextToSpeechParameters(BaseInferenceType): + """Additional inference parameters for Text To Speech""" + + generation_parameters: Optional[TextToSpeechGenerationParameters] = None + """Parametrization of the text generation process""" + + +@dataclass_with_extra +class TextToSpeechInput(BaseInferenceType): + """Inputs for Text To Speech inference""" + + inputs: str + """The input text data""" + parameters: Optional[TextToSpeechParameters] = None + """Additional inference parameters for Text To Speech""" + + +@dataclass_with_extra +class TextToSpeechOutput(BaseInferenceType): + """Outputs of inference for the Text To Speech task""" + + audio: Any + """The generated audio""" + sampling_rate: Optional[float] = None + """The sampling rate of the generated audio waveform.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/token_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/token_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..e039b6a1db7dcd54dbc9434d3254da0770c6799e --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/token_classification.py @@ -0,0 +1,51 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +TokenClassificationAggregationStrategy = Literal["none", "simple", "first", "average", "max"] + + +@dataclass_with_extra +class TokenClassificationParameters(BaseInferenceType): + """Additional inference parameters for Token Classification""" + + aggregation_strategy: Optional["TokenClassificationAggregationStrategy"] = None + """The strategy used to fuse tokens based on model predictions""" + ignore_labels: Optional[List[str]] = None + """A list of labels to ignore""" + stride: Optional[int] = None + """The number of overlapping tokens between chunks when splitting the input text.""" + + +@dataclass_with_extra +class TokenClassificationInput(BaseInferenceType): + """Inputs for Token Classification inference""" + + inputs: str + """The input text data""" + parameters: Optional[TokenClassificationParameters] = None + """Additional inference parameters for Token Classification""" + + +@dataclass_with_extra +class TokenClassificationOutputElement(BaseInferenceType): + """Outputs of inference for the Token Classification task""" + + end: int + """The character position in the input where this group ends.""" + score: float + """The associated score / probability""" + start: int + """The character position in the input where this group begins.""" + word: str + """The corresponding text""" + entity: Optional[str] = None + """The predicted label for a single token""" + entity_group: Optional[str] = None + """The predicted label for a group of one or more tokens""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/translation.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/translation.py new file mode 100644 index 0000000000000000000000000000000000000000..df95b7dbb1f4ce5b80cec034e004bb6e71387be8 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/translation.py @@ -0,0 +1,49 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Dict, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +TranslationTruncationStrategy = Literal["do_not_truncate", "longest_first", "only_first", "only_second"] + + +@dataclass_with_extra +class TranslationParameters(BaseInferenceType): + """Additional inference parameters for Translation""" + + clean_up_tokenization_spaces: Optional[bool] = None + """Whether to clean up the potential extra spaces in the text output.""" + generate_parameters: Optional[Dict[str, Any]] = None + """Additional parametrization of the text generation algorithm.""" + src_lang: Optional[str] = None + """The source language of the text. Required for models that can translate from multiple + languages. + """ + tgt_lang: Optional[str] = None + """Target language to translate to. Required for models that can translate to multiple + languages. + """ + truncation: Optional["TranslationTruncationStrategy"] = None + """The truncation strategy to use.""" + + +@dataclass_with_extra +class TranslationInput(BaseInferenceType): + """Inputs for Translation inference""" + + inputs: str + """The text to translate.""" + parameters: Optional[TranslationParameters] = None + """Additional inference parameters for Translation""" + + +@dataclass_with_extra +class TranslationOutput(BaseInferenceType): + """Outputs of inference for the Translation task""" + + translation_text: str + """The translated text.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/video_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/video_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..e1d7a15bb4ee5fa63aa6ebc3750191bd38549212 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/video_classification.py @@ -0,0 +1,45 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import Any, Literal, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +VideoClassificationOutputTransform = Literal["sigmoid", "softmax", "none"] + + +@dataclass_with_extra +class VideoClassificationParameters(BaseInferenceType): + """Additional inference parameters for Video Classification""" + + frame_sampling_rate: Optional[int] = None + """The sampling rate used to select frames from the video.""" + function_to_apply: Optional["VideoClassificationOutputTransform"] = None + """The function to apply to the model outputs in order to retrieve the scores.""" + num_frames: Optional[int] = None + """The number of sampled frames to consider for classification.""" + top_k: Optional[int] = None + """When specified, limits the output to the top K most probable classes.""" + + +@dataclass_with_extra +class VideoClassificationInput(BaseInferenceType): + """Inputs for Video Classification inference""" + + inputs: Any + """The input video data""" + parameters: Optional[VideoClassificationParameters] = None + """Additional inference parameters for Video Classification""" + + +@dataclass_with_extra +class VideoClassificationOutputElement(BaseInferenceType): + """Outputs of inference for the Video Classification task""" + + label: str + """The predicted class label.""" + score: float + """The corresponding probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..47b32492e358edcc0de6aa09d53635b0a8156b25 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_classification.py @@ -0,0 +1,45 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class ZeroShotClassificationParameters(BaseInferenceType): + """Additional inference parameters for Zero Shot Classification""" + + candidate_labels: List[str] + """The set of possible class labels to classify the text into.""" + hypothesis_template: Optional[str] = None + """The sentence used in conjunction with `candidate_labels` to attempt the text + classification by replacing the placeholder with the candidate labels. + """ + multi_label: Optional[bool] = None + """Whether multiple candidate labels can be true. If false, the scores are normalized such + that the sum of the label likelihoods for each sequence is 1. If true, the labels are + considered independent and probabilities are normalized for each candidate. + """ + + +@dataclass_with_extra +class ZeroShotClassificationInput(BaseInferenceType): + """Inputs for Zero Shot Classification inference""" + + inputs: str + """The text to classify""" + parameters: ZeroShotClassificationParameters + """Additional inference parameters for Zero Shot Classification""" + + +@dataclass_with_extra +class ZeroShotClassificationOutputElement(BaseInferenceType): + """Outputs of inference for the Zero Shot Classification task""" + + label: str + """The predicted class label.""" + score: float + """The corresponding probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py new file mode 100644 index 0000000000000000000000000000000000000000..998d66b6b4e3356f0f09a0ad25ebdaf2e76cd03f --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_image_classification.py @@ -0,0 +1,40 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List, Optional + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class ZeroShotImageClassificationParameters(BaseInferenceType): + """Additional inference parameters for Zero Shot Image Classification""" + + candidate_labels: List[str] + """The candidate labels for this image""" + hypothesis_template: Optional[str] = None + """The sentence used in conjunction with `candidate_labels` to attempt the image + classification by replacing the placeholder with the candidate labels. + """ + + +@dataclass_with_extra +class ZeroShotImageClassificationInput(BaseInferenceType): + """Inputs for Zero Shot Image Classification inference""" + + inputs: str + """The input image data to classify as a base64-encoded string.""" + parameters: ZeroShotImageClassificationParameters + """Additional inference parameters for Zero Shot Image Classification""" + + +@dataclass_with_extra +class ZeroShotImageClassificationOutputElement(BaseInferenceType): + """Outputs of inference for the Zero Shot Image Classification task""" + + label: str + """The predicted class label.""" + score: float + """The corresponding probability.""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py new file mode 100644 index 0000000000000000000000000000000000000000..8ef76b5fcb93e8126266e4b1464934d01024b1b7 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/inference/_generated/types/zero_shot_object_detection.py @@ -0,0 +1,52 @@ +# Inference code generated from the JSON schema spec in @huggingface/tasks. +# +# See: +# - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts +# - specs: https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks. +from typing import List + +from .base import BaseInferenceType, dataclass_with_extra + + +@dataclass_with_extra +class ZeroShotObjectDetectionParameters(BaseInferenceType): + """Additional inference parameters for Zero Shot Object Detection""" + + candidate_labels: List[str] + """The candidate labels for this image""" + + +@dataclass_with_extra +class ZeroShotObjectDetectionInput(BaseInferenceType): + """Inputs for Zero Shot Object Detection inference""" + + inputs: str + """The input image data as a base64-encoded string.""" + parameters: ZeroShotObjectDetectionParameters + """Additional inference parameters for Zero Shot Object Detection""" + + +@dataclass_with_extra +class ZeroShotObjectDetectionBoundingBox(BaseInferenceType): + """The predicted bounding box. Coordinates are relative to the top left corner of the input + image. + """ + + xmax: int + xmin: int + ymax: int + ymin: int + + +@dataclass_with_extra +class ZeroShotObjectDetectionOutputElement(BaseInferenceType): + """Outputs of inference for the Zero Shot Object Detection task""" + + box: ZeroShotObjectDetectionBoundingBox + """The predicted bounding box. Coordinates are relative to the top left corner of the input + image. + """ + label: str + """A candidate label""" + score: float + """The associated score / probability""" diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/keras_mixin.py b/.venv/lib/python3.13/site-packages/huggingface_hub/keras_mixin.py new file mode 100644 index 0000000000000000000000000000000000000000..e1c7ad503e2f663b1f36da4c2ef5c954fde35606 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/keras_mixin.py @@ -0,0 +1,500 @@ +import collections.abc as collections +import json +import os +import warnings +from functools import wraps +from pathlib import Path +from shutil import copytree +from typing import Any, Dict, List, Optional, Union + +from huggingface_hub import ModelHubMixin, snapshot_download +from huggingface_hub.utils import ( + get_tf_version, + is_graphviz_available, + is_pydot_available, + is_tf_available, + yaml_dump, +) + +from . import constants +from .hf_api import HfApi +from .utils import SoftTemporaryDirectory, logging, validate_hf_hub_args +from .utils._typing import CallableT + + +logger = logging.get_logger(__name__) + +keras = None +if is_tf_available(): + # Depending on which version of TensorFlow is installed, we need to import + # keras from the correct location. + # See https://github.com/tensorflow/tensorflow/releases/tag/v2.16.1. + # Note: saving a keras model only works with Keras<3.0. + try: + import tf_keras as keras # type: ignore + except ImportError: + import tensorflow as tf # type: ignore + + keras = tf.keras + + +def _requires_keras_2_model(fn: CallableT) -> CallableT: + # Wrapper to raise if user tries to save a Keras 3.x model + @wraps(fn) + def _inner(model, *args, **kwargs): + if not hasattr(model, "history"): # hacky way to check if model is Keras 2.x + raise NotImplementedError( + f"Cannot use '{fn.__name__}': Keras 3.x is not supported." + " Please save models manually and upload them using `upload_folder` or `huggingface-cli upload`." + ) + return fn(model, *args, **kwargs) + + return _inner # type: ignore [return-value] + + +def _flatten_dict(dictionary, parent_key=""): + """Flatten a nested dictionary. + Reference: https://stackoverflow.com/a/6027615/10319735 + + Args: + dictionary (`dict`): + The nested dictionary to be flattened. + parent_key (`str`): + The parent key to be prefixed to the children keys. + Necessary for recursing over the nested dictionary. + + Returns: + The flattened dictionary. + """ + items = [] + for key, value in dictionary.items(): + new_key = f"{parent_key}.{key}" if parent_key else key + if isinstance(value, collections.MutableMapping): + items.extend( + _flatten_dict( + value, + new_key, + ).items() + ) + else: + items.append((new_key, value)) + return dict(items) + + +def _create_hyperparameter_table(model): + """Parse hyperparameter dictionary into a markdown table.""" + table = None + if model.optimizer is not None: + optimizer_params = model.optimizer.get_config() + # flatten the configuration + optimizer_params = _flatten_dict(optimizer_params) + optimizer_params["training_precision"] = keras.mixed_precision.global_policy().name + table = "| Hyperparameters | Value |\n| :-- | :-- |\n" + for key, value in optimizer_params.items(): + table += f"| {key} | {value} |\n" + return table + + +def _plot_network(model, save_directory): + keras.utils.plot_model( + model, + to_file=f"{save_directory}/model.png", + show_shapes=False, + show_dtype=False, + show_layer_names=True, + rankdir="TB", + expand_nested=False, + dpi=96, + layer_range=None, + ) + + +def _create_model_card( + model, + repo_dir: Path, + plot_model: bool = True, + metadata: Optional[dict] = None, +): + """ + Creates a model card for the repository. + + Do not overwrite an existing README.md file. + """ + readme_path = repo_dir / "README.md" + if readme_path.exists(): + return + + hyperparameters = _create_hyperparameter_table(model) + if plot_model and is_graphviz_available() and is_pydot_available(): + _plot_network(model, repo_dir) + if metadata is None: + metadata = {} + metadata["library_name"] = "keras" + model_card: str = "---\n" + model_card += yaml_dump(metadata, default_flow_style=False) + model_card += "---\n" + model_card += "\n## Model description\n\nMore information needed\n" + model_card += "\n## Intended uses & limitations\n\nMore information needed\n" + model_card += "\n## Training and evaluation data\n\nMore information needed\n" + if hyperparameters is not None: + model_card += "\n## Training procedure\n" + model_card += "\n### Training hyperparameters\n" + model_card += "\nThe following hyperparameters were used during training:\n\n" + model_card += hyperparameters + model_card += "\n" + if plot_model and os.path.exists(f"{repo_dir}/model.png"): + model_card += "\n ## Model Plot\n" + model_card += "\n
" + model_card += "\nView Model Plot\n" + path_to_plot = "./model.png" + model_card += f"\n![Model Image]({path_to_plot})\n" + model_card += "\n
" + + readme_path.write_text(model_card) + + +@_requires_keras_2_model +def save_pretrained_keras( + model, + save_directory: Union[str, Path], + config: Optional[Dict[str, Any]] = None, + include_optimizer: bool = False, + plot_model: bool = True, + tags: Optional[Union[list, str]] = None, + **model_save_kwargs, +): + """ + Saves a Keras model to save_directory in SavedModel format. Use this if + you're using the Functional or Sequential APIs. + + Args: + model (`Keras.Model`): + The [Keras + model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) + you'd like to save. The model must be compiled and built. + save_directory (`str` or `Path`): + Specify directory in which you want to save the Keras model. + config (`dict`, *optional*): + Configuration object to be saved alongside the model weights. + include_optimizer(`bool`, *optional*, defaults to `False`): + Whether or not to include optimizer in serialization. + plot_model (`bool`, *optional*, defaults to `True`): + Setting this to `True` will plot the model and put it in the model + card. Requires graphviz and pydot to be installed. + tags (Union[`str`,`list`], *optional*): + List of tags that are related to model or string of a single tag. See example tags + [here](https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1). + model_save_kwargs(`dict`, *optional*): + model_save_kwargs will be passed to + [`tf.keras.models.save_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/save_model). + """ + if keras is None: + raise ImportError("Called a Tensorflow-specific function but could not import it.") + + if not model.built: + raise ValueError("Model should be built before trying to save") + + save_directory = Path(save_directory) + save_directory.mkdir(parents=True, exist_ok=True) + + # saving config + if config: + if not isinstance(config, dict): + raise RuntimeError(f"Provided config to save_pretrained_keras should be a dict. Got: '{type(config)}'") + + with (save_directory / constants.CONFIG_NAME).open("w") as f: + json.dump(config, f) + + metadata = {} + if isinstance(tags, list): + metadata["tags"] = tags + elif isinstance(tags, str): + metadata["tags"] = [tags] + + task_name = model_save_kwargs.pop("task_name", None) + if task_name is not None: + warnings.warn( + "`task_name` input argument is deprecated. Pass `tags` instead.", + FutureWarning, + ) + if "tags" in metadata: + metadata["tags"].append(task_name) + else: + metadata["tags"] = [task_name] + + if model.history is not None: + if model.history.history != {}: + path = save_directory / "history.json" + if path.exists(): + warnings.warn( + "`history.json` file already exists, it will be overwritten by the history of this version.", + UserWarning, + ) + with path.open("w", encoding="utf-8") as f: + json.dump(model.history.history, f, indent=2, sort_keys=True) + + _create_model_card(model, save_directory, plot_model, metadata) + keras.models.save_model(model, save_directory, include_optimizer=include_optimizer, **model_save_kwargs) + + +def from_pretrained_keras(*args, **kwargs) -> "KerasModelHubMixin": + r""" + Instantiate a pretrained Keras model from a pre-trained model from the Hub. + The model is expected to be in `SavedModel` format. + + Args: + pretrained_model_name_or_path (`str` or `os.PathLike`): + Can be either: + - A string, the `model id` of a pretrained model hosted inside a + model repo on huggingface.co. Valid model ids can be located + at the root-level, like `bert-base-uncased`, or namespaced + under a user or organization name, like + `dbmdz/bert-base-german-cased`. + - You can add `revision` by appending `@` at the end of model_id + simply like this: `dbmdz/bert-base-german-cased@main` Revision + is the specific model version to use. It can be a branch name, + a tag name, or a commit id, since we use a git-based system + for storing models and other artifacts on huggingface.co, so + `revision` can be any identifier allowed by git. + - A path to a `directory` containing model weights saved using + [`~transformers.PreTrainedModel.save_pretrained`], e.g., + `./my_model_directory/`. + - `None` if you are both providing the configuration and state + dictionary (resp. with keyword arguments `config` and + `state_dict`). + force_download (`bool`, *optional*, defaults to `False`): + Whether to force the (re-)download of the model weights and + configuration files, overriding the cached versions if they exist. + proxies (`Dict[str, str]`, *optional*): + A dictionary of proxy servers to use by protocol or endpoint, e.g., + `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The + proxies are used on each request. + token (`str` or `bool`, *optional*): + The token to use as HTTP bearer authorization for remote files. If + `True`, will use the token generated when running `transformers-cli + login` (stored in `~/.huggingface`). + cache_dir (`Union[str, os.PathLike]`, *optional*): + Path to a directory in which a downloaded pretrained model + configuration should be cached if the standard cache should not be + used. + local_files_only(`bool`, *optional*, defaults to `False`): + Whether to only look at local files (i.e., do not try to download + the model). + model_kwargs (`Dict`, *optional*): + model_kwargs will be passed to the model during initialization + + + + Passing `token=True` is required when you want to use a private + model. + + + """ + return KerasModelHubMixin.from_pretrained(*args, **kwargs) + + +@validate_hf_hub_args +@_requires_keras_2_model +def push_to_hub_keras( + model, + repo_id: str, + *, + config: Optional[dict] = None, + commit_message: str = "Push Keras model using huggingface_hub.", + private: Optional[bool] = None, + api_endpoint: Optional[str] = None, + token: Optional[str] = None, + branch: Optional[str] = None, + create_pr: Optional[bool] = None, + allow_patterns: Optional[Union[List[str], str]] = None, + ignore_patterns: Optional[Union[List[str], str]] = None, + delete_patterns: Optional[Union[List[str], str]] = None, + log_dir: Optional[str] = None, + include_optimizer: bool = False, + tags: Optional[Union[list, str]] = None, + plot_model: bool = True, + **model_save_kwargs, +): + """ + Upload model checkpoint to the Hub. + + Use `allow_patterns` and `ignore_patterns` to precisely filter which files should be pushed to the hub. Use + `delete_patterns` to delete existing remote files in the same commit. See [`upload_folder`] reference for more + details. + + Args: + model (`Keras.Model`): + The [Keras model](`https://www.tensorflow.org/api_docs/python/tf/keras/Model`) you'd like to push to the + Hub. The model must be compiled and built. + repo_id (`str`): + ID of the repository to push to (example: `"username/my-model"`). + commit_message (`str`, *optional*, defaults to "Add Keras model"): + Message to commit while pushing. + private (`bool`, *optional*): + Whether the repository created should be private. + If `None` (default), the repo will be public unless the organization's default is private. + api_endpoint (`str`, *optional*): + The API endpoint to use when pushing the model to the hub. + token (`str`, *optional*): + The token to use as HTTP bearer authorization for remote files. If + not set, will use the token set when logging in with + `huggingface-cli login` (stored in `~/.huggingface`). + branch (`str`, *optional*): + The git branch on which to push the model. This defaults to + the default branch as specified in your repository, which + defaults to `"main"`. + create_pr (`boolean`, *optional*): + Whether or not to create a Pull Request from `branch` with that commit. + Defaults to `False`. + config (`dict`, *optional*): + Configuration object to be saved alongside the model weights. + allow_patterns (`List[str]` or `str`, *optional*): + If provided, only files matching at least one pattern are pushed. + ignore_patterns (`List[str]` or `str`, *optional*): + If provided, files matching any of the patterns are not pushed. + delete_patterns (`List[str]` or `str`, *optional*): + If provided, remote files matching any of the patterns will be deleted from the repo. + log_dir (`str`, *optional*): + TensorBoard logging directory to be pushed. The Hub automatically + hosts and displays a TensorBoard instance if log files are included + in the repository. + include_optimizer (`bool`, *optional*, defaults to `False`): + Whether or not to include optimizer during serialization. + tags (Union[`list`, `str`], *optional*): + List of tags that are related to model or string of a single tag. See example tags + [here](https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1). + plot_model (`bool`, *optional*, defaults to `True`): + Setting this to `True` will plot the model and put it in the model + card. Requires graphviz and pydot to be installed. + model_save_kwargs(`dict`, *optional*): + model_save_kwargs will be passed to + [`tf.keras.models.save_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/save_model). + + Returns: + The url of the commit of your model in the given repository. + """ + api = HfApi(endpoint=api_endpoint) + repo_id = api.create_repo(repo_id=repo_id, token=token, private=private, exist_ok=True).repo_id + + # Push the files to the repo in a single commit + with SoftTemporaryDirectory() as tmp: + saved_path = Path(tmp) / repo_id + save_pretrained_keras( + model, + saved_path, + config=config, + include_optimizer=include_optimizer, + tags=tags, + plot_model=plot_model, + **model_save_kwargs, + ) + + # If `log_dir` provided, delete remote logs and upload new ones + if log_dir is not None: + delete_patterns = ( + [] + if delete_patterns is None + else ( + [delete_patterns] # convert `delete_patterns` to a list + if isinstance(delete_patterns, str) + else delete_patterns + ) + ) + delete_patterns.append("logs/*") + copytree(log_dir, saved_path / "logs") + + return api.upload_folder( + repo_type="model", + repo_id=repo_id, + folder_path=saved_path, + commit_message=commit_message, + token=token, + revision=branch, + create_pr=create_pr, + allow_patterns=allow_patterns, + ignore_patterns=ignore_patterns, + delete_patterns=delete_patterns, + ) + + +class KerasModelHubMixin(ModelHubMixin): + """ + Implementation of [`ModelHubMixin`] to provide model Hub upload/download + capabilities to Keras models. + + + ```python + >>> import tensorflow as tf + >>> from huggingface_hub import KerasModelHubMixin + + + >>> class MyModel(tf.keras.Model, KerasModelHubMixin): + ... def __init__(self, **kwargs): + ... super().__init__() + ... self.config = kwargs.pop("config", None) + ... self.dummy_inputs = ... + ... self.layer = ... + + ... def call(self, *args): + ... return ... + + + >>> # Initialize and compile the model as you normally would + >>> model = MyModel() + >>> model.compile(...) + >>> # Build the graph by training it or passing dummy inputs + >>> _ = model(model.dummy_inputs) + >>> # Save model weights to local directory + >>> model.save_pretrained("my-awesome-model") + >>> # Push model weights to the Hub + >>> model.push_to_hub("my-awesome-model") + >>> # Download and initialize weights from the Hub + >>> model = MyModel.from_pretrained("username/super-cool-model") + ``` + """ + + def _save_pretrained(self, save_directory): + save_pretrained_keras(self, save_directory) + + @classmethod + def _from_pretrained( + cls, + model_id, + revision, + cache_dir, + force_download, + proxies, + resume_download, + local_files_only, + token, + config: Optional[Dict[str, Any]] = None, + **model_kwargs, + ): + """Here we just call [`from_pretrained_keras`] function so both the mixin and + functional APIs stay in sync. + + TODO - Some args above aren't used since we are calling + snapshot_download instead of hf_hub_download. + """ + if keras is None: + raise ImportError("Called a TensorFlow-specific function but could not import it.") + + # Root is either a local filepath matching model_id or a cached snapshot + if not os.path.isdir(model_id): + storage_folder = snapshot_download( + repo_id=model_id, + revision=revision, + cache_dir=cache_dir, + library_name="keras", + library_version=get_tf_version(), + ) + else: + storage_folder = model_id + + # TODO: change this in a future PR. We are not returning a KerasModelHubMixin instance here... + model = keras.models.load_model(storage_folder) + + # For now, we add a new attribute, config, to store the config loaded from the hub/a local dir. + model.config = config + + return model diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/lfs.py b/.venv/lib/python3.13/site-packages/huggingface_hub/lfs.py new file mode 100644 index 0000000000000000000000000000000000000000..c2d4f36829dfe941ce60c8b711c1cc912e8c324a --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/lfs.py @@ -0,0 +1,460 @@ +# coding=utf-8 +# Copyright 2019-present, the HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Git LFS related type definitions and utilities""" + +import inspect +import io +import re +import warnings +from dataclasses import dataclass +from math import ceil +from os.path import getsize +from pathlib import Path +from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, Optional, Tuple, TypedDict +from urllib.parse import unquote + +from huggingface_hub import constants + +from .utils import ( + build_hf_headers, + fix_hf_endpoint_in_url, + get_session, + hf_raise_for_status, + http_backoff, + logging, + tqdm, + validate_hf_hub_args, +) +from .utils._lfs import SliceFileObj +from .utils.sha import sha256, sha_fileobj +from .utils.tqdm import is_tqdm_disabled + + +if TYPE_CHECKING: + from ._commit_api import CommitOperationAdd + +logger = logging.get_logger(__name__) + +OID_REGEX = re.compile(r"^[0-9a-f]{40}$") + +LFS_MULTIPART_UPLOAD_COMMAND = "lfs-multipart-upload" + +LFS_HEADERS = { + "Accept": "application/vnd.git-lfs+json", + "Content-Type": "application/vnd.git-lfs+json", +} + + +@dataclass +class UploadInfo: + """ + Dataclass holding required information to determine whether a blob + should be uploaded to the hub using the LFS protocol or the regular protocol + + Args: + sha256 (`bytes`): + SHA256 hash of the blob + size (`int`): + Size in bytes of the blob + sample (`bytes`): + First 512 bytes of the blob + """ + + sha256: bytes + size: int + sample: bytes + + @classmethod + def from_path(cls, path: str): + size = getsize(path) + with io.open(path, "rb") as file: + sample = file.peek(512)[:512] + sha = sha_fileobj(file) + return cls(size=size, sha256=sha, sample=sample) + + @classmethod + def from_bytes(cls, data: bytes): + sha = sha256(data).digest() + return cls(size=len(data), sample=data[:512], sha256=sha) + + @classmethod + def from_fileobj(cls, fileobj: BinaryIO): + sample = fileobj.read(512) + fileobj.seek(0, io.SEEK_SET) + sha = sha_fileobj(fileobj) + size = fileobj.tell() + fileobj.seek(0, io.SEEK_SET) + return cls(size=size, sha256=sha, sample=sample) + + +@validate_hf_hub_args +def post_lfs_batch_info( + upload_infos: Iterable[UploadInfo], + token: Optional[str], + repo_type: str, + repo_id: str, + revision: Optional[str] = None, + endpoint: Optional[str] = None, + headers: Optional[Dict[str, str]] = None, +) -> Tuple[List[dict], List[dict]]: + """ + Requests the LFS batch endpoint to retrieve upload instructions + + Learn more: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md + + Args: + upload_infos (`Iterable` of `UploadInfo`): + `UploadInfo` for the files that are being uploaded, typically obtained + from `CommitOperationAdd.upload_info` + repo_type (`str`): + Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`. + repo_id (`str`): + A namespace (user or an organization) and a repo name separated + by a `/`. + revision (`str`, *optional*): + The git revision to upload to. + headers (`dict`, *optional*): + Additional headers to include in the request + + Returns: + `LfsBatchInfo`: 2-tuple: + - First element is the list of upload instructions from the server + - Second element is an list of errors, if any + + Raises: + [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) + If an argument is invalid or the server response is malformed. + [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError) + If the server returned an error. + """ + endpoint = endpoint if endpoint is not None else constants.ENDPOINT + url_prefix = "" + if repo_type in constants.REPO_TYPES_URL_PREFIXES: + url_prefix = constants.REPO_TYPES_URL_PREFIXES[repo_type] + batch_url = f"{endpoint}/{url_prefix}{repo_id}.git/info/lfs/objects/batch" + payload: Dict = { + "operation": "upload", + "transfers": ["basic", "multipart"], + "objects": [ + { + "oid": upload.sha256.hex(), + "size": upload.size, + } + for upload in upload_infos + ], + "hash_algo": "sha256", + } + if revision is not None: + payload["ref"] = {"name": unquote(revision)} # revision has been previously 'quoted' + + headers = { + **LFS_HEADERS, + **build_hf_headers(token=token), + **(headers or {}), + } + resp = get_session().post(batch_url, headers=headers, json=payload) + hf_raise_for_status(resp) + batch_info = resp.json() + + objects = batch_info.get("objects", None) + if not isinstance(objects, list): + raise ValueError("Malformed response from server") + + return ( + [_validate_batch_actions(obj) for obj in objects if "error" not in obj], + [_validate_batch_error(obj) for obj in objects if "error" in obj], + ) + + +class PayloadPartT(TypedDict): + partNumber: int + etag: str + + +class CompletionPayloadT(TypedDict): + """Payload that will be sent to the Hub when uploading multi-part.""" + + oid: str + parts: List[PayloadPartT] + + +def lfs_upload( + operation: "CommitOperationAdd", + lfs_batch_action: Dict, + token: Optional[str] = None, + headers: Optional[Dict[str, str]] = None, + endpoint: Optional[str] = None, +) -> None: + """ + Handles uploading a given object to the Hub with the LFS protocol. + + Can be a No-op if the content of the file is already present on the hub large file storage. + + Args: + operation (`CommitOperationAdd`): + The add operation triggering this upload. + lfs_batch_action (`dict`): + Upload instructions from the LFS batch endpoint for this object. See [`~utils.lfs.post_lfs_batch_info`] for + more details. + headers (`dict`, *optional*): + Headers to include in the request, including authentication and user agent headers. + + Raises: + [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError) + If `lfs_batch_action` is improperly formatted + [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError) + If the upload resulted in an error + """ + # 0. If LFS file is already present, skip upload + _validate_batch_actions(lfs_batch_action) + actions = lfs_batch_action.get("actions") + if actions is None: + # The file was already uploaded + logger.debug(f"Content of file {operation.path_in_repo} is already present upstream - skipping upload") + return + + # 1. Validate server response (check required keys in dict) + upload_action = lfs_batch_action["actions"]["upload"] + _validate_lfs_action(upload_action) + verify_action = lfs_batch_action["actions"].get("verify") + if verify_action is not None: + _validate_lfs_action(verify_action) + + # 2. Upload file (either single part or multi-part) + header = upload_action.get("header", {}) + chunk_size = header.get("chunk_size") + upload_url = fix_hf_endpoint_in_url(upload_action["href"], endpoint=endpoint) + if chunk_size is not None: + try: + chunk_size = int(chunk_size) + except (ValueError, TypeError): + raise ValueError( + f"Malformed response from LFS batch endpoint: `chunk_size` should be an integer. Got '{chunk_size}'." + ) + _upload_multi_part(operation=operation, header=header, chunk_size=chunk_size, upload_url=upload_url) + else: + _upload_single_part(operation=operation, upload_url=upload_url) + + # 3. Verify upload went well + if verify_action is not None: + _validate_lfs_action(verify_action) + verify_url = fix_hf_endpoint_in_url(verify_action["href"], endpoint) + verify_resp = get_session().post( + verify_url, + headers=build_hf_headers(token=token, headers=headers), + json={"oid": operation.upload_info.sha256.hex(), "size": operation.upload_info.size}, + ) + hf_raise_for_status(verify_resp) + logger.debug(f"{operation.path_in_repo}: Upload successful") + + +def _validate_lfs_action(lfs_action: dict): + """validates response from the LFS batch endpoint""" + if not ( + isinstance(lfs_action.get("href"), str) + and (lfs_action.get("header") is None or isinstance(lfs_action.get("header"), dict)) + ): + raise ValueError("lfs_action is improperly formatted") + return lfs_action + + +def _validate_batch_actions(lfs_batch_actions: dict): + """validates response from the LFS batch endpoint""" + if not (isinstance(lfs_batch_actions.get("oid"), str) and isinstance(lfs_batch_actions.get("size"), int)): + raise ValueError("lfs_batch_actions is improperly formatted") + + upload_action = lfs_batch_actions.get("actions", {}).get("upload") + verify_action = lfs_batch_actions.get("actions", {}).get("verify") + if upload_action is not None: + _validate_lfs_action(upload_action) + if verify_action is not None: + _validate_lfs_action(verify_action) + return lfs_batch_actions + + +def _validate_batch_error(lfs_batch_error: dict): + """validates response from the LFS batch endpoint""" + if not (isinstance(lfs_batch_error.get("oid"), str) and isinstance(lfs_batch_error.get("size"), int)): + raise ValueError("lfs_batch_error is improperly formatted") + error_info = lfs_batch_error.get("error") + if not ( + isinstance(error_info, dict) + and isinstance(error_info.get("message"), str) + and isinstance(error_info.get("code"), int) + ): + raise ValueError("lfs_batch_error is improperly formatted") + return lfs_batch_error + + +def _upload_single_part(operation: "CommitOperationAdd", upload_url: str) -> None: + """ + Uploads `fileobj` as a single PUT HTTP request (basic LFS transfer protocol) + + Args: + upload_url (`str`): + The URL to PUT the file to. + fileobj: + The file-like object holding the data to upload. + + Returns: `requests.Response` + + Raises: + [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError) + If the upload resulted in an error. + """ + with operation.as_file(with_tqdm=True) as fileobj: + # S3 might raise a transient 500 error -> let's retry if that happens + response = http_backoff("PUT", upload_url, data=fileobj, retry_on_status_codes=(500, 502, 503, 504)) + hf_raise_for_status(response) + + +def _upload_multi_part(operation: "CommitOperationAdd", header: Dict, chunk_size: int, upload_url: str) -> None: + """ + Uploads file using HF multipart LFS transfer protocol. + """ + # 1. Get upload URLs for each part + sorted_parts_urls = _get_sorted_parts_urls(header=header, upload_info=operation.upload_info, chunk_size=chunk_size) + + # 2. Upload parts (either with hf_transfer or in pure Python) + use_hf_transfer = constants.HF_HUB_ENABLE_HF_TRANSFER + if ( + constants.HF_HUB_ENABLE_HF_TRANSFER + and not isinstance(operation.path_or_fileobj, str) + and not isinstance(operation.path_or_fileobj, Path) + ): + warnings.warn( + "hf_transfer is enabled but does not support uploading from bytes or BinaryIO, falling back to regular" + " upload" + ) + use_hf_transfer = False + + response_headers = ( + _upload_parts_hf_transfer(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size) + if use_hf_transfer + else _upload_parts_iteratively(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size) + ) + + # 3. Send completion request + completion_res = get_session().post( + upload_url, + json=_get_completion_payload(response_headers, operation.upload_info.sha256.hex()), + headers=LFS_HEADERS, + ) + hf_raise_for_status(completion_res) + + +def _get_sorted_parts_urls(header: Dict, upload_info: UploadInfo, chunk_size: int) -> List[str]: + sorted_part_upload_urls = [ + upload_url + for _, upload_url in sorted( + [ + (int(part_num, 10), upload_url) + for part_num, upload_url in header.items() + if part_num.isdigit() and len(part_num) > 0 + ], + key=lambda t: t[0], + ) + ] + num_parts = len(sorted_part_upload_urls) + if num_parts != ceil(upload_info.size / chunk_size): + raise ValueError("Invalid server response to upload large LFS file") + return sorted_part_upload_urls + + +def _get_completion_payload(response_headers: List[Dict], oid: str) -> CompletionPayloadT: + parts: List[PayloadPartT] = [] + for part_number, header in enumerate(response_headers): + etag = header.get("etag") + if etag is None or etag == "": + raise ValueError(f"Invalid etag (`{etag}`) returned for part {part_number + 1}") + parts.append( + { + "partNumber": part_number + 1, + "etag": etag, + } + ) + return {"oid": oid, "parts": parts} + + +def _upload_parts_iteratively( + operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int +) -> List[Dict]: + headers = [] + with operation.as_file(with_tqdm=True) as fileobj: + for part_idx, part_upload_url in enumerate(sorted_parts_urls): + with SliceFileObj( + fileobj, + seek_from=chunk_size * part_idx, + read_limit=chunk_size, + ) as fileobj_slice: + # S3 might raise a transient 500 error -> let's retry if that happens + part_upload_res = http_backoff( + "PUT", part_upload_url, data=fileobj_slice, retry_on_status_codes=(500, 502, 503, 504) + ) + hf_raise_for_status(part_upload_res) + headers.append(part_upload_res.headers) + return headers # type: ignore + + +def _upload_parts_hf_transfer( + operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int +) -> List[Dict]: + # Upload file using an external Rust-based package. Upload is faster but support less features (no progress bars). + try: + from hf_transfer import multipart_upload + except ImportError: + raise ValueError( + "Fast uploading using 'hf_transfer' is enabled (HF_HUB_ENABLE_HF_TRANSFER=1) but 'hf_transfer' package is" + " not available in your environment. Try `pip install hf_transfer`." + ) + + supports_callback = "callback" in inspect.signature(multipart_upload).parameters + if not supports_callback: + warnings.warn( + "You are using an outdated version of `hf_transfer`. Consider upgrading to latest version to enable progress bars using `pip install -U hf_transfer`." + ) + + total = operation.upload_info.size + desc = operation.path_in_repo + if len(desc) > 40: + desc = f"(…){desc[-40:]}" + + with tqdm( + unit="B", + unit_scale=True, + total=total, + initial=0, + desc=desc, + disable=is_tqdm_disabled(logger.getEffectiveLevel()), + name="huggingface_hub.lfs_upload", + ) as progress: + try: + output = multipart_upload( + file_path=operation.path_or_fileobj, + parts_urls=sorted_parts_urls, + chunk_size=chunk_size, + max_files=128, + parallel_failures=127, # could be removed + max_retries=5, + **({"callback": progress.update} if supports_callback else {}), + ) + except Exception as e: + raise RuntimeError( + "An error occurred while uploading using `hf_transfer`. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for" + " better error handling." + ) from e + if not supports_callback: + progress.update(total) + return output diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/repocard_data.py b/.venv/lib/python3.13/site-packages/huggingface_hub/repocard_data.py new file mode 100644 index 0000000000000000000000000000000000000000..62215f2274e482d4ed69a1d6deeafdf34fc5a6a4 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/huggingface_hub/repocard_data.py @@ -0,0 +1,770 @@ +import copy +from collections import defaultdict +from dataclasses import dataclass +from typing import Any, Dict, List, Optional, Tuple, Union + +from huggingface_hub.utils import logging, yaml_dump + + +logger = logging.get_logger(__name__) + + +@dataclass +class EvalResult: + """ + Flattened representation of individual evaluation results found in model-index of Model Cards. + + For more information on the model-index spec, see https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1. + + Args: + task_type (`str`): + The task identifier. Example: "image-classification". + dataset_type (`str`): + The dataset identifier. Example: "common_voice". Use dataset id from https://hf.co/datasets. + dataset_name (`str`): + A pretty name for the dataset. Example: "Common Voice (French)". + metric_type (`str`): + The metric identifier. Example: "wer". Use metric id from https://hf.co/metrics. + metric_value (`Any`): + The metric value. Example: 0.9 or "20.0 ± 1.2". + task_name (`str`, *optional*): + A pretty name for the task. Example: "Speech Recognition". + dataset_config (`str`, *optional*): + The name of the dataset configuration used in `load_dataset()`. + Example: fr in `load_dataset("common_voice", "fr")`. See the `datasets` docs for more info: + https://hf.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name + dataset_split (`str`, *optional*): + The split used in `load_dataset()`. Example: "test". + dataset_revision (`str`, *optional*): + The revision (AKA Git Sha) of the dataset used in `load_dataset()`. + Example: 5503434ddd753f426f4b38109466949a1217c2bb + dataset_args (`Dict[str, Any]`, *optional*): + The arguments passed during `Metric.compute()`. Example for `bleu`: `{"max_order": 4}` + metric_name (`str`, *optional*): + A pretty name for the metric. Example: "Test WER". + metric_config (`str`, *optional*): + The name of the metric configuration used in `load_metric()`. + Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`. + See the `datasets` docs for more info: https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations + metric_args (`Dict[str, Any]`, *optional*): + The arguments passed during `Metric.compute()`. Example for `bleu`: max_order: 4 + verified (`bool`, *optional*): + Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set. + verify_token (`str`, *optional*): + A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. + source_name (`str`, *optional*): + The name of the source of the evaluation result. Example: "Open LLM Leaderboard". + source_url (`str`, *optional*): + The URL of the source of the evaluation result. Example: "https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard". + """ + + # Required + + # The task identifier + # Example: automatic-speech-recognition + task_type: str + + # The dataset identifier + # Example: common_voice. Use dataset id from https://hf.co/datasets + dataset_type: str + + # A pretty name for the dataset. + # Example: Common Voice (French) + dataset_name: str + + # The metric identifier + # Example: wer. Use metric id from https://hf.co/metrics + metric_type: str + + # Value of the metric. + # Example: 20.0 or "20.0 ± 1.2" + metric_value: Any + + # Optional + + # A pretty name for the task. + # Example: Speech Recognition + task_name: Optional[str] = None + + # The name of the dataset configuration used in `load_dataset()`. + # Example: fr in `load_dataset("common_voice", "fr")`. + # See the `datasets` docs for more info: + # https://huggingface.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name + dataset_config: Optional[str] = None + + # The split used in `load_dataset()`. + # Example: test + dataset_split: Optional[str] = None + + # The revision (AKA Git Sha) of the dataset used in `load_dataset()`. + # Example: 5503434ddd753f426f4b38109466949a1217c2bb + dataset_revision: Optional[str] = None + + # The arguments passed during `Metric.compute()`. + # Example for `bleu`: max_order: 4 + dataset_args: Optional[Dict[str, Any]] = None + + # A pretty name for the metric. + # Example: Test WER + metric_name: Optional[str] = None + + # The name of the metric configuration used in `load_metric()`. + # Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`. + # See the `datasets` docs for more info: https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations + metric_config: Optional[str] = None + + # The arguments passed during `Metric.compute()`. + # Example for `bleu`: max_order: 4 + metric_args: Optional[Dict[str, Any]] = None + + # Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set. + verified: Optional[bool] = None + + # A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. + verify_token: Optional[str] = None + + # The name of the source of the evaluation result. + # Example: Open LLM Leaderboard + source_name: Optional[str] = None + + # The URL of the source of the evaluation result. + # Example: https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard + source_url: Optional[str] = None + + @property + def unique_identifier(self) -> tuple: + """Returns a tuple that uniquely identifies this evaluation.""" + return ( + self.task_type, + self.dataset_type, + self.dataset_config, + self.dataset_split, + self.dataset_revision, + ) + + def is_equal_except_value(self, other: "EvalResult") -> bool: + """ + Return True if `self` and `other` describe exactly the same metric but with a + different value. + """ + for key, _ in self.__dict__.items(): + if key == "metric_value": + continue + # For metrics computed by Hugging Face's evaluation service, `verify_token` is derived from `metric_value`, + # so we exclude it here in the comparison. + if key != "verify_token" and getattr(self, key) != getattr(other, key): + return False + return True + + def __post_init__(self) -> None: + if self.source_name is not None and self.source_url is None: + raise ValueError("If `source_name` is provided, `source_url` must also be provided.") + + +@dataclass +class CardData: + """Structure containing metadata from a RepoCard. + + [`CardData`] is the parent class of [`ModelCardData`] and [`DatasetCardData`]. + + Metadata can be exported as a dictionary or YAML. Export can be customized to alter the representation of the data + (example: flatten evaluation results). `CardData` behaves as a dictionary (can get, pop, set values) but do not + inherit from `dict` to allow this export step. + """ + + def __init__(self, ignore_metadata_errors: bool = False, **kwargs): + self.__dict__.update(kwargs) + + def to_dict(self): + """Converts CardData to a dict. + + Returns: + `dict`: CardData represented as a dictionary ready to be dumped to a YAML + block for inclusion in a README.md file. + """ + + data_dict = copy.deepcopy(self.__dict__) + self._to_dict(data_dict) + return {key: value for key, value in data_dict.items() if value is not None} + + def _to_dict(self, data_dict): + """Use this method in child classes to alter the dict representation of the data. Alter the dict in-place. + + Args: + data_dict (`dict`): The raw dict representation of the card data. + """ + pass + + def to_yaml(self, line_break=None, original_order: Optional[List[str]] = None) -> str: + """Dumps CardData to a YAML block for inclusion in a README.md file. + + Args: + line_break (str, *optional*): + The line break to use when dumping to yaml. + + Returns: + `str`: CardData represented as a YAML block. + """ + if original_order: + self.__dict__ = { + k: self.__dict__[k] + for k in original_order + list(set(self.__dict__.keys()) - set(original_order)) + if k in self.__dict__ + } + return yaml_dump(self.to_dict(), sort_keys=False, line_break=line_break).strip() + + def __repr__(self): + return repr(self.__dict__) + + def __str__(self): + return self.to_yaml() + + def get(self, key: str, default: Any = None) -> Any: + """Get value for a given metadata key.""" + value = self.__dict__.get(key) + return default if value is None else value + + def pop(self, key: str, default: Any = None) -> Any: + """Pop value for a given metadata key.""" + return self.__dict__.pop(key, default) + + def __getitem__(self, key: str) -> Any: + """Get value for a given metadata key.""" + return self.__dict__[key] + + def __setitem__(self, key: str, value: Any) -> None: + """Set value for a given metadata key.""" + self.__dict__[key] = value + + def __contains__(self, key: str) -> bool: + """Check if a given metadata key is set.""" + return key in self.__dict__ + + def __len__(self) -> int: + """Return the number of metadata keys set.""" + return len(self.__dict__) + + +def _validate_eval_results( + eval_results: Optional[Union[EvalResult, List[EvalResult]]], + model_name: Optional[str], +) -> List[EvalResult]: + if eval_results is None: + return [] + if isinstance(eval_results, EvalResult): + eval_results = [eval_results] + if not isinstance(eval_results, list) or not all(isinstance(r, EvalResult) for r in eval_results): + raise ValueError( + f"`eval_results` should be of type `EvalResult` or a list of `EvalResult`, got {type(eval_results)}." + ) + if model_name is None: + raise ValueError("Passing `eval_results` requires `model_name` to be set.") + return eval_results + + +class ModelCardData(CardData): + """Model Card Metadata that is used by Hugging Face Hub when included at the top of your README.md + + Args: + base_model (`str` or `List[str]`, *optional*): + The identifier of the base model from which the model derives. This is applicable for example if your model is a + fine-tune or adapter of an existing model. The value must be the ID of a model on the Hub (or a list of IDs + if your model derives from multiple models). Defaults to None. + datasets (`Union[str, List[str]]`, *optional*): + Dataset or list of datasets that were used to train this model. Should be a dataset ID + found on https://hf.co/datasets. Defaults to None. + eval_results (`Union[List[EvalResult], EvalResult]`, *optional*): + List of `huggingface_hub.EvalResult` that define evaluation results of the model. If provided, + `model_name` is used to as a name on PapersWithCode's leaderboards. Defaults to `None`. + language (`Union[str, List[str]]`, *optional*): + Language of model's training data or metadata. It must be an ISO 639-1, 639-2 or + 639-3 code (two/three letters), or a special value like "code", "multilingual". Defaults to `None`. + library_name (`str`, *optional*): + Name of library used by this model. Example: keras or any library from + https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/model-libraries.ts. + Defaults to None. + license (`str`, *optional*): + License of this model. Example: apache-2.0 or any license from + https://huggingface.co/docs/hub/repositories-licenses. Defaults to None. + license_name (`str`, *optional*): + Name of the license of this model. Defaults to None. To be used in conjunction with `license_link`. + Common licenses (Apache-2.0, MIT, CC-BY-SA-4.0) do not need a name. In that case, use `license` instead. + license_link (`str`, *optional*): + Link to the license of this model. Defaults to None. To be used in conjunction with `license_name`. + Common licenses (Apache-2.0, MIT, CC-BY-SA-4.0) do not need a link. In that case, use `license` instead. + metrics (`List[str]`, *optional*): + List of metrics used to evaluate this model. Should be a metric name that can be found + at https://hf.co/metrics. Example: 'accuracy'. Defaults to None. + model_name (`str`, *optional*): + A name for this model. It is used along with + `eval_results` to construct the `model-index` within the card's metadata. The name + you supply here is what will be used on PapersWithCode's leaderboards. If None is provided + then the repo name is used as a default. Defaults to None. + pipeline_tag (`str`, *optional*): + The pipeline tag associated with the model. Example: "text-classification". + tags (`List[str]`, *optional*): + List of tags to add to your model that can be used when filtering on the Hugging + Face Hub. Defaults to None. + ignore_metadata_errors (`str`): + If True, errors while parsing the metadata section will be ignored. Some information might be lost during + the process. Use it at your own risk. + kwargs (`dict`, *optional*): + Additional metadata that will be added to the model card. Defaults to None. + + Example: + ```python + >>> from huggingface_hub import ModelCardData + >>> card_data = ModelCardData( + ... language="en", + ... license="mit", + ... library_name="timm", + ... tags=['image-classification', 'resnet'], + ... ) + >>> card_data.to_dict() + {'language': 'en', 'license': 'mit', 'library_name': 'timm', 'tags': ['image-classification', 'resnet']} + + ``` + """ + + def __init__( + self, + *, + base_model: Optional[Union[str, List[str]]] = None, + datasets: Optional[Union[str, List[str]]] = None, + eval_results: Optional[List[EvalResult]] = None, + language: Optional[Union[str, List[str]]] = None, + library_name: Optional[str] = None, + license: Optional[str] = None, + license_name: Optional[str] = None, + license_link: Optional[str] = None, + metrics: Optional[List[str]] = None, + model_name: Optional[str] = None, + pipeline_tag: Optional[str] = None, + tags: Optional[List[str]] = None, + ignore_metadata_errors: bool = False, + **kwargs, + ): + self.base_model = base_model + self.datasets = datasets + self.eval_results = eval_results + self.language = language + self.library_name = library_name + self.license = license + self.license_name = license_name + self.license_link = license_link + self.metrics = metrics + self.model_name = model_name + self.pipeline_tag = pipeline_tag + self.tags = _to_unique_list(tags) + + model_index = kwargs.pop("model-index", None) + if model_index: + try: + model_name, eval_results = model_index_to_eval_results(model_index) + self.model_name = model_name + self.eval_results = eval_results + except (KeyError, TypeError) as error: + if ignore_metadata_errors: + logger.warning("Invalid model-index. Not loading eval results into CardData.") + else: + raise ValueError( + f"Invalid `model_index` in metadata cannot be parsed: {error.__class__} {error}. Pass" + " `ignore_metadata_errors=True` to ignore this error while loading a Model Card. Warning:" + " some information will be lost. Use it at your own risk." + ) + + super().__init__(**kwargs) + + if self.eval_results: + try: + self.eval_results = _validate_eval_results(self.eval_results, self.model_name) + except Exception as e: + if ignore_metadata_errors: + logger.warning(f"Failed to validate eval_results: {e}. Not loading eval results into CardData.") + else: + raise ValueError(f"Failed to validate eval_results: {e}") from e + + def _to_dict(self, data_dict): + """Format the internal data dict. In this case, we convert eval results to a valid model index""" + if self.eval_results is not None: + data_dict["model-index"] = eval_results_to_model_index(self.model_name, self.eval_results) + del data_dict["eval_results"], data_dict["model_name"] + + +class DatasetCardData(CardData): + """Dataset Card Metadata that is used by Hugging Face Hub when included at the top of your README.md + + Args: + language (`List[str]`, *optional*): + Language of dataset's data or metadata. It must be an ISO 639-1, 639-2 or + 639-3 code (two/three letters), or a special value like "code", "multilingual". + license (`Union[str, List[str]]`, *optional*): + License(s) of this dataset. Example: apache-2.0 or any license from + https://huggingface.co/docs/hub/repositories-licenses. + annotations_creators (`Union[str, List[str]]`, *optional*): + How the annotations for the dataset were created. + Options are: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'no-annotation', 'other'. + language_creators (`Union[str, List[str]]`, *optional*): + How the text-based data in the dataset was created. + Options are: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'other' + multilinguality (`Union[str, List[str]]`, *optional*): + Whether the dataset is multilingual. + Options are: 'monolingual', 'multilingual', 'translation', 'other'. + size_categories (`Union[str, List[str]]`, *optional*): + The number of examples in the dataset. Options are: 'n<1K', '1K1T', and 'other'. + source_datasets (`List[str]]`, *optional*): + Indicates whether the dataset is an original dataset or extended from another existing dataset. + Options are: 'original' and 'extended'. + task_categories (`Union[str, List[str]]`, *optional*): + What categories of task does the dataset support? + task_ids (`Union[str, List[str]]`, *optional*): + What specific tasks does the dataset support? + paperswithcode_id (`str`, *optional*): + ID of the dataset on PapersWithCode. + pretty_name (`str`, *optional*): + A more human-readable name for the dataset. (ex. "Cats vs. Dogs") + train_eval_index (`Dict`, *optional*): + A dictionary that describes the necessary spec for doing evaluation on the Hub. + If not provided, it will be gathered from the 'train-eval-index' key of the kwargs. + config_names (`Union[str, List[str]]`, *optional*): + A list of the available dataset configs for the dataset. + """ + + def __init__( + self, + *, + language: Optional[Union[str, List[str]]] = None, + license: Optional[Union[str, List[str]]] = None, + annotations_creators: Optional[Union[str, List[str]]] = None, + language_creators: Optional[Union[str, List[str]]] = None, + multilinguality: Optional[Union[str, List[str]]] = None, + size_categories: Optional[Union[str, List[str]]] = None, + source_datasets: Optional[List[str]] = None, + task_categories: Optional[Union[str, List[str]]] = None, + task_ids: Optional[Union[str, List[str]]] = None, + paperswithcode_id: Optional[str] = None, + pretty_name: Optional[str] = None, + train_eval_index: Optional[Dict] = None, + config_names: Optional[Union[str, List[str]]] = None, + ignore_metadata_errors: bool = False, + **kwargs, + ): + self.annotations_creators = annotations_creators + self.language_creators = language_creators + self.language = language + self.license = license + self.multilinguality = multilinguality + self.size_categories = size_categories + self.source_datasets = source_datasets + self.task_categories = task_categories + self.task_ids = task_ids + self.paperswithcode_id = paperswithcode_id + self.pretty_name = pretty_name + self.config_names = config_names + + # TODO - maybe handle this similarly to EvalResult? + self.train_eval_index = train_eval_index or kwargs.pop("train-eval-index", None) + super().__init__(**kwargs) + + def _to_dict(self, data_dict): + data_dict["train-eval-index"] = data_dict.pop("train_eval_index") + + +class SpaceCardData(CardData): + """Space Card Metadata that is used by Hugging Face Hub when included at the top of your README.md + + To get an exhaustive reference of Spaces configuration, please visit https://huggingface.co/docs/hub/spaces-config-reference#spaces-configuration-reference. + + Args: + title (`str`, *optional*) + Title of the Space. + sdk (`str`, *optional*) + SDK of the Space (one of `gradio`, `streamlit`, `docker`, or `static`). + sdk_version (`str`, *optional*) + Version of the used SDK (if Gradio/Streamlit sdk). + python_version (`str`, *optional*) + Python version used in the Space (if Gradio/Streamlit sdk). + app_file (`str`, *optional*) + Path to your main application file (which contains either gradio or streamlit Python code, or static html code). + Path is relative to the root of the repository. + app_port (`str`, *optional*) + Port on which your application is running. Used only if sdk is `docker`. + license (`str`, *optional*) + License of this model. Example: apache-2.0 or any license from + https://huggingface.co/docs/hub/repositories-licenses. + duplicated_from (`str`, *optional*) + ID of the original Space if this is a duplicated Space. + models (List[`str`], *optional*) + List of models related to this Space. Should be a dataset ID found on https://hf.co/models. + datasets (`List[str]`, *optional*) + List of datasets related to this Space. Should be a dataset ID found on https://hf.co/datasets. + tags (`List[str]`, *optional*) + List of tags to add to your Space that can be used when filtering on the Hub. + ignore_metadata_errors (`str`): + If True, errors while parsing the metadata section will be ignored. Some information might be lost during + the process. Use it at your own risk. + kwargs (`dict`, *optional*): + Additional metadata that will be added to the space card. + + Example: + ```python + >>> from huggingface_hub import SpaceCardData + >>> card_data = SpaceCardData( + ... title="Dreambooth Training", + ... license="mit", + ... sdk="gradio", + ... duplicated_from="multimodalart/dreambooth-training" + ... ) + >>> card_data.to_dict() + {'title': 'Dreambooth Training', 'sdk': 'gradio', 'license': 'mit', 'duplicated_from': 'multimodalart/dreambooth-training'} + ``` + """ + + def __init__( + self, + *, + title: Optional[str] = None, + sdk: Optional[str] = None, + sdk_version: Optional[str] = None, + python_version: Optional[str] = None, + app_file: Optional[str] = None, + app_port: Optional[int] = None, + license: Optional[str] = None, + duplicated_from: Optional[str] = None, + models: Optional[List[str]] = None, + datasets: Optional[List[str]] = None, + tags: Optional[List[str]] = None, + ignore_metadata_errors: bool = False, + **kwargs, + ): + self.title = title + self.sdk = sdk + self.sdk_version = sdk_version + self.python_version = python_version + self.app_file = app_file + self.app_port = app_port + self.license = license + self.duplicated_from = duplicated_from + self.models = models + self.datasets = datasets + self.tags = _to_unique_list(tags) + super().__init__(**kwargs) + + +def model_index_to_eval_results(model_index: List[Dict[str, Any]]) -> Tuple[str, List[EvalResult]]: + """Takes in a model index and returns the model name and a list of `huggingface_hub.EvalResult` objects. + + A detailed spec of the model index can be found here: + https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1 + + Args: + model_index (`List[Dict[str, Any]]`): + A model index data structure, likely coming from a README.md file on the + Hugging Face Hub. + + Returns: + model_name (`str`): + The name of the model as found in the model index. This is used as the + identifier for the model on leaderboards like PapersWithCode. + eval_results (`List[EvalResult]`): + A list of `huggingface_hub.EvalResult` objects containing the metrics + reported in the provided model_index. + + Example: + ```python + >>> from huggingface_hub.repocard_data import model_index_to_eval_results + >>> # Define a minimal model index + >>> model_index = [ + ... { + ... "name": "my-cool-model", + ... "results": [ + ... { + ... "task": { + ... "type": "image-classification" + ... }, + ... "dataset": { + ... "type": "beans", + ... "name": "Beans" + ... }, + ... "metrics": [ + ... { + ... "type": "accuracy", + ... "value": 0.9 + ... } + ... ] + ... } + ... ] + ... } + ... ] + >>> model_name, eval_results = model_index_to_eval_results(model_index) + >>> model_name + 'my-cool-model' + >>> eval_results[0].task_type + 'image-classification' + >>> eval_results[0].metric_type + 'accuracy' + + ``` + """ + + eval_results = [] + for elem in model_index: + name = elem["name"] + results = elem["results"] + for result in results: + task_type = result["task"]["type"] + task_name = result["task"].get("name") + dataset_type = result["dataset"]["type"] + dataset_name = result["dataset"]["name"] + dataset_config = result["dataset"].get("config") + dataset_split = result["dataset"].get("split") + dataset_revision = result["dataset"].get("revision") + dataset_args = result["dataset"].get("args") + source_name = result.get("source", {}).get("name") + source_url = result.get("source", {}).get("url") + + for metric in result["metrics"]: + metric_type = metric["type"] + metric_value = metric["value"] + metric_name = metric.get("name") + metric_args = metric.get("args") + metric_config = metric.get("config") + verified = metric.get("verified") + verify_token = metric.get("verifyToken") + + eval_result = EvalResult( + task_type=task_type, # Required + dataset_type=dataset_type, # Required + dataset_name=dataset_name, # Required + metric_type=metric_type, # Required + metric_value=metric_value, # Required + task_name=task_name, + dataset_config=dataset_config, + dataset_split=dataset_split, + dataset_revision=dataset_revision, + dataset_args=dataset_args, + metric_name=metric_name, + metric_args=metric_args, + metric_config=metric_config, + verified=verified, + verify_token=verify_token, + source_name=source_name, + source_url=source_url, + ) + eval_results.append(eval_result) + return name, eval_results + + +def _remove_none(obj): + """ + Recursively remove `None` values from a dict. Borrowed from: https://stackoverflow.com/a/20558778 + """ + if isinstance(obj, (list, tuple, set)): + return type(obj)(_remove_none(x) for x in obj if x is not None) + elif isinstance(obj, dict): + return type(obj)((_remove_none(k), _remove_none(v)) for k, v in obj.items() if k is not None and v is not None) + else: + return obj + + +def eval_results_to_model_index(model_name: str, eval_results: List[EvalResult]) -> List[Dict[str, Any]]: + """Takes in given model name and list of `huggingface_hub.EvalResult` and returns a + valid model-index that will be compatible with the format expected by the + Hugging Face Hub. + + Args: + model_name (`str`): + Name of the model (ex. "my-cool-model"). This is used as the identifier + for the model on leaderboards like PapersWithCode. + eval_results (`List[EvalResult]`): + List of `huggingface_hub.EvalResult` objects containing the metrics to be + reported in the model-index. + + Returns: + model_index (`List[Dict[str, Any]]`): The eval_results converted to a model-index. + + Example: + ```python + >>> from huggingface_hub.repocard_data import eval_results_to_model_index, EvalResult + >>> # Define minimal eval_results + >>> eval_results = [ + ... EvalResult( + ... task_type="image-classification", # Required + ... dataset_type="beans", # Required + ... dataset_name="Beans", # Required + ... metric_type="accuracy", # Required + ... metric_value=0.9, # Required + ... ) + ... ] + >>> eval_results_to_model_index("my-cool-model", eval_results) + [{'name': 'my-cool-model', 'results': [{'task': {'type': 'image-classification'}, 'dataset': {'name': 'Beans', 'type': 'beans'}, 'metrics': [{'type': 'accuracy', 'value': 0.9}]}]}] + + ``` + """ + + # Metrics are reported on a unique task-and-dataset basis. + # Here, we make a map of those pairs and the associated EvalResults. + task_and_ds_types_map: Dict[Any, List[EvalResult]] = defaultdict(list) + for eval_result in eval_results: + task_and_ds_types_map[eval_result.unique_identifier].append(eval_result) + + # Use the map from above to generate the model index data. + model_index_data = [] + for results in task_and_ds_types_map.values(): + # All items from `results` share same metadata + sample_result = results[0] + data = { + "task": { + "type": sample_result.task_type, + "name": sample_result.task_name, + }, + "dataset": { + "name": sample_result.dataset_name, + "type": sample_result.dataset_type, + "config": sample_result.dataset_config, + "split": sample_result.dataset_split, + "revision": sample_result.dataset_revision, + "args": sample_result.dataset_args, + }, + "metrics": [ + { + "type": result.metric_type, + "value": result.metric_value, + "name": result.metric_name, + "config": result.metric_config, + "args": result.metric_args, + "verified": result.verified, + "verifyToken": result.verify_token, + } + for result in results + ], + } + if sample_result.source_url is not None: + source = { + "url": sample_result.source_url, + } + if sample_result.source_name is not None: + source["name"] = sample_result.source_name + data["source"] = source + model_index_data.append(data) + + # TODO - Check if there cases where this list is longer than one? + # Finally, the model index itself is list of dicts. + model_index = [ + { + "name": model_name, + "results": model_index_data, + } + ] + return _remove_none(model_index) + + +def _to_unique_list(tags: Optional[List[str]]) -> Optional[List[str]]: + if tags is None: + return tags + unique_tags = [] # make tags unique + keep order explicitly + for tag in tags: + if tag not in unique_tags: + unique_tags.append(tag) + return unique_tags diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d07f9d1edf177d703333e92d1aed4561dfd491a4 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c7db404865148e569561644d6bdbdea9a5ff57b Binary files /dev/null and b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_lfs.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_lfs.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5ec00a9c00fc32a74c527a3ea64b0fce105250f Binary files /dev/null and b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_lfs.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b46f8682ce9230568dc631f6188f03418f639c29 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-313.pyc b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..554d2e335c1f8cb700230d8297c93c6f04338884 Binary files /dev/null and b/.venv/lib/python3.13/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-313.pyc differ diff --git a/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/INSTALLER b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a --- /dev/null +++ b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/INSTALLER @@ -0,0 +1 @@ +uv \ No newline at end of file diff --git a/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/LICENSE.md b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..19b6b45242c16a1025465309eec2ca5009319de3 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/LICENSE.md @@ -0,0 +1,31 @@ +BSD 3-Clause License + +Copyright (c) 2013-2024, 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.13/site-packages/idna-3.10.dist-info/METADATA b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..c42623e9423c23b555d9d352bc5dab518ede02c2 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/METADATA @@ -0,0 +1,250 @@ +Metadata-Version: 2.1 +Name: idna +Version: 3.10 +Summary: Internationalized Domain Names in Applications (IDNA) +Author-email: Kim Davies +Requires-Python: >=3.6 +Description-Content-Type: text/x-rst +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: System Administrators +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +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 :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Internet :: Name Service (DNS) +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Utilities +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 the Internationalized Domain Names in +Applications (IDNA) protocol as specified in `RFC 5891 +`_. This is the latest version of +the protocol and is sometimes referred to as “IDNA 2008”. + +This library also provides support for Unicode Technical +Standard 46, `Unicode IDNA Compatibility Processing +`_. + +This acts as a suitable replacement for the “encodings.idna” +module that comes with the Python standard library, but which +only supports the older superseded IDNA specification (`RFC 3490 +`_). + +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: + +.. 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 A-labels or U-labels +respectively. + +.. code-block:: pycon + + >>> import idna + >>> idna.encode('ドメイン.テスト') + b'xn--eckwd4c7c.xn--zckzah' + >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah')) + ドメイン.テスト + +You may use the codec encoding and decoding methods using the +``idna.codec`` module: + +.. code-block:: pycon + + >>> import idna.codec + >>> print('домен.испытание'.encode('idna2008')) + b'xn--d1acufc.xn--80akhbyknj4f' + >>> print(b'xn--d1acufc.xn--80akhbyknj4f'.decode('idna2008')) + домен.испытание + +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) ++++++++++++++++++++++++++++++++ + +As described in `RFC 5895 `_, the +IDNA specification does not normalize input from different potential +ways a user may input a domain name. This functionality, known as +a “mapping”, is considered by the specification to be a local +user-interface issue distinct from IDNA conversion functionality. + +This library provides one such mapping that was developed by the +Unicode Consortium. Known as `Unicode IDNA Compatibility Processing +`_, it provides for both a regular +mapping for typical applications, as well as a transitional mapping to +help migrate from older IDNA 2003 applications. Strings are +preprocessed according to Section 4.4 “Preprocessing for IDNA2008” +prior to the IDNA operations. + +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 + +Transitional processing provides conversions to help transition from +the older 2003 standard to the current standard. For example, in the +original IDNA specification, the *LATIN SMALL LETTER SHARP S* (ß) was +converted into two *LATIN SMALL LETTER S* (ss), whereas in the current +IDNA specification this conversion is not performed. + +.. code-block:: pycon + + >>> idna.encode('Königsgäßchen', uts46=True, transitional=True) + 'xn--knigsgsschen-lcb0w' + +Implementers should use transitional processing with caution, only in +rare cases where conversion from legacy labels to current labels must be +performed (i.e. IDNA implementations that pre-date 2008). For typical +applications that just need to convert labels, transitional processing +is unlikely to be beneficial and could produce unexpected incompatible +results. + +``encodings.idna`` Compatibility +++++++++++++++++++++++++++++++++ + +Function calls from the Python built-in ``encodings.idna`` module are +mapped to their IDNA 2008 equivalents using the ``idna.compat`` module. +Simply substitute the ``import`` clause in your code to refer to the new +module name. + +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 positional context (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. These tables are +computed 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.6 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. + Removing support for older versions should be well justified in that the + maintenance burden has become too high. + +* **Python 2**. Python 2 is supported by version 2.x of this library. + Use "idna<3" in your requirements file if you need this library for + a Python 2 application. Be advised that these versions are no longer + actively developed. + +* **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. + diff --git a/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/RECORD b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..d8c77ddddae5d1523bf26ff599fc9e0e9ee6780e --- /dev/null +++ b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/RECORD @@ -0,0 +1,15 @@ +idna-3.10.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +idna-3.10.dist-info/LICENSE.md,sha256=pZ8LDvNjWHQQmkRhykT_enDVBpboFHZ7-vch1Mmw2w8,1541 +idna-3.10.dist-info/METADATA,sha256=URR5ZyDfQ1PCEGhkYoojqfi2Ra0tau2--lhwG4XSfjI,10158 +idna-3.10.dist-info/RECORD,, +idna-3.10.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +idna-3.10.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81 +idna/__init__.py,sha256=MPqNDLZbXqGaNdXxAFhiqFPKEQXju2jNQhCey6-5eJM,868 +idna/codec.py,sha256=PEew3ItwzjW4hymbasnty2N2OXvNcgHB-JjrBuxHPYY,3422 +idna/compat.py,sha256=RzLy6QQCdl9784aFhb2EX9EKGCJjg0P3PilGdeXXcx8,316 +idna/core.py,sha256=YJYyAMnwiQEPjVC4-Fqu_p4CJ6yKKuDGmppBNQNQpFs,13239 +idna/idnadata.py,sha256=W30GcIGvtOWYwAjZj4ZjuouUutC6ffgNuyjJy7fZ-lo,78306 +idna/intranges.py,sha256=amUtkdhYcQG8Zr-CoMM_kVRacxkivC1WgxN1b63KKdU,1898 +idna/package_data.py,sha256=q59S3OXsc5VI8j6vSD0sGBMyk6zZ4vWFREE88yCJYKs,21 +idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +idna/uts46data.py,sha256=rt90K9J40gUSwppDPCrhjgi5AA6pWM65dEGRSf6rIhM,239289 diff --git a/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/REQUESTED b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/WHEEL b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..3b5e64b5e6c4a210201d1676a891fd57b15cda99 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/idna-3.10.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.9.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv/lib/python3.13/site-packages/packaging/__init__.py b/.venv/lib/python3.13/site-packages/packaging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d45c22cfd88e2b88976b46d4171a502b602658ec --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/__init__.py @@ -0,0 +1,15 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +__title__ = "packaging" +__summary__ = "Core utilities for Python packages" +__uri__ = "https://github.com/pypa/packaging" + +__version__ = "25.0" + +__author__ = "Donald Stufft and individual contributors" +__email__ = "donald@stufft.io" + +__license__ = "BSD-2-Clause or Apache-2.0" +__copyright__ = f"2014 {__author__}" diff --git a/.venv/lib/python3.13/site-packages/packaging/_elffile.py b/.venv/lib/python3.13/site-packages/packaging/_elffile.py new file mode 100644 index 0000000000000000000000000000000000000000..7a5afc33b0a2401cf509bb6a8d1143d5230324d9 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_elffile.py @@ -0,0 +1,109 @@ +""" +ELF file parser. + +This provides a class ``ELFFile`` that parses an ELF executable in a similar +interface to ``ZipFile``. Only the read interface is implemented. + +Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca +ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html +""" + +from __future__ import annotations + +import enum +import os +import struct +from typing import IO + + +class ELFInvalid(ValueError): + pass + + +class EIClass(enum.IntEnum): + C32 = 1 + C64 = 2 + + +class EIData(enum.IntEnum): + Lsb = 1 + Msb = 2 + + +class EMachine(enum.IntEnum): + I386 = 3 + S390 = 22 + Arm = 40 + X8664 = 62 + AArc64 = 183 + + +class ELFFile: + """ + Representation of an ELF executable. + """ + + def __init__(self, f: IO[bytes]) -> None: + self._f = f + + try: + ident = self._read("16B") + except struct.error as e: + raise ELFInvalid("unable to parse identification") from e + magic = bytes(ident[:4]) + if magic != b"\x7fELF": + raise ELFInvalid(f"invalid magic: {magic!r}") + + self.capacity = ident[4] # Format for program header (bitness). + self.encoding = ident[5] # Data structure encoding (endianness). + + try: + # e_fmt: Format for program header. + # p_fmt: Format for section header. + # p_idx: Indexes to find p_type, p_offset, and p_filesz. + e_fmt, self._p_fmt, self._p_idx = { + (1, 1): ("HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. + (2, 1): ("HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. + }[(self.capacity, self.encoding)] + except KeyError as e: + raise ELFInvalid( + f"unrecognized capacity ({self.capacity}) or encoding ({self.encoding})" + ) from e + + try: + ( + _, + self.machine, # Architecture type. + _, + _, + self._e_phoff, # Offset of program header. + _, + self.flags, # Processor-specific flags. + _, + self._e_phentsize, # Size of section. + self._e_phnum, # Number of sections. + ) = self._read(e_fmt) + except struct.error as e: + raise ELFInvalid("unable to parse machine and section information") from e + + def _read(self, fmt: str) -> tuple[int, ...]: + return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) + + @property + def interpreter(self) -> str | None: + """ + The path recorded in the ``PT_INTERP`` section header. + """ + for index in range(self._e_phnum): + self._f.seek(self._e_phoff + self._e_phentsize * index) + try: + data = self._read(self._p_fmt) + except struct.error: + continue + if data[self._p_idx[0]] != 3: # Not PT_INTERP. + continue + self._f.seek(data[self._p_idx[1]]) + return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") + return None diff --git a/.venv/lib/python3.13/site-packages/packaging/_manylinux.py b/.venv/lib/python3.13/site-packages/packaging/_manylinux.py new file mode 100644 index 0000000000000000000000000000000000000000..95f55762e86f08af76aaa95f5cd147d4517c6d66 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_manylinux.py @@ -0,0 +1,262 @@ +from __future__ import annotations + +import collections +import contextlib +import functools +import os +import re +import sys +import warnings +from typing import Generator, Iterator, NamedTuple, Sequence + +from ._elffile import EIClass, EIData, ELFFile, EMachine + +EF_ARM_ABIMASK = 0xFF000000 +EF_ARM_ABI_VER5 = 0x05000000 +EF_ARM_ABI_FLOAT_HARD = 0x00000400 + + +# `os.PathLike` not a generic type until Python 3.9, so sticking with `str` +# as the type for `path` until then. +@contextlib.contextmanager +def _parse_elf(path: str) -> Generator[ELFFile | None, None, None]: + try: + with open(path, "rb") as f: + yield ELFFile(f) + except (OSError, TypeError, ValueError): + yield None + + +def _is_linux_armhf(executable: str) -> bool: + # hard-float ABI can be detected from the ELF header of the running + # process + # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.Arm + and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5 + and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD + ) + + +def _is_linux_i686(executable: str) -> bool: + with _parse_elf(executable) as f: + return ( + f is not None + and f.capacity == EIClass.C32 + and f.encoding == EIData.Lsb + and f.machine == EMachine.I386 + ) + + +def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool: + if "armv7l" in archs: + return _is_linux_armhf(executable) + if "i686" in archs: + return _is_linux_i686(executable) + allowed_archs = { + "x86_64", + "aarch64", + "ppc64", + "ppc64le", + "s390x", + "loongarch64", + "riscv64", + } + return any(arch in allowed_archs for arch in archs) + + +# If glibc ever changes its major version, we need to know what the last +# minor version was, so we can build the complete list of all versions. +# For now, guess what the highest minor version might be, assume it will +# be 50 for testing. Once this actually happens, update the dictionary +# with the actual value. +_LAST_GLIBC_MINOR: dict[int, int] = collections.defaultdict(lambda: 50) + + +class _GLibCVersion(NamedTuple): + major: int + minor: int + + +def _glibc_version_string_confstr() -> str | None: + """ + Primary implementation of glibc_version_string using os.confstr. + """ + # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely + # to be broken or missing. This strategy is used in the standard library + # platform module. + # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 + try: + # Should be a string like "glibc 2.17". + version_string: str | None = os.confstr("CS_GNU_LIBC_VERSION") + assert version_string is not None + _, version = version_string.rsplit() + except (AssertionError, AttributeError, OSError, ValueError): + # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... + return None + return version + + +def _glibc_version_string_ctypes() -> str | None: + """ + Fallback implementation of glibc_version_string using ctypes. + """ + try: + import ctypes + except ImportError: + return None + + # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen + # manpage says, "If filename is NULL, then the returned handle is for the + # main program". This way we can let the linker do the work to figure out + # which libc our process is actually using. + # + # We must also handle the special case where the executable is not a + # dynamically linked executable. This can occur when using musl libc, + # for example. In this situation, dlopen() will error, leading to an + # OSError. Interestingly, at least in the case of musl, there is no + # errno set on the OSError. The single string argument used to construct + # OSError comes from libc itself and is therefore not portable to + # hard code here. In any case, failure to call dlopen() means we + # can proceed, so we bail on our attempt. + try: + process_namespace = ctypes.CDLL(None) + except OSError: + return None + + try: + gnu_get_libc_version = process_namespace.gnu_get_libc_version + except AttributeError: + # Symbol doesn't exist -> therefore, we are not linked to + # glibc. + return None + + # Call gnu_get_libc_version, which returns a string like "2.5" + gnu_get_libc_version.restype = ctypes.c_char_p + version_str: str = gnu_get_libc_version() + # py2 / py3 compatibility: + if not isinstance(version_str, str): + version_str = version_str.decode("ascii") + + return version_str + + +def _glibc_version_string() -> str | None: + """Returns glibc version string, or None if not using glibc.""" + return _glibc_version_string_confstr() or _glibc_version_string_ctypes() + + +def _parse_glibc_version(version_str: str) -> tuple[int, int]: + """Parse glibc version. + + We use a regexp instead of str.split because we want to discard any + random junk that might come after the minor version -- this might happen + in patched/forked versions of glibc (e.g. Linaro's version of glibc + uses version strings like "2.20-2014.11"). See gh-3588. + """ + m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str) + if not m: + warnings.warn( + f"Expected glibc version with 2 components major.minor, got: {version_str}", + RuntimeWarning, + stacklevel=2, + ) + return -1, -1 + return int(m.group("major")), int(m.group("minor")) + + +@functools.lru_cache +def _get_glibc_version() -> tuple[int, int]: + version_str = _glibc_version_string() + if version_str is None: + return (-1, -1) + return _parse_glibc_version(version_str) + + +# From PEP 513, PEP 600 +def _is_compatible(arch: str, version: _GLibCVersion) -> bool: + sys_glibc = _get_glibc_version() + if sys_glibc < version: + return False + # Check for presence of _manylinux module. + try: + import _manylinux + except ImportError: + return True + if hasattr(_manylinux, "manylinux_compatible"): + result = _manylinux.manylinux_compatible(version[0], version[1], arch) + if result is not None: + return bool(result) + return True + if version == _GLibCVersion(2, 5): + if hasattr(_manylinux, "manylinux1_compatible"): + return bool(_manylinux.manylinux1_compatible) + if version == _GLibCVersion(2, 12): + if hasattr(_manylinux, "manylinux2010_compatible"): + return bool(_manylinux.manylinux2010_compatible) + if version == _GLibCVersion(2, 17): + if hasattr(_manylinux, "manylinux2014_compatible"): + return bool(_manylinux.manylinux2014_compatible) + return True + + +_LEGACY_MANYLINUX_MAP = { + # CentOS 7 w/ glibc 2.17 (PEP 599) + (2, 17): "manylinux2014", + # CentOS 6 w/ glibc 2.12 (PEP 571) + (2, 12): "manylinux2010", + # CentOS 5 w/ glibc 2.5 (PEP 513) + (2, 5): "manylinux1", +} + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate manylinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be manylinux-compatible. + + :returns: An iterator of compatible manylinux tags. + """ + if not _have_compatible_abi(sys.executable, archs): + return + # Oldest glibc to be supported regardless of architecture is (2, 17). + too_old_glibc2 = _GLibCVersion(2, 16) + if set(archs) & {"x86_64", "i686"}: + # On x86/i686 also oldest glibc to be supported is (2, 5). + too_old_glibc2 = _GLibCVersion(2, 4) + current_glibc = _GLibCVersion(*_get_glibc_version()) + glibc_max_list = [current_glibc] + # We can assume compatibility across glibc major versions. + # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 + # + # Build a list of maximum glibc versions so that we can + # output the canonical list of all glibc from current_glibc + # down to too_old_glibc2, including all intermediary versions. + for glibc_major in range(current_glibc.major - 1, 1, -1): + glibc_minor = _LAST_GLIBC_MINOR[glibc_major] + glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) + for arch in archs: + for glibc_max in glibc_max_list: + if glibc_max.major == too_old_glibc2.major: + min_minor = too_old_glibc2.minor + else: + # For other glibc major versions oldest supported is (x, 0). + min_minor = -1 + for glibc_minor in range(glibc_max.minor, min_minor, -1): + glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) + tag = "manylinux_{}_{}".format(*glibc_version) + if _is_compatible(arch, glibc_version): + yield f"{tag}_{arch}" + # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. + if glibc_version in _LEGACY_MANYLINUX_MAP: + legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] + if _is_compatible(arch, glibc_version): + yield f"{legacy_tag}_{arch}" diff --git a/.venv/lib/python3.13/site-packages/packaging/_musllinux.py b/.venv/lib/python3.13/site-packages/packaging/_musllinux.py new file mode 100644 index 0000000000000000000000000000000000000000..d2bf30b56319ba862c5c9a1a39a87c6d1cb68718 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_musllinux.py @@ -0,0 +1,85 @@ +"""PEP 656 support. + +This module implements logic to detect if the currently running Python is +linked against musl, and what musl version is used. +""" + +from __future__ import annotations + +import functools +import re +import subprocess +import sys +from typing import Iterator, NamedTuple, Sequence + +from ._elffile import ELFFile + + +class _MuslVersion(NamedTuple): + major: int + minor: int + + +def _parse_musl_version(output: str) -> _MuslVersion | None: + lines = [n for n in (n.strip() for n in output.splitlines()) if n] + if len(lines) < 2 or lines[0][:4] != "musl": + return None + m = re.match(r"Version (\d+)\.(\d+)", lines[1]) + if not m: + return None + return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) + + +@functools.lru_cache +def _get_musl_version(executable: str) -> _MuslVersion | None: + """Detect currently-running musl runtime version. + + This is done by checking the specified executable's dynamic linking + information, and invoking the loader to parse its output for a version + string. If the loader is musl, the output would be something like:: + + musl libc (x86_64) + Version 1.2.2 + Dynamic Program Loader + """ + try: + with open(executable, "rb") as f: + ld = ELFFile(f).interpreter + except (OSError, TypeError, ValueError): + return None + if ld is None or "musl" not in ld: + return None + proc = subprocess.run([ld], stderr=subprocess.PIPE, text=True) + return _parse_musl_version(proc.stderr) + + +def platform_tags(archs: Sequence[str]) -> Iterator[str]: + """Generate musllinux tags compatible to the current platform. + + :param archs: Sequence of compatible architectures. + The first one shall be the closest to the actual architecture and be the part of + platform tag after the ``linux_`` prefix, e.g. ``x86_64``. + The ``linux_`` prefix is assumed as a prerequisite for the current platform to + be musllinux-compatible. + + :returns: An iterator of compatible musllinux tags. + """ + sys_musl = _get_musl_version(sys.executable) + if sys_musl is None: # Python not dynamically linked against musl. + return + for arch in archs: + for minor in range(sys_musl.minor, -1, -1): + yield f"musllinux_{sys_musl.major}_{minor}_{arch}" + + +if __name__ == "__main__": # pragma: no cover + import sysconfig + + plat = sysconfig.get_platform() + assert plat.startswith("linux-"), "not linux" + + print("plat:", plat) + print("musl:", _get_musl_version(sys.executable)) + print("tags:", end=" ") + for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): + print(t, end="\n ") diff --git a/.venv/lib/python3.13/site-packages/packaging/_parser.py b/.venv/lib/python3.13/site-packages/packaging/_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..0007c0aa64aeae24c7e0ca90790a25ba51dbf7d6 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_parser.py @@ -0,0 +1,353 @@ +"""Handwritten parser of dependency specifiers. + +The docstring for each __parse_* function contains EBNF-inspired grammar representing +the implementation. +""" + +from __future__ import annotations + +import ast +from typing import NamedTuple, Sequence, Tuple, Union + +from ._tokenizer import DEFAULT_RULES, Tokenizer + + +class Node: + def __init__(self, value: str) -> None: + self.value = value + + def __str__(self) -> str: + return self.value + + def __repr__(self) -> str: + return f"<{self.__class__.__name__}('{self}')>" + + def serialize(self) -> str: + raise NotImplementedError + + +class Variable(Node): + def serialize(self) -> str: + return str(self) + + +class Value(Node): + def serialize(self) -> str: + return f'"{self}"' + + +class Op(Node): + def serialize(self) -> str: + return str(self) + + +MarkerVar = Union[Variable, Value] +MarkerItem = Tuple[MarkerVar, Op, MarkerVar] +MarkerAtom = Union[MarkerItem, Sequence["MarkerAtom"]] +MarkerList = Sequence[Union["MarkerList", MarkerAtom, str]] + + +class ParsedRequirement(NamedTuple): + name: str + url: str + extras: list[str] + specifier: str + marker: MarkerList | None + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for dependency specifier +# -------------------------------------------------------------------------------------- +def parse_requirement(source: str) -> ParsedRequirement: + return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: + """ + requirement = WS? IDENTIFIER WS? extras WS? requirement_details + """ + tokenizer.consume("WS") + + name_token = tokenizer.expect( + "IDENTIFIER", expected="package name at the start of dependency specifier" + ) + name = name_token.text + tokenizer.consume("WS") + + extras = _parse_extras(tokenizer) + tokenizer.consume("WS") + + url, specifier, marker = _parse_requirement_details(tokenizer) + tokenizer.expect("END", expected="end of dependency specifier") + + return ParsedRequirement(name, url, extras, specifier, marker) + + +def _parse_requirement_details( + tokenizer: Tokenizer, +) -> tuple[str, str, MarkerList | None]: + """ + requirement_details = AT URL (WS requirement_marker?)? + | specifier WS? (requirement_marker)? + """ + + specifier = "" + url = "" + marker = None + + if tokenizer.check("AT"): + tokenizer.read() + tokenizer.consume("WS") + + url_start = tokenizer.position + url = tokenizer.expect("URL", expected="URL after @").text + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + tokenizer.expect("WS", expected="whitespace after URL") + + # The input might end after whitespace. + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, span_start=url_start, after="URL and whitespace" + ) + else: + specifier_start = tokenizer.position + specifier = _parse_specifier(tokenizer) + tokenizer.consume("WS") + + if tokenizer.check("END", peek=True): + return (url, specifier, marker) + + marker = _parse_requirement_marker( + tokenizer, + span_start=specifier_start, + after=( + "version specifier" + if specifier + else "name and no valid version specifier" + ), + ) + + return (url, specifier, marker) + + +def _parse_requirement_marker( + tokenizer: Tokenizer, *, span_start: int, after: str +) -> MarkerList: + """ + requirement_marker = SEMICOLON marker WS? + """ + + if not tokenizer.check("SEMICOLON"): + tokenizer.raise_syntax_error( + f"Expected end or semicolon (after {after})", + span_start=span_start, + ) + tokenizer.read() + + marker = _parse_marker(tokenizer) + tokenizer.consume("WS") + + return marker + + +def _parse_extras(tokenizer: Tokenizer) -> list[str]: + """ + extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? + """ + if not tokenizer.check("LEFT_BRACKET", peek=True): + return [] + + with tokenizer.enclosing_tokens( + "LEFT_BRACKET", + "RIGHT_BRACKET", + around="extras", + ): + tokenizer.consume("WS") + extras = _parse_extras_list(tokenizer) + tokenizer.consume("WS") + + return extras + + +def _parse_extras_list(tokenizer: Tokenizer) -> list[str]: + """ + extras_list = identifier (wsp* ',' wsp* identifier)* + """ + extras: list[str] = [] + + if not tokenizer.check("IDENTIFIER"): + return extras + + extras.append(tokenizer.read().text) + + while True: + tokenizer.consume("WS") + if tokenizer.check("IDENTIFIER", peek=True): + tokenizer.raise_syntax_error("Expected comma between extra names") + elif not tokenizer.check("COMMA"): + break + + tokenizer.read() + tokenizer.consume("WS") + + extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") + extras.append(extra_token.text) + + return extras + + +def _parse_specifier(tokenizer: Tokenizer) -> str: + """ + specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS + | WS? version_many WS? + """ + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="version specifier", + ): + tokenizer.consume("WS") + parsed_specifiers = _parse_version_many(tokenizer) + tokenizer.consume("WS") + + return parsed_specifiers + + +def _parse_version_many(tokenizer: Tokenizer) -> str: + """ + version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? + """ + parsed_specifiers = "" + while tokenizer.check("SPECIFIER"): + span_start = tokenizer.position + parsed_specifiers += tokenizer.read().text + if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): + tokenizer.raise_syntax_error( + ".* suffix can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position + 1, + ) + if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): + tokenizer.raise_syntax_error( + "Local version label can only be used with `==` or `!=` operators", + span_start=span_start, + span_end=tokenizer.position, + ) + tokenizer.consume("WS") + if not tokenizer.check("COMMA"): + break + parsed_specifiers += tokenizer.read().text + tokenizer.consume("WS") + + return parsed_specifiers + + +# -------------------------------------------------------------------------------------- +# Recursive descent parser for marker expression +# -------------------------------------------------------------------------------------- +def parse_marker(source: str) -> MarkerList: + return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES)) + + +def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList: + retval = _parse_marker(tokenizer) + tokenizer.expect("END", expected="end of marker expression") + return retval + + +def _parse_marker(tokenizer: Tokenizer) -> MarkerList: + """ + marker = marker_atom (BOOLOP marker_atom)+ + """ + expression = [_parse_marker_atom(tokenizer)] + while tokenizer.check("BOOLOP"): + token = tokenizer.read() + expr_right = _parse_marker_atom(tokenizer) + expression.extend((token.text, expr_right)) + return expression + + +def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: + """ + marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? + | WS? marker_item WS? + """ + + tokenizer.consume("WS") + if tokenizer.check("LEFT_PARENTHESIS", peek=True): + with tokenizer.enclosing_tokens( + "LEFT_PARENTHESIS", + "RIGHT_PARENTHESIS", + around="marker expression", + ): + tokenizer.consume("WS") + marker: MarkerAtom = _parse_marker(tokenizer) + tokenizer.consume("WS") + else: + marker = _parse_marker_item(tokenizer) + tokenizer.consume("WS") + return marker + + +def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: + """ + marker_item = WS? marker_var WS? marker_op WS? marker_var WS? + """ + tokenizer.consume("WS") + marker_var_left = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + marker_op = _parse_marker_op(tokenizer) + tokenizer.consume("WS") + marker_var_right = _parse_marker_var(tokenizer) + tokenizer.consume("WS") + return (marker_var_left, marker_op, marker_var_right) + + +def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: + """ + marker_var = VARIABLE | QUOTED_STRING + """ + if tokenizer.check("VARIABLE"): + return process_env_var(tokenizer.read().text.replace(".", "_")) + elif tokenizer.check("QUOTED_STRING"): + return process_python_str(tokenizer.read().text) + else: + tokenizer.raise_syntax_error( + message="Expected a marker variable or quoted string" + ) + + +def process_env_var(env_var: str) -> Variable: + if env_var in ("platform_python_implementation", "python_implementation"): + return Variable("platform_python_implementation") + else: + return Variable(env_var) + + +def process_python_str(python_str: str) -> Value: + value = ast.literal_eval(python_str) + return Value(str(value)) + + +def _parse_marker_op(tokenizer: Tokenizer) -> Op: + """ + marker_op = IN | NOT IN | OP + """ + if tokenizer.check("IN"): + tokenizer.read() + return Op("in") + elif tokenizer.check("NOT"): + tokenizer.read() + tokenizer.expect("WS", expected="whitespace after 'not'") + tokenizer.expect("IN", expected="'in' after 'not'") + return Op("not in") + elif tokenizer.check("OP"): + return Op(tokenizer.read().text) + else: + return tokenizer.raise_syntax_error( + "Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in" + ) diff --git a/.venv/lib/python3.13/site-packages/packaging/_structures.py b/.venv/lib/python3.13/site-packages/packaging/_structures.py new file mode 100644 index 0000000000000000000000000000000000000000..90a6465f9682c886363eea5327dac64bf623a6ff --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_structures.py @@ -0,0 +1,61 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + + +class InfinityType: + def __repr__(self) -> str: + return "Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return False + + def __le__(self, other: object) -> bool: + return False + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return True + + def __ge__(self, other: object) -> bool: + return True + + def __neg__(self: object) -> "NegativeInfinityType": + return NegativeInfinity + + +Infinity = InfinityType() + + +class NegativeInfinityType: + def __repr__(self) -> str: + return "-Infinity" + + def __hash__(self) -> int: + return hash(repr(self)) + + def __lt__(self, other: object) -> bool: + return True + + def __le__(self, other: object) -> bool: + return True + + def __eq__(self, other: object) -> bool: + return isinstance(other, self.__class__) + + def __gt__(self, other: object) -> bool: + return False + + def __ge__(self, other: object) -> bool: + return False + + def __neg__(self: object) -> InfinityType: + return Infinity + + +NegativeInfinity = NegativeInfinityType() diff --git a/.venv/lib/python3.13/site-packages/packaging/_tokenizer.py b/.venv/lib/python3.13/site-packages/packaging/_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..d28a9b6cf5daca9fa3ce5a8c8ae583a57ee84f12 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/_tokenizer.py @@ -0,0 +1,195 @@ +from __future__ import annotations + +import contextlib +import re +from dataclasses import dataclass +from typing import Iterator, NoReturn + +from .specifiers import Specifier + + +@dataclass +class Token: + name: str + text: str + position: int + + +class ParserSyntaxError(Exception): + """The provided source text could not be parsed correctly.""" + + def __init__( + self, + message: str, + *, + source: str, + span: tuple[int, int], + ) -> None: + self.span = span + self.message = message + self.source = source + + super().__init__() + + def __str__(self) -> str: + marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" + return "\n ".join([self.message, self.source, marker]) + + +DEFAULT_RULES: dict[str, str | re.Pattern[str]] = { + "LEFT_PARENTHESIS": r"\(", + "RIGHT_PARENTHESIS": r"\)", + "LEFT_BRACKET": r"\[", + "RIGHT_BRACKET": r"\]", + "SEMICOLON": r";", + "COMMA": r",", + "QUOTED_STRING": re.compile( + r""" + ( + ('[^']*') + | + ("[^"]*") + ) + """, + re.VERBOSE, + ), + "OP": r"(===|==|~=|!=|<=|>=|<|>)", + "BOOLOP": r"\b(or|and)\b", + "IN": r"\bin\b", + "NOT": r"\bnot\b", + "VARIABLE": re.compile( + r""" + \b( + python_version + |python_full_version + |os[._]name + |sys[._]platform + |platform_(release|system) + |platform[._](version|machine|python_implementation) + |python_implementation + |implementation_(name|version) + |extras? + |dependency_groups + )\b + """, + re.VERBOSE, + ), + "SPECIFIER": re.compile( + Specifier._operator_regex_str + Specifier._version_regex_str, + re.VERBOSE | re.IGNORECASE, + ), + "AT": r"\@", + "URL": r"[^ \t]+", + "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b", + "VERSION_PREFIX_TRAIL": r"\.\*", + "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*", + "WS": r"[ \t]+", + "END": r"$", +} + + +class Tokenizer: + """Context-sensitive token parsing. + + Provides methods to examine the input stream to check whether the next token + matches. + """ + + def __init__( + self, + source: str, + *, + rules: dict[str, str | re.Pattern[str]], + ) -> None: + self.source = source + self.rules: dict[str, re.Pattern[str]] = { + name: re.compile(pattern) for name, pattern in rules.items() + } + self.next_token: Token | None = None + self.position = 0 + + def consume(self, name: str) -> None: + """Move beyond provided token name, if at current position.""" + if self.check(name): + self.read() + + def check(self, name: str, *, peek: bool = False) -> bool: + """Check whether the next token has the provided name. + + By default, if the check succeeds, the token *must* be read before + another check. If `peek` is set to `True`, the token is not loaded and + would need to be checked again. + """ + assert self.next_token is None, ( + f"Cannot check for {name!r}, already have {self.next_token!r}" + ) + assert name in self.rules, f"Unknown token name: {name!r}" + + expression = self.rules[name] + + match = expression.match(self.source, self.position) + if match is None: + return False + if not peek: + self.next_token = Token(name, match[0], self.position) + return True + + def expect(self, name: str, *, expected: str) -> Token: + """Expect a certain token name next, failing with a syntax error otherwise. + + The token is *not* read. + """ + if not self.check(name): + raise self.raise_syntax_error(f"Expected {expected}") + return self.read() + + def read(self) -> Token: + """Consume the next token and return it.""" + token = self.next_token + assert token is not None + + self.position += len(token.text) + self.next_token = None + + return token + + def raise_syntax_error( + self, + message: str, + *, + span_start: int | None = None, + span_end: int | None = None, + ) -> NoReturn: + """Raise ParserSyntaxError at the given position.""" + span = ( + self.position if span_start is None else span_start, + self.position if span_end is None else span_end, + ) + raise ParserSyntaxError( + message, + source=self.source, + span=span, + ) + + @contextlib.contextmanager + def enclosing_tokens( + self, open_token: str, close_token: str, *, around: str + ) -> Iterator[None]: + if self.check(open_token): + open_position = self.position + self.read() + else: + open_position = None + + yield + + if open_position is None: + return + + if not self.check(close_token): + self.raise_syntax_error( + f"Expected matching {close_token} for {open_token}, after {around}", + span_start=open_position, + ) + + self.read() diff --git a/.venv/lib/python3.13/site-packages/packaging/markers.py b/.venv/lib/python3.13/site-packages/packaging/markers.py new file mode 100644 index 0000000000000000000000000000000000000000..e7cea57297a23809548fcd0d344740796bae945b --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/markers.py @@ -0,0 +1,362 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import operator +import os +import platform +import sys +from typing import AbstractSet, Any, Callable, Literal, TypedDict, Union, cast + +from ._parser import MarkerAtom, MarkerList, Op, Value, Variable +from ._parser import parse_marker as _parse_marker +from ._tokenizer import ParserSyntaxError +from .specifiers import InvalidSpecifier, Specifier +from .utils import canonicalize_name + +__all__ = [ + "EvaluateContext", + "InvalidMarker", + "Marker", + "UndefinedComparison", + "UndefinedEnvironmentName", + "default_environment", +] + +Operator = Callable[[str, Union[str, AbstractSet[str]]], bool] +EvaluateContext = Literal["metadata", "lock_file", "requirement"] +MARKERS_ALLOWING_SET = {"extras", "dependency_groups"} + + +class InvalidMarker(ValueError): + """ + An invalid marker was found, users should refer to PEP 508. + """ + + +class UndefinedComparison(ValueError): + """ + An invalid operation was attempted on a value that doesn't support it. + """ + + +class UndefinedEnvironmentName(ValueError): + """ + A name was attempted to be used that does not exist inside of the + environment. + """ + + +class Environment(TypedDict): + implementation_name: str + """The implementation's identifier, e.g. ``'cpython'``.""" + + implementation_version: str + """ + The implementation's version, e.g. ``'3.13.0a2'`` for CPython 3.13.0a2, or + ``'7.3.13'`` for PyPy3.10 v7.3.13. + """ + + os_name: str + """ + The value of :py:data:`os.name`. The name of the operating system dependent module + imported, e.g. ``'posix'``. + """ + + platform_machine: str + """ + Returns the machine type, e.g. ``'i386'``. + + An empty string if the value cannot be determined. + """ + + platform_release: str + """ + The system's release, e.g. ``'2.2.0'`` or ``'NT'``. + + An empty string if the value cannot be determined. + """ + + platform_system: str + """ + The system/OS name, e.g. ``'Linux'``, ``'Windows'`` or ``'Java'``. + + An empty string if the value cannot be determined. + """ + + platform_version: str + """ + The system's release version, e.g. ``'#3 on degas'``. + + An empty string if the value cannot be determined. + """ + + python_full_version: str + """ + The Python version as string ``'major.minor.patchlevel'``. + + Note that unlike the Python :py:data:`sys.version`, this value will always include + the patchlevel (it defaults to 0). + """ + + platform_python_implementation: str + """ + A string identifying the Python implementation, e.g. ``'CPython'``. + """ + + python_version: str + """The Python version as string ``'major.minor'``.""" + + sys_platform: str + """ + This string contains a platform identifier that can be used to append + platform-specific components to :py:data:`sys.path`, for instance. + + For Unix systems, except on Linux and AIX, this is the lowercased OS name as + returned by ``uname -s`` with the first part of the version as returned by + ``uname -r`` appended, e.g. ``'sunos5'`` or ``'freebsd8'``, at the time when Python + was built. + """ + + +def _normalize_extra_values(results: Any) -> Any: + """ + Normalize extra values. + """ + if isinstance(results[0], tuple): + lhs, op, rhs = results[0] + if isinstance(lhs, Variable) and lhs.value == "extra": + normalized_extra = canonicalize_name(rhs.value) + rhs = Value(normalized_extra) + elif isinstance(rhs, Variable) and rhs.value == "extra": + normalized_extra = canonicalize_name(lhs.value) + lhs = Value(normalized_extra) + results[0] = lhs, op, rhs + return results + + +def _format_marker( + marker: list[str] | MarkerAtom | str, first: bool | None = True +) -> str: + assert isinstance(marker, (list, tuple, str)) + + # Sometimes we have a structure like [[...]] which is a single item list + # where the single item is itself it's own list. In that case we want skip + # the rest of this function so that we don't get extraneous () on the + # outside. + if ( + isinstance(marker, list) + and len(marker) == 1 + and isinstance(marker[0], (list, tuple)) + ): + return _format_marker(marker[0]) + + if isinstance(marker, list): + inner = (_format_marker(m, first=False) for m in marker) + if first: + return " ".join(inner) + else: + return "(" + " ".join(inner) + ")" + elif isinstance(marker, tuple): + return " ".join([m.serialize() for m in marker]) + else: + return marker + + +_operators: dict[str, Operator] = { + "in": lambda lhs, rhs: lhs in rhs, + "not in": lambda lhs, rhs: lhs not in rhs, + "<": operator.lt, + "<=": operator.le, + "==": operator.eq, + "!=": operator.ne, + ">=": operator.ge, + ">": operator.gt, +} + + +def _eval_op(lhs: str, op: Op, rhs: str | AbstractSet[str]) -> bool: + if isinstance(rhs, str): + try: + spec = Specifier("".join([op.serialize(), rhs])) + except InvalidSpecifier: + pass + else: + return spec.contains(lhs, prereleases=True) + + oper: Operator | None = _operators.get(op.serialize()) + if oper is None: + raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") + + return oper(lhs, rhs) + + +def _normalize( + lhs: str, rhs: str | AbstractSet[str], key: str +) -> tuple[str, str | AbstractSet[str]]: + # PEP 685 – Comparison of extra names for optional distribution dependencies + # https://peps.python.org/pep-0685/ + # > When comparing extra names, tools MUST normalize the names being + # > compared using the semantics outlined in PEP 503 for names + if key == "extra": + assert isinstance(rhs, str), "extra value must be a string" + return (canonicalize_name(lhs), canonicalize_name(rhs)) + if key in MARKERS_ALLOWING_SET: + if isinstance(rhs, str): # pragma: no cover + return (canonicalize_name(lhs), canonicalize_name(rhs)) + else: + return (canonicalize_name(lhs), {canonicalize_name(v) for v in rhs}) + + # other environment markers don't have such standards + return lhs, rhs + + +def _evaluate_markers( + markers: MarkerList, environment: dict[str, str | AbstractSet[str]] +) -> bool: + groups: list[list[bool]] = [[]] + + for marker in markers: + assert isinstance(marker, (list, tuple, str)) + + if isinstance(marker, list): + groups[-1].append(_evaluate_markers(marker, environment)) + elif isinstance(marker, tuple): + lhs, op, rhs = marker + + if isinstance(lhs, Variable): + environment_key = lhs.value + lhs_value = environment[environment_key] + rhs_value = rhs.value + else: + lhs_value = lhs.value + environment_key = rhs.value + rhs_value = environment[environment_key] + assert isinstance(lhs_value, str), "lhs must be a string" + lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key) + groups[-1].append(_eval_op(lhs_value, op, rhs_value)) + else: + assert marker in ["and", "or"] + if marker == "or": + groups.append([]) + + return any(all(item) for item in groups) + + +def format_full_version(info: sys._version_info) -> str: + version = f"{info.major}.{info.minor}.{info.micro}" + kind = info.releaselevel + if kind != "final": + version += kind[0] + str(info.serial) + return version + + +def default_environment() -> Environment: + iver = format_full_version(sys.implementation.version) + implementation_name = sys.implementation.name + return { + "implementation_name": implementation_name, + "implementation_version": iver, + "os_name": os.name, + "platform_machine": platform.machine(), + "platform_release": platform.release(), + "platform_system": platform.system(), + "platform_version": platform.version(), + "python_full_version": platform.python_version(), + "platform_python_implementation": platform.python_implementation(), + "python_version": ".".join(platform.python_version_tuple()[:2]), + "sys_platform": sys.platform, + } + + +class Marker: + def __init__(self, marker: str) -> None: + # Note: We create a Marker object without calling this constructor in + # packaging.requirements.Requirement. If any additional logic is + # added here, make sure to mirror/adapt Requirement. + try: + self._markers = _normalize_extra_values(_parse_marker(marker)) + # The attribute `_markers` can be described in terms of a recursive type: + # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]] + # + # For example, the following expression: + # python_version > "3.6" or (python_version == "3.6" and os_name == "unix") + # + # is parsed into: + # [ + # (, ')>, ), + # 'and', + # [ + # (, , ), + # 'or', + # (, , ) + # ] + # ] + except ParserSyntaxError as e: + raise InvalidMarker(str(e)) from e + + def __str__(self) -> str: + return _format_marker(self._markers) + + def __repr__(self) -> str: + return f"" + + def __hash__(self) -> int: + return hash((self.__class__.__name__, str(self))) + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, Marker): + return NotImplemented + + return str(self) == str(other) + + def evaluate( + self, + environment: dict[str, str] | None = None, + context: EvaluateContext = "metadata", + ) -> bool: + """Evaluate a marker. + + Return the boolean from evaluating the given marker against the + environment. environment is an optional argument to override all or + part of the determined environment. The *context* parameter specifies what + context the markers are being evaluated for, which influences what markers + are considered valid. Acceptable values are "metadata" (for core metadata; + default), "lock_file", and "requirement" (i.e. all other situations). + + The environment is determined from the current Python process. + """ + current_environment = cast( + "dict[str, str | AbstractSet[str]]", default_environment() + ) + if context == "lock_file": + current_environment.update( + extras=frozenset(), dependency_groups=frozenset() + ) + elif context == "metadata": + current_environment["extra"] = "" + if environment is not None: + current_environment.update(environment) + # The API used to allow setting extra to None. We need to handle this + # case for backwards compatibility. + if "extra" in current_environment and current_environment["extra"] is None: + current_environment["extra"] = "" + + return _evaluate_markers( + self._markers, _repair_python_full_version(current_environment) + ) + + +def _repair_python_full_version( + env: dict[str, str | AbstractSet[str]], +) -> dict[str, str | AbstractSet[str]]: + """ + Work around platform.python_version() returning something that is not PEP 440 + compliant for non-tagged Python builds. + """ + python_full_version = cast(str, env["python_full_version"]) + if python_full_version.endswith("+"): + env["python_full_version"] = f"{python_full_version}local" + return env diff --git a/.venv/lib/python3.13/site-packages/packaging/metadata.py b/.venv/lib/python3.13/site-packages/packaging/metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..3bd8602d36c53374f1f10a0716d28fdc64e2d3ac --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/metadata.py @@ -0,0 +1,862 @@ +from __future__ import annotations + +import email.feedparser +import email.header +import email.message +import email.parser +import email.policy +import pathlib +import sys +import typing +from typing import ( + Any, + Callable, + Generic, + Literal, + TypedDict, + cast, +) + +from . import licenses, requirements, specifiers, utils +from . import version as version_module +from .licenses import NormalizedLicenseExpression + +T = typing.TypeVar("T") + + +if sys.version_info >= (3, 11): # pragma: no cover + ExceptionGroup = ExceptionGroup +else: # pragma: no cover + + class ExceptionGroup(Exception): + """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11. + + If :external:exc:`ExceptionGroup` is already defined by Python itself, + that version is used instead. + """ + + message: str + exceptions: list[Exception] + + def __init__(self, message: str, exceptions: list[Exception]) -> None: + self.message = message + self.exceptions = exceptions + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})" + + +class InvalidMetadata(ValueError): + """A metadata field contains invalid data.""" + + field: str + """The name of the field that contains invalid data.""" + + def __init__(self, field: str, message: str) -> None: + self.field = field + super().__init__(message) + + +# The RawMetadata class attempts to make as few assumptions about the underlying +# serialization formats as possible. The idea is that as long as a serialization +# formats offer some very basic primitives in *some* way then we can support +# serializing to and from that format. +class RawMetadata(TypedDict, total=False): + """A dictionary of raw core metadata. + + Each field in core metadata maps to a key of this dictionary (when data is + provided). The key is lower-case and underscores are used instead of dashes + compared to the equivalent core metadata field. Any core metadata field that + can be specified multiple times or can hold multiple values in a single + field have a key with a plural name. See :class:`Metadata` whose attributes + match the keys of this dictionary. + + Core metadata fields that can be specified multiple times are stored as a + list or dict depending on which is appropriate for the field. Any fields + which hold multiple values in a single field are stored as a list. + + """ + + # Metadata 1.0 - PEP 241 + metadata_version: str + name: str + version: str + platforms: list[str] + summary: str + description: str + keywords: list[str] + home_page: str + author: str + author_email: str + license: str + + # Metadata 1.1 - PEP 314 + supported_platforms: list[str] + download_url: str + classifiers: list[str] + requires: list[str] + provides: list[str] + obsoletes: list[str] + + # Metadata 1.2 - PEP 345 + maintainer: str + maintainer_email: str + requires_dist: list[str] + provides_dist: list[str] + obsoletes_dist: list[str] + requires_python: str + requires_external: list[str] + project_urls: dict[str, str] + + # Metadata 2.0 + # PEP 426 attempted to completely revamp the metadata format + # but got stuck without ever being able to build consensus on + # it and ultimately ended up withdrawn. + # + # However, a number of tools had started emitting METADATA with + # `2.0` Metadata-Version, so for historical reasons, this version + # was skipped. + + # Metadata 2.1 - PEP 566 + description_content_type: str + provides_extra: list[str] + + # Metadata 2.2 - PEP 643 + dynamic: list[str] + + # Metadata 2.3 - PEP 685 + # No new fields were added in PEP 685, just some edge case were + # tightened up to provide better interoptability. + + # Metadata 2.4 - PEP 639 + license_expression: str + license_files: list[str] + + +_STRING_FIELDS = { + "author", + "author_email", + "description", + "description_content_type", + "download_url", + "home_page", + "license", + "license_expression", + "maintainer", + "maintainer_email", + "metadata_version", + "name", + "requires_python", + "summary", + "version", +} + +_LIST_FIELDS = { + "classifiers", + "dynamic", + "license_files", + "obsoletes", + "obsoletes_dist", + "platforms", + "provides", + "provides_dist", + "provides_extra", + "requires", + "requires_dist", + "requires_external", + "supported_platforms", +} + +_DICT_FIELDS = { + "project_urls", +} + + +def _parse_keywords(data: str) -> list[str]: + """Split a string of comma-separated keywords into a list of keywords.""" + return [k.strip() for k in data.split(",")] + + +def _parse_project_urls(data: list[str]) -> dict[str, str]: + """Parse a list of label/URL string pairings separated by a comma.""" + urls = {} + for pair in data: + # Our logic is slightly tricky here as we want to try and do + # *something* reasonable with malformed data. + # + # The main thing that we have to worry about, is data that does + # not have a ',' at all to split the label from the Value. There + # isn't a singular right answer here, and we will fail validation + # later on (if the caller is validating) so it doesn't *really* + # matter, but since the missing value has to be an empty str + # and our return value is dict[str, str], if we let the key + # be the missing value, then they'd have multiple '' values that + # overwrite each other in a accumulating dict. + # + # The other potentional issue is that it's possible to have the + # same label multiple times in the metadata, with no solid "right" + # answer with what to do in that case. As such, we'll do the only + # thing we can, which is treat the field as unparseable and add it + # to our list of unparsed fields. + parts = [p.strip() for p in pair.split(",", 1)] + parts.extend([""] * (max(0, 2 - len(parts)))) # Ensure 2 items + + # TODO: The spec doesn't say anything about if the keys should be + # considered case sensitive or not... logically they should + # be case-preserving and case-insensitive, but doing that + # would open up more cases where we might have duplicate + # entries. + label, url = parts + if label in urls: + # The label already exists in our set of urls, so this field + # is unparseable, and we can just add the whole thing to our + # unparseable data and stop processing it. + raise KeyError("duplicate labels in project urls") + urls[label] = url + + return urls + + +def _get_payload(msg: email.message.Message, source: bytes | str) -> str: + """Get the body of the message.""" + # If our source is a str, then our caller has managed encodings for us, + # and we don't need to deal with it. + if isinstance(source, str): + payload = msg.get_payload() + assert isinstance(payload, str) + return payload + # If our source is a bytes, then we're managing the encoding and we need + # to deal with it. + else: + bpayload = msg.get_payload(decode=True) + assert isinstance(bpayload, bytes) + try: + return bpayload.decode("utf8", "strict") + except UnicodeDecodeError as exc: + raise ValueError("payload in an invalid encoding") from exc + + +# The various parse_FORMAT functions here are intended to be as lenient as +# possible in their parsing, while still returning a correctly typed +# RawMetadata. +# +# To aid in this, we also generally want to do as little touching of the +# data as possible, except where there are possibly some historic holdovers +# that make valid data awkward to work with. +# +# While this is a lower level, intermediate format than our ``Metadata`` +# class, some light touch ups can make a massive difference in usability. + +# Map METADATA fields to RawMetadata. +_EMAIL_TO_RAW_MAPPING = { + "author": "author", + "author-email": "author_email", + "classifier": "classifiers", + "description": "description", + "description-content-type": "description_content_type", + "download-url": "download_url", + "dynamic": "dynamic", + "home-page": "home_page", + "keywords": "keywords", + "license": "license", + "license-expression": "license_expression", + "license-file": "license_files", + "maintainer": "maintainer", + "maintainer-email": "maintainer_email", + "metadata-version": "metadata_version", + "name": "name", + "obsoletes": "obsoletes", + "obsoletes-dist": "obsoletes_dist", + "platform": "platforms", + "project-url": "project_urls", + "provides": "provides", + "provides-dist": "provides_dist", + "provides-extra": "provides_extra", + "requires": "requires", + "requires-dist": "requires_dist", + "requires-external": "requires_external", + "requires-python": "requires_python", + "summary": "summary", + "supported-platform": "supported_platforms", + "version": "version", +} +_RAW_TO_EMAIL_MAPPING = {raw: email for email, raw in _EMAIL_TO_RAW_MAPPING.items()} + + +def parse_email(data: bytes | str) -> tuple[RawMetadata, dict[str, list[str]]]: + """Parse a distribution's metadata stored as email headers (e.g. from ``METADATA``). + + This function returns a two-item tuple of dicts. The first dict is of + recognized fields from the core metadata specification. Fields that can be + parsed and translated into Python's built-in types are converted + appropriately. All other fields are left as-is. Fields that are allowed to + appear multiple times are stored as lists. + + The second dict contains all other fields from the metadata. This includes + any unrecognized fields. It also includes any fields which are expected to + be parsed into a built-in type but were not formatted appropriately. Finally, + any fields that are expected to appear only once but are repeated are + included in this dict. + + """ + raw: dict[str, str | list[str] | dict[str, str]] = {} + unparsed: dict[str, list[str]] = {} + + if isinstance(data, str): + parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data) + else: + parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data) + + # We have to wrap parsed.keys() in a set, because in the case of multiple + # values for a key (a list), the key will appear multiple times in the + # list of keys, but we're avoiding that by using get_all(). + for name in frozenset(parsed.keys()): + # Header names in RFC are case insensitive, so we'll normalize to all + # lower case to make comparisons easier. + name = name.lower() + + # We use get_all() here, even for fields that aren't multiple use, + # because otherwise someone could have e.g. two Name fields, and we + # would just silently ignore it rather than doing something about it. + headers = parsed.get_all(name) or [] + + # The way the email module works when parsing bytes is that it + # unconditionally decodes the bytes as ascii using the surrogateescape + # handler. When you pull that data back out (such as with get_all() ), + # it looks to see if the str has any surrogate escapes, and if it does + # it wraps it in a Header object instead of returning the string. + # + # As such, we'll look for those Header objects, and fix up the encoding. + value = [] + # Flag if we have run into any issues processing the headers, thus + # signalling that the data belongs in 'unparsed'. + valid_encoding = True + for h in headers: + # It's unclear if this can return more types than just a Header or + # a str, so we'll just assert here to make sure. + assert isinstance(h, (email.header.Header, str)) + + # If it's a header object, we need to do our little dance to get + # the real data out of it. In cases where there is invalid data + # we're going to end up with mojibake, but there's no obvious, good + # way around that without reimplementing parts of the Header object + # ourselves. + # + # That should be fine since, if mojibacked happens, this key is + # going into the unparsed dict anyways. + if isinstance(h, email.header.Header): + # The Header object stores it's data as chunks, and each chunk + # can be independently encoded, so we'll need to check each + # of them. + chunks: list[tuple[bytes, str | None]] = [] + for bin, encoding in email.header.decode_header(h): + try: + bin.decode("utf8", "strict") + except UnicodeDecodeError: + # Enable mojibake. + encoding = "latin1" + valid_encoding = False + else: + encoding = "utf8" + chunks.append((bin, encoding)) + + # Turn our chunks back into a Header object, then let that + # Header object do the right thing to turn them into a + # string for us. + value.append(str(email.header.make_header(chunks))) + # This is already a string, so just add it. + else: + value.append(h) + + # We've processed all of our values to get them into a list of str, + # but we may have mojibake data, in which case this is an unparsed + # field. + if not valid_encoding: + unparsed[name] = value + continue + + raw_name = _EMAIL_TO_RAW_MAPPING.get(name) + if raw_name is None: + # This is a bit of a weird situation, we've encountered a key that + # we don't know what it means, so we don't know whether it's meant + # to be a list or not. + # + # Since we can't really tell one way or another, we'll just leave it + # as a list, even though it may be a single item list, because that's + # what makes the most sense for email headers. + unparsed[name] = value + continue + + # If this is one of our string fields, then we'll check to see if our + # value is a list of a single item. If it is then we'll assume that + # it was emitted as a single string, and unwrap the str from inside + # the list. + # + # If it's any other kind of data, then we haven't the faintest clue + # what we should parse it as, and we have to just add it to our list + # of unparsed stuff. + if raw_name in _STRING_FIELDS and len(value) == 1: + raw[raw_name] = value[0] + # If this is one of our list of string fields, then we can just assign + # the value, since email *only* has strings, and our get_all() call + # above ensures that this is a list. + elif raw_name in _LIST_FIELDS: + raw[raw_name] = value + # Special Case: Keywords + # The keywords field is implemented in the metadata spec as a str, + # but it conceptually is a list of strings, and is serialized using + # ", ".join(keywords), so we'll do some light data massaging to turn + # this into what it logically is. + elif raw_name == "keywords" and len(value) == 1: + raw[raw_name] = _parse_keywords(value[0]) + # Special Case: Project-URL + # The project urls is implemented in the metadata spec as a list of + # specially-formatted strings that represent a key and a value, which + # is fundamentally a mapping, however the email format doesn't support + # mappings in a sane way, so it was crammed into a list of strings + # instead. + # + # We will do a little light data massaging to turn this into a map as + # it logically should be. + elif raw_name == "project_urls": + try: + raw[raw_name] = _parse_project_urls(value) + except KeyError: + unparsed[name] = value + # Nothing that we've done has managed to parse this, so it'll just + # throw it in our unparseable data and move on. + else: + unparsed[name] = value + + # We need to support getting the Description from the message payload in + # addition to getting it from the the headers. This does mean, though, there + # is the possibility of it being set both ways, in which case we put both + # in 'unparsed' since we don't know which is right. + try: + payload = _get_payload(parsed, data) + except ValueError: + unparsed.setdefault("description", []).append( + parsed.get_payload(decode=isinstance(data, bytes)) # type: ignore[call-overload] + ) + else: + if payload: + # Check to see if we've already got a description, if so then both + # it, and this body move to unparseable. + if "description" in raw: + description_header = cast(str, raw.pop("description")) + unparsed.setdefault("description", []).extend( + [description_header, payload] + ) + elif "description" in unparsed: + unparsed["description"].append(payload) + else: + raw["description"] = payload + + # We need to cast our `raw` to a metadata, because a TypedDict only support + # literal key names, but we're computing our key names on purpose, but the + # way this function is implemented, our `TypedDict` can only have valid key + # names. + return cast(RawMetadata, raw), unparsed + + +_NOT_FOUND = object() + + +# Keep the two values in sync. +_VALID_METADATA_VERSIONS = ["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"] +_MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3", "2.4"] + +_REQUIRED_ATTRS = frozenset(["metadata_version", "name", "version"]) + + +class _Validator(Generic[T]): + """Validate a metadata field. + + All _process_*() methods correspond to a core metadata field. The method is + called with the field's raw value. If the raw value is valid it is returned + in its "enriched" form (e.g. ``version.Version`` for the ``Version`` field). + If the raw value is invalid, :exc:`InvalidMetadata` is raised (with a cause + as appropriate). + """ + + name: str + raw_name: str + added: _MetadataVersion + + def __init__( + self, + *, + added: _MetadataVersion = "1.0", + ) -> None: + self.added = added + + def __set_name__(self, _owner: Metadata, name: str) -> None: + self.name = name + self.raw_name = _RAW_TO_EMAIL_MAPPING[name] + + def __get__(self, instance: Metadata, _owner: type[Metadata]) -> T: + # With Python 3.8, the caching can be replaced with functools.cached_property(). + # No need to check the cache as attribute lookup will resolve into the + # instance's __dict__ before __get__ is called. + cache = instance.__dict__ + value = instance._raw.get(self.name) + + # To make the _process_* methods easier, we'll check if the value is None + # and if this field is NOT a required attribute, and if both of those + # things are true, we'll skip the the converter. This will mean that the + # converters never have to deal with the None union. + if self.name in _REQUIRED_ATTRS or value is not None: + try: + converter: Callable[[Any], T] = getattr(self, f"_process_{self.name}") + except AttributeError: + pass + else: + value = converter(value) + + cache[self.name] = value + try: + del instance._raw[self.name] # type: ignore[misc] + except KeyError: + pass + + return cast(T, value) + + def _invalid_metadata( + self, msg: str, cause: Exception | None = None + ) -> InvalidMetadata: + exc = InvalidMetadata( + self.raw_name, msg.format_map({"field": repr(self.raw_name)}) + ) + exc.__cause__ = cause + return exc + + def _process_metadata_version(self, value: str) -> _MetadataVersion: + # Implicitly makes Metadata-Version required. + if value not in _VALID_METADATA_VERSIONS: + raise self._invalid_metadata(f"{value!r} is not a valid metadata version") + return cast(_MetadataVersion, value) + + def _process_name(self, value: str) -> str: + if not value: + raise self._invalid_metadata("{field} is a required field") + # Validate the name as a side-effect. + try: + utils.canonicalize_name(value, validate=True) + except utils.InvalidName as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return value + + def _process_version(self, value: str) -> version_module.Version: + if not value: + raise self._invalid_metadata("{field} is a required field") + try: + return version_module.parse(value) + except version_module.InvalidVersion as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_summary(self, value: str) -> str: + """Check the field contains no newlines.""" + if "\n" in value: + raise self._invalid_metadata("{field} must be a single line") + return value + + def _process_description_content_type(self, value: str) -> str: + content_types = {"text/plain", "text/x-rst", "text/markdown"} + message = email.message.EmailMessage() + message["content-type"] = value + + content_type, parameters = ( + # Defaults to `text/plain` if parsing failed. + message.get_content_type().lower(), + message["content-type"].params, + ) + # Check if content-type is valid or defaulted to `text/plain` and thus was + # not parseable. + if content_type not in content_types or content_type not in value.lower(): + raise self._invalid_metadata( + f"{{field}} must be one of {list(content_types)}, not {value!r}" + ) + + charset = parameters.get("charset", "UTF-8") + if charset != "UTF-8": + raise self._invalid_metadata( + f"{{field}} can only specify the UTF-8 charset, not {list(charset)}" + ) + + markdown_variants = {"GFM", "CommonMark"} + variant = parameters.get("variant", "GFM") # Use an acceptable default. + if content_type == "text/markdown" and variant not in markdown_variants: + raise self._invalid_metadata( + f"valid Markdown variants for {{field}} are {list(markdown_variants)}, " + f"not {variant!r}", + ) + return value + + def _process_dynamic(self, value: list[str]) -> list[str]: + for dynamic_field in map(str.lower, value): + if dynamic_field in {"name", "version", "metadata-version"}: + raise self._invalid_metadata( + f"{dynamic_field!r} is not allowed as a dynamic field" + ) + elif dynamic_field not in _EMAIL_TO_RAW_MAPPING: + raise self._invalid_metadata( + f"{dynamic_field!r} is not a valid dynamic field" + ) + return list(map(str.lower, value)) + + def _process_provides_extra( + self, + value: list[str], + ) -> list[utils.NormalizedName]: + normalized_names = [] + try: + for name in value: + normalized_names.append(utils.canonicalize_name(name, validate=True)) + except utils.InvalidName as exc: + raise self._invalid_metadata( + f"{name!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return normalized_names + + def _process_requires_python(self, value: str) -> specifiers.SpecifierSet: + try: + return specifiers.SpecifierSet(value) + except specifiers.InvalidSpecifier as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_requires_dist( + self, + value: list[str], + ) -> list[requirements.Requirement]: + reqs = [] + try: + for req in value: + reqs.append(requirements.Requirement(req)) + except requirements.InvalidRequirement as exc: + raise self._invalid_metadata( + f"{req!r} is invalid for {{field}}", cause=exc + ) from exc + else: + return reqs + + def _process_license_expression( + self, value: str + ) -> NormalizedLicenseExpression | None: + try: + return licenses.canonicalize_license_expression(value) + except ValueError as exc: + raise self._invalid_metadata( + f"{value!r} is invalid for {{field}}", cause=exc + ) from exc + + def _process_license_files(self, value: list[str]) -> list[str]: + paths = [] + for path in value: + if ".." in path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, " + "parent directory indicators are not allowed" + ) + if "*" in path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must be resolved" + ) + if ( + pathlib.PurePosixPath(path).is_absolute() + or pathlib.PureWindowsPath(path).is_absolute() + ): + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must be relative" + ) + if pathlib.PureWindowsPath(path).as_posix() != path: + raise self._invalid_metadata( + f"{path!r} is invalid for {{field}}, paths must use '/' delimiter" + ) + paths.append(path) + return paths + + +class Metadata: + """Representation of distribution metadata. + + Compared to :class:`RawMetadata`, this class provides objects representing + metadata fields instead of only using built-in types. Any invalid metadata + will cause :exc:`InvalidMetadata` to be raised (with a + :py:attr:`~BaseException.__cause__` attribute as appropriate). + """ + + _raw: RawMetadata + + @classmethod + def from_raw(cls, data: RawMetadata, *, validate: bool = True) -> Metadata: + """Create an instance from :class:`RawMetadata`. + + If *validate* is true, all metadata will be validated. All exceptions + related to validation will be gathered and raised as an :class:`ExceptionGroup`. + """ + ins = cls() + ins._raw = data.copy() # Mutations occur due to caching enriched values. + + if validate: + exceptions: list[Exception] = [] + try: + metadata_version = ins.metadata_version + metadata_age = _VALID_METADATA_VERSIONS.index(metadata_version) + except InvalidMetadata as metadata_version_exc: + exceptions.append(metadata_version_exc) + metadata_version = None + + # Make sure to check for the fields that are present, the required + # fields (so their absence can be reported). + fields_to_check = frozenset(ins._raw) | _REQUIRED_ATTRS + # Remove fields that have already been checked. + fields_to_check -= {"metadata_version"} + + for key in fields_to_check: + try: + if metadata_version: + # Can't use getattr() as that triggers descriptor protocol which + # will fail due to no value for the instance argument. + try: + field_metadata_version = cls.__dict__[key].added + except KeyError: + exc = InvalidMetadata(key, f"unrecognized field: {key!r}") + exceptions.append(exc) + continue + field_age = _VALID_METADATA_VERSIONS.index( + field_metadata_version + ) + if field_age > metadata_age: + field = _RAW_TO_EMAIL_MAPPING[key] + exc = InvalidMetadata( + field, + f"{field} introduced in metadata version " + f"{field_metadata_version}, not {metadata_version}", + ) + exceptions.append(exc) + continue + getattr(ins, key) + except InvalidMetadata as exc: + exceptions.append(exc) + + if exceptions: + raise ExceptionGroup("invalid metadata", exceptions) + + return ins + + @classmethod + def from_email(cls, data: bytes | str, *, validate: bool = True) -> Metadata: + """Parse metadata from email headers. + + If *validate* is true, the metadata will be validated. All exceptions + related to validation will be gathered and raised as an :class:`ExceptionGroup`. + """ + raw, unparsed = parse_email(data) + + if validate: + exceptions: list[Exception] = [] + for unparsed_key in unparsed: + if unparsed_key in _EMAIL_TO_RAW_MAPPING: + message = f"{unparsed_key!r} has invalid data" + else: + message = f"unrecognized field: {unparsed_key!r}" + exceptions.append(InvalidMetadata(unparsed_key, message)) + + if exceptions: + raise ExceptionGroup("unparsed", exceptions) + + try: + return cls.from_raw(raw, validate=validate) + except ExceptionGroup as exc_group: + raise ExceptionGroup( + "invalid or unparsed metadata", exc_group.exceptions + ) from None + + metadata_version: _Validator[_MetadataVersion] = _Validator() + """:external:ref:`core-metadata-metadata-version` + (required; validated to be a valid metadata version)""" + # `name` is not normalized/typed to NormalizedName so as to provide access to + # the original/raw name. + name: _Validator[str] = _Validator() + """:external:ref:`core-metadata-name` + (required; validated using :func:`~packaging.utils.canonicalize_name` and its + *validate* parameter)""" + version: _Validator[version_module.Version] = _Validator() + """:external:ref:`core-metadata-version` (required)""" + dynamic: _Validator[list[str] | None] = _Validator( + added="2.2", + ) + """:external:ref:`core-metadata-dynamic` + (validated against core metadata field names and lowercased)""" + platforms: _Validator[list[str] | None] = _Validator() + """:external:ref:`core-metadata-platform`""" + supported_platforms: _Validator[list[str] | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-supported-platform`""" + summary: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-summary` (validated to contain no newlines)""" + description: _Validator[str | None] = _Validator() # TODO 2.1: can be in body + """:external:ref:`core-metadata-description`""" + description_content_type: _Validator[str | None] = _Validator(added="2.1") + """:external:ref:`core-metadata-description-content-type` (validated)""" + keywords: _Validator[list[str] | None] = _Validator() + """:external:ref:`core-metadata-keywords`""" + home_page: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-home-page`""" + download_url: _Validator[str | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-download-url`""" + author: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-author`""" + author_email: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-author-email`""" + maintainer: _Validator[str | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-maintainer`""" + maintainer_email: _Validator[str | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-maintainer-email`""" + license: _Validator[str | None] = _Validator() + """:external:ref:`core-metadata-license`""" + license_expression: _Validator[NormalizedLicenseExpression | None] = _Validator( + added="2.4" + ) + """:external:ref:`core-metadata-license-expression`""" + license_files: _Validator[list[str] | None] = _Validator(added="2.4") + """:external:ref:`core-metadata-license-file`""" + classifiers: _Validator[list[str] | None] = _Validator(added="1.1") + """:external:ref:`core-metadata-classifier`""" + requires_dist: _Validator[list[requirements.Requirement] | None] = _Validator( + added="1.2" + ) + """:external:ref:`core-metadata-requires-dist`""" + requires_python: _Validator[specifiers.SpecifierSet | None] = _Validator( + added="1.2" + ) + """:external:ref:`core-metadata-requires-python`""" + # Because `Requires-External` allows for non-PEP 440 version specifiers, we + # don't do any processing on the values. + requires_external: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-requires-external`""" + project_urls: _Validator[dict[str, str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-project-url`""" + # PEP 685 lets us raise an error if an extra doesn't pass `Name` validation + # regardless of metadata version. + provides_extra: _Validator[list[utils.NormalizedName] | None] = _Validator( + added="2.1", + ) + """:external:ref:`core-metadata-provides-extra`""" + provides_dist: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-provides-dist`""" + obsoletes_dist: _Validator[list[str] | None] = _Validator(added="1.2") + """:external:ref:`core-metadata-obsoletes-dist`""" + requires: _Validator[list[str] | None] = _Validator(added="1.1") + """``Requires`` (deprecated)""" + provides: _Validator[list[str] | None] = _Validator(added="1.1") + """``Provides`` (deprecated)""" + obsoletes: _Validator[list[str] | None] = _Validator(added="1.1") + """``Obsoletes`` (deprecated)""" diff --git a/.venv/lib/python3.13/site-packages/packaging/py.typed b/.venv/lib/python3.13/site-packages/packaging/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.13/site-packages/packaging/requirements.py b/.venv/lib/python3.13/site-packages/packaging/requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..4e068c9567def3564f238a76fe7ab46b569f33e5 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/requirements.py @@ -0,0 +1,91 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +from __future__ import annotations + +from typing import Any, Iterator + +from ._parser import parse_requirement as _parse_requirement +from ._tokenizer import ParserSyntaxError +from .markers import Marker, _normalize_extra_values +from .specifiers import SpecifierSet +from .utils import canonicalize_name + + +class InvalidRequirement(ValueError): + """ + An invalid requirement was found, users should refer to PEP 508. + """ + + +class Requirement: + """Parse a requirement. + + Parse a given requirement string into its parts, such as name, specifier, + URL, and extras. Raises InvalidRequirement on a badly-formed requirement + string. + """ + + # TODO: Can we test whether something is contained within a requirement? + # If so how do we do that? Do we need to test against the _name_ of + # the thing as well as the version? What about the markers? + # TODO: Can we normalize the name and extra name? + + def __init__(self, requirement_string: str) -> None: + try: + parsed = _parse_requirement(requirement_string) + except ParserSyntaxError as e: + raise InvalidRequirement(str(e)) from e + + self.name: str = parsed.name + self.url: str | None = parsed.url or None + self.extras: set[str] = set(parsed.extras or []) + self.specifier: SpecifierSet = SpecifierSet(parsed.specifier) + self.marker: Marker | None = None + if parsed.marker is not None: + self.marker = Marker.__new__(Marker) + self.marker._markers = _normalize_extra_values(parsed.marker) + + def _iter_parts(self, name: str) -> Iterator[str]: + yield name + + if self.extras: + formatted_extras = ",".join(sorted(self.extras)) + yield f"[{formatted_extras}]" + + if self.specifier: + yield str(self.specifier) + + if self.url: + yield f"@ {self.url}" + if self.marker: + yield " " + + if self.marker: + yield f"; {self.marker}" + + def __str__(self) -> str: + return "".join(self._iter_parts(self.name)) + + def __repr__(self) -> str: + return f"" + + def __hash__(self) -> int: + return hash( + ( + self.__class__.__name__, + *self._iter_parts(canonicalize_name(self.name)), + ) + ) + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, Requirement): + return NotImplemented + + return ( + canonicalize_name(self.name) == canonicalize_name(other.name) + and self.extras == other.extras + and self.specifier == other.specifier + and self.url == other.url + and self.marker == other.marker + ) diff --git a/.venv/lib/python3.13/site-packages/packaging/specifiers.py b/.venv/lib/python3.13/site-packages/packaging/specifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..c8448043006f1c60ee92df69da47986d10229b1d --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/specifiers.py @@ -0,0 +1,1019 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier + from packaging.version import Version +""" + +from __future__ import annotations + +import abc +import itertools +import re +from typing import Callable, Iterable, Iterator, TypeVar, Union + +from .utils import canonicalize_version +from .version import Version + +UnparsedVersion = Union[Version, str] +UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion) +CallableOperator = Callable[[Version, str], bool] + + +def _coerce_version(version: UnparsedVersion) -> Version: + if not isinstance(version, Version): + version = Version(version) + return version + + +class InvalidSpecifier(ValueError): + """ + Raised when attempting to create a :class:`Specifier` with a specifier + string that is invalid. + + >>> Specifier("lolwat") + Traceback (most recent call last): + ... + packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' + """ + + +class BaseSpecifier(metaclass=abc.ABCMeta): + @abc.abstractmethod + def __str__(self) -> str: + """ + Returns the str representation of this Specifier-like object. This + should be representative of the Specifier itself. + """ + + @abc.abstractmethod + def __hash__(self) -> int: + """ + Returns a hash value for this Specifier-like object. + """ + + @abc.abstractmethod + def __eq__(self, other: object) -> bool: + """ + Returns a boolean representing whether or not the two Specifier-like + objects are equal. + + :param other: The other object to check against. + """ + + @property + @abc.abstractmethod + def prereleases(self) -> bool | None: + """Whether or not pre-releases as a whole are allowed. + + This can be set to either ``True`` or ``False`` to explicitly enable or disable + prereleases or it can be set to ``None`` (the default) to use default semantics. + """ + + @prereleases.setter + def prereleases(self, value: bool) -> None: + """Setter for :attr:`prereleases`. + + :param value: The value to set. + """ + + @abc.abstractmethod + def contains(self, item: str, prereleases: bool | None = None) -> bool: + """ + Determines if the given item is contained within this specifier. + """ + + @abc.abstractmethod + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """ + Takes an iterable of items and filters them so that only items which + are contained within this specifier are allowed in it. + """ + + +class Specifier(BaseSpecifier): + """This class abstracts handling of version specifiers. + + .. tip:: + + It is generally not required to instantiate this manually. You should instead + prefer to work with :class:`SpecifierSet` instead, which can parse + comma-separated version specifiers (which is what package metadata contains). + """ + + _operator_regex_str = r""" + (?P(~=|==|!=|<=|>=|<|>|===)) + """ + _version_regex_str = r""" + (?P + (?: + # The identity operators allow for an escape hatch that will + # do an exact string match of the version you wish to install. + # This will not be parsed by PEP 440 and we cannot determine + # any semantic meaning from it. This operator is discouraged + # but included entirely as an escape hatch. + (?<====) # Only match for the identity operator + \s* + [^\s;)]* # The arbitrary version can be just about anything, + # we match everything except for whitespace, a + # semi-colon for marker support, and a closing paren + # since versions can be enclosed in them. + ) + | + (?: + # The (non)equality operators allow for wild card and local + # versions to be specified so we have to define these two + # operators separately to enable that. + (?<===|!=) # Only match for equals and not equals + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)* # release + + # You cannot use a wild card and a pre-release, post-release, a dev or + # local version together so group them with a | and make them optional. + (?: + \.\* # Wild card syntax of .* + | + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local + )? + ) + | + (?: + # The compatible operator requires at least two digits in the + # release segment. + (?<=~=) # Only match for the compatible operator + + \s* + v? + (?:[0-9]+!)? # epoch + [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) + (?: # pre release + [-_\.]? + (alpha|beta|preview|pre|a|b|c|rc) + [-_\.]? + [0-9]* + )? + (?: # post release + (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) + )? + (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release + ) + | + (?: + # All other operators only allow a sub set of what the + # (non)equality operators do. Specifically they do not allow + # local versions to be specified nor do they allow the prefix + # matching wild cards. + (?=": "greater_than_equal", + "<": "less_than", + ">": "greater_than", + "===": "arbitrary", + } + + def __init__(self, spec: str = "", prereleases: bool | None = None) -> None: + """Initialize a Specifier instance. + + :param spec: + The string representation of a specifier which will be parsed and + normalized before use. + :param prereleases: + This tells the specifier if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + :raises InvalidSpecifier: + If the given specifier is invalid (i.e. bad syntax). + """ + match = self._regex.search(spec) + if not match: + raise InvalidSpecifier(f"Invalid specifier: {spec!r}") + + self._spec: tuple[str, str] = ( + match.group("operator").strip(), + match.group("version").strip(), + ) + + # Store whether or not this Specifier should accept prereleases + self._prereleases = prereleases + + # https://github.com/python/mypy/pull/13475#pullrequestreview-1079784515 + @property # type: ignore[override] + def prereleases(self) -> bool: + # If there is an explicit prereleases set for this, then we'll just + # blindly use that. + if self._prereleases is not None: + return self._prereleases + + # Look at all of our specifiers and determine if they are inclusive + # operators, and if they are if they are including an explicit + # prerelease. + operator, version = self._spec + if operator in ["==", ">=", "<=", "~=", "===", ">", "<"]: + # The == specifier can include a trailing .*, if it does we + # want to remove before parsing. + if operator == "==" and version.endswith(".*"): + version = version[:-2] + + # Parse the version, and if it is a pre-release than this + # specifier allows pre-releases. + if Version(version).is_prerelease: + return True + + return False + + @prereleases.setter + def prereleases(self, value: bool) -> None: + self._prereleases = value + + @property + def operator(self) -> str: + """The operator of this specifier. + + >>> Specifier("==1.2.3").operator + '==' + """ + return self._spec[0] + + @property + def version(self) -> str: + """The version of this specifier. + + >>> Specifier("==1.2.3").version + '1.2.3' + """ + return self._spec[1] + + def __repr__(self) -> str: + """A representation of the Specifier that shows all internal state. + + >>> Specifier('>=1.0.0') + =1.0.0')> + >>> Specifier('>=1.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> Specifier('>=1.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"<{self.__class__.__name__}({str(self)!r}{pre})>" + + def __str__(self) -> str: + """A string representation of the Specifier that can be round-tripped. + + >>> str(Specifier('>=1.0.0')) + '>=1.0.0' + >>> str(Specifier('>=1.0.0', prereleases=False)) + '>=1.0.0' + """ + return "{}{}".format(*self._spec) + + @property + def _canonical_spec(self) -> tuple[str, str]: + canonical_version = canonicalize_version( + self._spec[1], + strip_trailing_zero=(self._spec[0] != "~="), + ) + return self._spec[0], canonical_version + + def __hash__(self) -> int: + return hash(self._canonical_spec) + + def __eq__(self, other: object) -> bool: + """Whether or not the two Specifier-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") + True + >>> (Specifier("==1.2.3", prereleases=False) == + ... Specifier("==1.2.3", prereleases=True)) + True + >>> Specifier("==1.2.3") == "==1.2.3" + True + >>> Specifier("==1.2.3") == Specifier("==1.2.4") + False + >>> Specifier("==1.2.3") == Specifier("~=1.2.3") + False + """ + if isinstance(other, str): + try: + other = self.__class__(str(other)) + except InvalidSpecifier: + return NotImplemented + elif not isinstance(other, self.__class__): + return NotImplemented + + return self._canonical_spec == other._canonical_spec + + def _get_operator(self, op: str) -> CallableOperator: + operator_callable: CallableOperator = getattr( + self, f"_compare_{self._operators[op]}" + ) + return operator_callable + + def _compare_compatible(self, prospective: Version, spec: str) -> bool: + # Compatible releases have an equivalent combination of >= and ==. That + # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to + # implement this in terms of the other specifiers instead of + # implementing it ourselves. The only thing we need to do is construct + # the other specifiers. + + # We want everything but the last item in the version, but we want to + # ignore suffix segments. + prefix = _version_join( + list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] + ) + + # Add the prefix notation to the end of our string + prefix += ".*" + + return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( + prospective, prefix + ) + + def _compare_equal(self, prospective: Version, spec: str) -> bool: + # We need special logic to handle prefix matching + if spec.endswith(".*"): + # In the case of prefix matching we want to ignore local segment. + normalized_prospective = canonicalize_version( + prospective.public, strip_trailing_zero=False + ) + # Get the normalized version string ignoring the trailing .* + normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False) + # Split the spec out by bangs and dots, and pretend that there is + # an implicit dot in between a release segment and a pre-release segment. + split_spec = _version_split(normalized_spec) + + # Split the prospective version out by bangs and dots, and pretend + # that there is an implicit dot in between a release segment and + # a pre-release segment. + split_prospective = _version_split(normalized_prospective) + + # 0-pad the prospective version before shortening it to get the correct + # shortened version. + padded_prospective, _ = _pad_version(split_prospective, split_spec) + + # Shorten the prospective version to be the same length as the spec + # so that we can determine if the specifier is a prefix of the + # prospective version or not. + shortened_prospective = padded_prospective[: len(split_spec)] + + return shortened_prospective == split_spec + else: + # Convert our spec string into a Version + spec_version = Version(spec) + + # If the specifier does not have a local segment, then we want to + # act as if the prospective version also does not have a local + # segment. + if not spec_version.local: + prospective = Version(prospective.public) + + return prospective == spec_version + + def _compare_not_equal(self, prospective: Version, spec: str) -> bool: + return not self._compare_equal(prospective, spec) + + def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return Version(prospective.public) <= Version(spec) + + def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool: + # NB: Local version identifiers are NOT permitted in the version + # specifier, so local version labels can be universally removed from + # the prospective version. + return Version(prospective.public) >= Version(spec) + + def _compare_less_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = Version(spec_str) + + # Check to see if the prospective version is less than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective < spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a pre-release version, that we do not accept pre-release + # versions for the version mentioned in the specifier (e.g. <3.1 should + # not match 3.1.dev0, but should match 3.0.dev0). + if not spec.is_prerelease and prospective.is_prerelease: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # If we've gotten to here, it means that prospective version is both + # less than the spec version *and* it's not a pre-release of the same + # version in the spec. + return True + + def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool: + # Convert our spec to a Version instance, since we'll want to work with + # it as a version. + spec = Version(spec_str) + + # Check to see if the prospective version is greater than the spec + # version. If it's not we can short circuit and just return False now + # instead of doing extra unneeded work. + if not prospective > spec: + return False + + # This special case is here so that, unless the specifier itself + # includes is a post-release version, that we do not accept + # post-release versions for the version mentioned in the specifier + # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). + if not spec.is_postrelease and prospective.is_postrelease: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # Ensure that we do not allow a local version of the version mentioned + # in the specifier, which is technically greater than, to match. + if prospective.local is not None: + if Version(prospective.base_version) == Version(spec.base_version): + return False + + # If we've gotten to here, it means that prospective version is both + # greater than the spec version *and* it's not a pre-release of the + # same version in the spec. + return True + + def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: + return str(prospective).lower() == str(spec).lower() + + def __contains__(self, item: str | Version) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in Specifier(">=1.2.3") + True + >>> Version("1.2.3") in Specifier(">=1.2.3") + True + >>> "1.0.0" in Specifier(">=1.2.3") + False + >>> "1.3.0a1" in Specifier(">=1.2.3") + False + >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) + True + """ + return self.contains(item) + + def contains(self, item: UnparsedVersion, prereleases: bool | None = None) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this Specifier. If set to + ``None`` (the default), it uses :attr:`prereleases` to determine + whether or not prereleases are allowed. + + >>> Specifier(">=1.2.3").contains("1.2.3") + True + >>> Specifier(">=1.2.3").contains(Version("1.2.3")) + True + >>> Specifier(">=1.2.3").contains("1.0.0") + False + >>> Specifier(">=1.2.3").contains("1.3.0a1") + False + >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") + True + >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) + True + """ + + # Determine if prereleases are to be allowed or not. + if prereleases is None: + prereleases = self.prereleases + + # Normalize item to a Version, this allows us to have a shortcut for + # "2.0" in Specifier(">=2") + normalized_item = _coerce_version(item) + + # Determine if we should be supporting prereleases in this specifier + # or not, if we do not support prereleases than we can short circuit + # logic if this version is a prereleases. + if normalized_item.is_prerelease and not prereleases: + return False + + # Actually do the comparison to determine if this item is contained + # within this Specifier or not. + operator_callable: CallableOperator = self._get_operator(self.operator) + return operator_callable(normalized_item, self.version) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifier. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will be intelligently decide whether to allow + prereleases or not (based on the :attr:`prereleases` attribute, and + whether the only versions matching are prereleases). + + This method is smarter than just ``filter(Specifier().contains, [...])`` + because it implements the rule from :pep:`440` that a prerelease item + SHOULD be accepted if no other versions match the given specifier. + + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) + ['1.2.3', '1.3', ] + >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) + ['1.5a1'] + >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + """ + + yielded = False + found_prereleases = [] + + kw = {"prereleases": prereleases if prereleases is not None else True} + + # Attempt to iterate over all the values in the iterable and if any of + # them match, yield them. + for version in iterable: + parsed_version = _coerce_version(version) + + if self.contains(parsed_version, **kw): + # If our version is a prerelease, and we were not set to allow + # prereleases, then we'll store it for later in case nothing + # else matches this specifier. + if parsed_version.is_prerelease and not ( + prereleases or self.prereleases + ): + found_prereleases.append(version) + # Either this is not a prerelease, or we should have been + # accepting prereleases from the beginning. + else: + yielded = True + yield version + + # Now that we've iterated over everything, determine if we've yielded + # any values, and if we have not and we have any prereleases stored up + # then we will go ahead and yield the prereleases. + if not yielded and found_prereleases: + for version in found_prereleases: + yield version + + +_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") + + +def _version_split(version: str) -> list[str]: + """Split version into components. + + The split components are intended for version comparison. The logic does + not attempt to retain the original version string, so joining the + components back with :func:`_version_join` may not produce the original + version string. + """ + result: list[str] = [] + + epoch, _, rest = version.rpartition("!") + result.append(epoch or "0") + + for item in rest.split("."): + match = _prefix_regex.search(item) + if match: + result.extend(match.groups()) + else: + result.append(item) + return result + + +def _version_join(components: list[str]) -> str: + """Join split version components into a version string. + + This function assumes the input came from :func:`_version_split`, where the + first component must be the epoch (either empty or numeric), and all other + components numeric. + """ + epoch, *rest = components + return f"{epoch}!{'.'.join(rest)}" + + +def _is_not_suffix(segment: str) -> bool: + return not any( + segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") + ) + + +def _pad_version(left: list[str], right: list[str]) -> tuple[list[str], list[str]]: + left_split, right_split = [], [] + + # Get the release segment of our versions + left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) + right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) + + # Get the rest of our versions + left_split.append(left[len(left_split[0]) :]) + right_split.append(right[len(right_split[0]) :]) + + # Insert our padding + left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) + right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) + + return ( + list(itertools.chain.from_iterable(left_split)), + list(itertools.chain.from_iterable(right_split)), + ) + + +class SpecifierSet(BaseSpecifier): + """This class abstracts handling of a set of version specifiers. + + It can be passed a single specifier (``>=3.0``), a comma-separated list of + specifiers (``>=3.0,!=3.1``), or no specifier at all. + """ + + def __init__( + self, + specifiers: str | Iterable[Specifier] = "", + prereleases: bool | None = None, + ) -> None: + """Initialize a SpecifierSet instance. + + :param specifiers: + The string representation of a specifier or a comma-separated list of + specifiers which will be parsed and normalized before use. + May also be an iterable of ``Specifier`` instances, which will be used + as is. + :param prereleases: + This tells the SpecifierSet if it should accept prerelease versions if + applicable or not. The default of ``None`` will autodetect it from the + given specifiers. + + :raises InvalidSpecifier: + If the given ``specifiers`` are not parseable than this exception will be + raised. + """ + + if isinstance(specifiers, str): + # Split on `,` to break each individual specifier into its own item, and + # strip each item to remove leading/trailing whitespace. + split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] + + # Make each individual specifier a Specifier and save in a frozen set + # for later. + self._specs = frozenset(map(Specifier, split_specifiers)) + else: + # Save the supplied specifiers in a frozen set. + self._specs = frozenset(specifiers) + + # Store our prereleases value so we can use it later to determine if + # we accept prereleases or not. + self._prereleases = prereleases + + @property + def prereleases(self) -> bool | None: + # If we have been given an explicit prerelease modifier, then we'll + # pass that through here. + if self._prereleases is not None: + return self._prereleases + + # If we don't have any specifiers, and we don't have a forced value, + # then we'll just return None since we don't know if this should have + # pre-releases or not. + if not self._specs: + return None + + # Otherwise we'll see if any of the given specifiers accept + # prereleases, if any of them do we'll return True, otherwise False. + return any(s.prereleases for s in self._specs) + + @prereleases.setter + def prereleases(self, value: bool) -> None: + self._prereleases = value + + def __repr__(self) -> str: + """A representation of the specifier set that shows all internal state. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> SpecifierSet('>=1.0.0,!=2.0.0') + =1.0.0')> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) + =1.0.0', prereleases=False)> + >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) + =1.0.0', prereleases=True)> + """ + pre = ( + f", prereleases={self.prereleases!r}" + if self._prereleases is not None + else "" + ) + + return f"" + + def __str__(self) -> str: + """A string representation of the specifier set that can be round-tripped. + + Note that the ordering of the individual specifiers within the set may not + match the input string. + + >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) + '!=1.0.1,>=1.0.0' + >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) + '!=1.0.1,>=1.0.0' + """ + return ",".join(sorted(str(s) for s in self._specs)) + + def __hash__(self) -> int: + return hash(self._specs) + + def __and__(self, other: SpecifierSet | str) -> SpecifierSet: + """Return a SpecifierSet which is a combination of the two sets. + + :param other: The other object to combine with. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' + =1.0.0')> + >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') + =1.0.0')> + """ + if isinstance(other, str): + other = SpecifierSet(other) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + specifier = SpecifierSet() + specifier._specs = frozenset(self._specs | other._specs) + + if self._prereleases is None and other._prereleases is not None: + specifier._prereleases = other._prereleases + elif self._prereleases is not None and other._prereleases is None: + specifier._prereleases = self._prereleases + elif self._prereleases == other._prereleases: + specifier._prereleases = self._prereleases + else: + raise ValueError( + "Cannot combine SpecifierSets with True and False prerelease overrides." + ) + + return specifier + + def __eq__(self, other: object) -> bool: + """Whether or not the two SpecifierSet-like objects are equal. + + :param other: The other object to check against. + + The value of :attr:`prereleases` is ignored. + + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == + ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" + True + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") + False + """ + if isinstance(other, (str, Specifier)): + other = SpecifierSet(str(other)) + elif not isinstance(other, SpecifierSet): + return NotImplemented + + return self._specs == other._specs + + def __len__(self) -> int: + """Returns the number of specifiers in this specifier set.""" + return len(self._specs) + + def __iter__(self) -> Iterator[Specifier]: + """ + Returns an iterator over all the underlying :class:`Specifier` instances + in this specifier set. + + >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) + [, =1.0.0')>] + """ + return iter(self._specs) + + def __contains__(self, item: UnparsedVersion) -> bool: + """Return whether or not the item is contained in this specifier. + + :param item: The item to check for. + + This is used for the ``in`` operator and behaves the same as + :meth:`contains` with no ``prereleases`` argument passed. + + >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") + True + >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") + False + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") + False + >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) + True + """ + return self.contains(item) + + def contains( + self, + item: UnparsedVersion, + prereleases: bool | None = None, + installed: bool | None = None, + ) -> bool: + """Return whether or not the item is contained in this SpecifierSet. + + :param item: + The item to check for, which can be a version string or a + :class:`Version` instance. + :param prereleases: + Whether or not to match prereleases with this SpecifierSet. If set to + ``None`` (the default), it uses :attr:`prereleases` to determine + whether or not prereleases are allowed. + + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") + False + >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") + True + >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) + True + """ + # Ensure that our item is a Version instance. + if not isinstance(item, Version): + item = Version(item) + + # Determine if we're forcing a prerelease or not, if we're not forcing + # one for this particular filter call, then we'll use whatever the + # SpecifierSet thinks for whether or not we should support prereleases. + if prereleases is None: + prereleases = self.prereleases + + # We can determine if we're going to allow pre-releases by looking to + # see if any of the underlying items supports them. If none of them do + # and this item is a pre-release then we do not allow it and we can + # short circuit that here. + # Note: This means that 1.0.dev1 would not be contained in something + # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 + if not prereleases and item.is_prerelease: + return False + + if installed and item.is_prerelease: + item = Version(item.base_version) + + # We simply dispatch to the underlying specs here to make sure that the + # given version is contained within all of them. + # Note: This use of all() here means that an empty set of specifiers + # will always return True, this is an explicit design decision. + return all(s.contains(item, prereleases=prereleases) for s in self._specs) + + def filter( + self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None + ) -> Iterator[UnparsedVersionVar]: + """Filter items in the given iterable, that match the specifiers in this set. + + :param iterable: + An iterable that can contain version strings and :class:`Version` instances. + The items in the iterable will be filtered according to the specifier. + :param prereleases: + Whether or not to allow prereleases in the returned iterator. If set to + ``None`` (the default), it will be intelligently decide whether to allow + prereleases or not (based on the :attr:`prereleases` attribute, and + whether the only versions matching are prereleases). + + This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` + because it implements the rule from :pep:`440` that a prerelease item + SHOULD be accepted if no other versions match the given specifier. + + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) + ['1.3', ] + >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) + [] + >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + + An "empty" SpecifierSet will filter items based on the presence of prerelease + versions in the set. + + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) + ['1.3'] + >>> list(SpecifierSet("").filter(["1.5a1"])) + ['1.5a1'] + >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) + ['1.3', '1.5a1'] + >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) + ['1.3', '1.5a1'] + """ + # Determine if we're forcing a prerelease or not, if we're not forcing + # one for this particular filter call, then we'll use whatever the + # SpecifierSet thinks for whether or not we should support prereleases. + if prereleases is None: + prereleases = self.prereleases + + # If we have any specifiers, then we want to wrap our iterable in the + # filter method for each one, this will act as a logical AND amongst + # each specifier. + if self._specs: + for spec in self._specs: + iterable = spec.filter(iterable, prereleases=bool(prereleases)) + return iter(iterable) + # If we do not have any specifiers, then we need to have a rough filter + # which will filter out any pre-releases, unless there are no final + # releases. + else: + filtered: list[UnparsedVersionVar] = [] + found_prereleases: list[UnparsedVersionVar] = [] + + for item in iterable: + parsed_version = _coerce_version(item) + + # Store any item which is a pre-release for later unless we've + # already found a final version or we are accepting prereleases + if parsed_version.is_prerelease and not prereleases: + if not filtered: + found_prereleases.append(item) + else: + filtered.append(item) + + # If we've found no items except for pre-releases, then we'll go + # ahead and use the pre-releases + if not filtered and found_prereleases and prereleases is None: + return iter(found_prereleases) + + return iter(filtered) diff --git a/.venv/lib/python3.13/site-packages/packaging/tags.py b/.venv/lib/python3.13/site-packages/packaging/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..8522f59c4f2d0039c1a02ea9aef66fe017dbdb20 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/tags.py @@ -0,0 +1,656 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import logging +import platform +import re +import struct +import subprocess +import sys +import sysconfig +from importlib.machinery import EXTENSION_SUFFIXES +from typing import ( + Iterable, + Iterator, + Sequence, + Tuple, + cast, +) + +from . import _manylinux, _musllinux + +logger = logging.getLogger(__name__) + +PythonVersion = Sequence[int] +AppleVersion = Tuple[int, int] + +INTERPRETER_SHORT_NAMES: dict[str, str] = { + "python": "py", # Generic. + "cpython": "cp", + "pypy": "pp", + "ironpython": "ip", + "jython": "jy", +} + + +_32_BIT_INTERPRETER = struct.calcsize("P") == 4 + + +class Tag: + """ + A representation of the tag triple for a wheel. + + Instances are considered immutable and thus are hashable. Equality checking + is also supported. + """ + + __slots__ = ["_abi", "_hash", "_interpreter", "_platform"] + + def __init__(self, interpreter: str, abi: str, platform: str) -> None: + self._interpreter = interpreter.lower() + self._abi = abi.lower() + self._platform = platform.lower() + # The __hash__ of every single element in a Set[Tag] will be evaluated each time + # that a set calls its `.disjoint()` method, which may be called hundreds of + # times when scanning a page of links for packages with tags matching that + # Set[Tag]. Pre-computing the value here produces significant speedups for + # downstream consumers. + self._hash = hash((self._interpreter, self._abi, self._platform)) + + @property + def interpreter(self) -> str: + return self._interpreter + + @property + def abi(self) -> str: + return self._abi + + @property + def platform(self) -> str: + return self._platform + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Tag): + return NotImplemented + + return ( + (self._hash == other._hash) # Short-circuit ASAP for perf reasons. + and (self._platform == other._platform) + and (self._abi == other._abi) + and (self._interpreter == other._interpreter) + ) + + def __hash__(self) -> int: + return self._hash + + def __str__(self) -> str: + return f"{self._interpreter}-{self._abi}-{self._platform}" + + def __repr__(self) -> str: + return f"<{self} @ {id(self)}>" + + +def parse_tag(tag: str) -> frozenset[Tag]: + """ + Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. + + Returning a set is required due to the possibility that the tag is a + compressed tag set. + """ + tags = set() + interpreters, abis, platforms = tag.split("-") + for interpreter in interpreters.split("."): + for abi in abis.split("."): + for platform_ in platforms.split("."): + tags.add(Tag(interpreter, abi, platform_)) + return frozenset(tags) + + +def _get_config_var(name: str, warn: bool = False) -> int | str | None: + value: int | str | None = sysconfig.get_config_var(name) + if value is None and warn: + logger.debug( + "Config variable '%s' is unset, Python ABI tag may be incorrect", name + ) + return value + + +def _normalize_string(string: str) -> str: + return string.replace(".", "_").replace("-", "_").replace(" ", "_") + + +def _is_threaded_cpython(abis: list[str]) -> bool: + """ + Determine if the ABI corresponds to a threaded (`--disable-gil`) build. + + The threaded builds are indicated by a "t" in the abiflags. + """ + if len(abis) == 0: + return False + # expect e.g., cp313 + m = re.match(r"cp\d+(.*)", abis[0]) + if not m: + return False + abiflags = m.group(1) + return "t" in abiflags + + +def _abi3_applies(python_version: PythonVersion, threading: bool) -> bool: + """ + Determine if the Python version supports abi3. + + PEP 384 was first implemented in Python 3.2. The threaded (`--disable-gil`) + builds do not support abi3. + """ + return len(python_version) > 1 and tuple(python_version) >= (3, 2) and not threading + + +def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> list[str]: + py_version = tuple(py_version) # To allow for version comparison. + abis = [] + version = _version_nodot(py_version[:2]) + threading = debug = pymalloc = ucs4 = "" + with_debug = _get_config_var("Py_DEBUG", warn) + has_refcount = hasattr(sys, "gettotalrefcount") + # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled + # extension modules is the best option. + # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 + has_ext = "_d.pyd" in EXTENSION_SUFFIXES + if with_debug or (with_debug is None and (has_refcount or has_ext)): + debug = "d" + if py_version >= (3, 13) and _get_config_var("Py_GIL_DISABLED", warn): + threading = "t" + if py_version < (3, 8): + with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) + if with_pymalloc or with_pymalloc is None: + pymalloc = "m" + if py_version < (3, 3): + unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) + if unicode_size == 4 or ( + unicode_size is None and sys.maxunicode == 0x10FFFF + ): + ucs4 = "u" + elif debug: + # Debug builds can also load "normal" extension modules. + # We can also assume no UCS-4 or pymalloc requirement. + abis.append(f"cp{version}{threading}") + abis.insert(0, f"cp{version}{threading}{debug}{pymalloc}{ucs4}") + return abis + + +def cpython_tags( + python_version: PythonVersion | None = None, + abis: Iterable[str] | None = None, + platforms: Iterable[str] | None = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a CPython interpreter. + + The tags consist of: + - cp-- + - cp-abi3- + - cp-none- + - cp-abi3- # Older Python versions down to 3.2. + + If python_version only specifies a major version then user-provided ABIs and + the 'none' ABItag will be used. + + If 'abi3' or 'none' are specified in 'abis' then they will be yielded at + their normal position and not at the beginning. + """ + if not python_version: + python_version = sys.version_info[:2] + + interpreter = f"cp{_version_nodot(python_version[:2])}" + + if abis is None: + if len(python_version) > 1: + abis = _cpython_abis(python_version, warn) + else: + abis = [] + abis = list(abis) + # 'abi3' and 'none' are explicitly handled later. + for explicit_abi in ("abi3", "none"): + try: + abis.remove(explicit_abi) + except ValueError: + pass + + platforms = list(platforms or platform_tags()) + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + threading = _is_threaded_cpython(abis) + use_abi3 = _abi3_applies(python_version, threading) + if use_abi3: + yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) + yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) + + if use_abi3: + for minor_version in range(python_version[1] - 1, 1, -1): + for platform_ in platforms: + version = _version_nodot((python_version[0], minor_version)) + interpreter = f"cp{version}" + yield Tag(interpreter, "abi3", platform_) + + +def _generic_abi() -> list[str]: + """ + Return the ABI tag based on EXT_SUFFIX. + """ + # The following are examples of `EXT_SUFFIX`. + # We want to keep the parts which are related to the ABI and remove the + # parts which are related to the platform: + # - linux: '.cpython-310-x86_64-linux-gnu.so' => cp310 + # - mac: '.cpython-310-darwin.so' => cp310 + # - win: '.cp310-win_amd64.pyd' => cp310 + # - win: '.pyd' => cp37 (uses _cpython_abis()) + # - pypy: '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73 + # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib' + # => graalpy_38_native + + ext_suffix = _get_config_var("EXT_SUFFIX", warn=True) + if not isinstance(ext_suffix, str) or ext_suffix[0] != ".": + raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')") + parts = ext_suffix.split(".") + if len(parts) < 3: + # CPython3.7 and earlier uses ".pyd" on Windows. + return _cpython_abis(sys.version_info[:2]) + soabi = parts[1] + if soabi.startswith("cpython"): + # non-windows + abi = "cp" + soabi.split("-")[1] + elif soabi.startswith("cp"): + # windows + abi = soabi.split("-")[0] + elif soabi.startswith("pypy"): + abi = "-".join(soabi.split("-")[:2]) + elif soabi.startswith("graalpy"): + abi = "-".join(soabi.split("-")[:3]) + elif soabi: + # pyston, ironpython, others? + abi = soabi + else: + return [] + return [_normalize_string(abi)] + + +def generic_tags( + interpreter: str | None = None, + abis: Iterable[str] | None = None, + platforms: Iterable[str] | None = None, + *, + warn: bool = False, +) -> Iterator[Tag]: + """ + Yields the tags for a generic interpreter. + + The tags consist of: + - -- + + The "none" ABI will be added if it was not explicitly provided. + """ + if not interpreter: + interp_name = interpreter_name() + interp_version = interpreter_version(warn=warn) + interpreter = "".join([interp_name, interp_version]) + if abis is None: + abis = _generic_abi() + else: + abis = list(abis) + platforms = list(platforms or platform_tags()) + if "none" not in abis: + abis.append("none") + for abi in abis: + for platform_ in platforms: + yield Tag(interpreter, abi, platform_) + + +def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: + """ + Yields Python versions in descending order. + + After the latest version, the major-only version will be yielded, and then + all previous versions of that major version. + """ + if len(py_version) > 1: + yield f"py{_version_nodot(py_version[:2])}" + yield f"py{py_version[0]}" + if len(py_version) > 1: + for minor in range(py_version[1] - 1, -1, -1): + yield f"py{_version_nodot((py_version[0], minor))}" + + +def compatible_tags( + python_version: PythonVersion | None = None, + interpreter: str | None = None, + platforms: Iterable[str] | None = None, +) -> Iterator[Tag]: + """ + Yields the sequence of tags that are compatible with a specific version of Python. + + The tags consist of: + - py*-none- + - -none-any # ... if `interpreter` is provided. + - py*-none-any + """ + if not python_version: + python_version = sys.version_info[:2] + platforms = list(platforms or platform_tags()) + for version in _py_interpreter_range(python_version): + for platform_ in platforms: + yield Tag(version, "none", platform_) + if interpreter: + yield Tag(interpreter, "none", "any") + for version in _py_interpreter_range(python_version): + yield Tag(version, "none", "any") + + +def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: + if not is_32bit: + return arch + + if arch.startswith("ppc"): + return "ppc" + + return "i386" + + +def _mac_binary_formats(version: AppleVersion, cpu_arch: str) -> list[str]: + formats = [cpu_arch] + if cpu_arch == "x86_64": + if version < (10, 4): + return [] + formats.extend(["intel", "fat64", "fat32"]) + + elif cpu_arch == "i386": + if version < (10, 4): + return [] + formats.extend(["intel", "fat32", "fat"]) + + elif cpu_arch == "ppc64": + # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? + if version > (10, 5) or version < (10, 4): + return [] + formats.append("fat64") + + elif cpu_arch == "ppc": + if version > (10, 6): + return [] + formats.extend(["fat32", "fat"]) + + if cpu_arch in {"arm64", "x86_64"}: + formats.append("universal2") + + if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: + formats.append("universal") + + return formats + + +def mac_platforms( + version: AppleVersion | None = None, arch: str | None = None +) -> Iterator[str]: + """ + Yields the platform tags for a macOS system. + + The `version` parameter is a two-item tuple specifying the macOS version to + generate platform tags for. The `arch` parameter is the CPU architecture to + generate platform tags for. Both parameters default to the appropriate value + for the current system. + """ + version_str, _, cpu_arch = platform.mac_ver() + if version is None: + version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) + if version == (10, 16): + # When built against an older macOS SDK, Python will report macOS 10.16 + # instead of the real version. + version_str = subprocess.run( + [ + sys.executable, + "-sS", + "-c", + "import platform; print(platform.mac_ver()[0])", + ], + check=True, + env={"SYSTEM_VERSION_COMPAT": "0"}, + stdout=subprocess.PIPE, + text=True, + ).stdout + version = cast("AppleVersion", tuple(map(int, version_str.split(".")[:2]))) + else: + version = version + if arch is None: + arch = _mac_arch(cpu_arch) + else: + arch = arch + + if (10, 0) <= version and version < (11, 0): + # Prior to Mac OS 11, each yearly release of Mac OS bumped the + # "minor" version number. The major version was always 10. + major_version = 10 + for minor_version in range(version[1], -1, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + if version >= (11, 0): + # Starting with Mac OS 11, each yearly release bumps the major version + # number. The minor versions are now the midyear updates. + minor_version = 0 + for major_version in range(version[0], 10, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + if version >= (11, 0): + # Mac OS 11 on x86_64 is compatible with binaries from previous releases. + # Arm64 support was introduced in 11.0, so no Arm binaries from previous + # releases exist. + # + # However, the "universal2" binary format can have a + # macOS version earlier than 11.0 when the x86_64 part of the binary supports + # that version of macOS. + major_version = 10 + if arch == "x86_64": + for minor_version in range(16, 3, -1): + compat_version = major_version, minor_version + binary_formats = _mac_binary_formats(compat_version, arch) + for binary_format in binary_formats: + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + else: + for minor_version in range(16, 3, -1): + compat_version = major_version, minor_version + binary_format = "universal2" + yield f"macosx_{major_version}_{minor_version}_{binary_format}" + + +def ios_platforms( + version: AppleVersion | None = None, multiarch: str | None = None +) -> Iterator[str]: + """ + Yields the platform tags for an iOS system. + + :param version: A two-item tuple specifying the iOS version to generate + platform tags for. Defaults to the current iOS version. + :param multiarch: The CPU architecture+ABI to generate platform tags for - + (the value used by `sys.implementation._multiarch` e.g., + `arm64_iphoneos` or `x84_64_iphonesimulator`). Defaults to the current + multiarch value. + """ + if version is None: + # if iOS is the current platform, ios_ver *must* be defined. However, + # it won't exist for CPython versions before 3.13, which causes a mypy + # error. + _, release, _, _ = platform.ios_ver() # type: ignore[attr-defined, unused-ignore] + version = cast("AppleVersion", tuple(map(int, release.split(".")[:2]))) + + if multiarch is None: + multiarch = sys.implementation._multiarch + multiarch = multiarch.replace("-", "_") + + ios_platform_template = "ios_{major}_{minor}_{multiarch}" + + # Consider any iOS major.minor version from the version requested, down to + # 12.0. 12.0 is the first iOS version that is known to have enough features + # to support CPython. Consider every possible minor release up to X.9. There + # highest the minor has ever gone is 8 (14.8 and 15.8) but having some extra + # candidates that won't ever match doesn't really hurt, and it saves us from + # having to keep an explicit list of known iOS versions in the code. Return + # the results descending order of version number. + + # If the requested major version is less than 12, there won't be any matches. + if version[0] < 12: + return + + # Consider the actual X.Y version that was requested. + yield ios_platform_template.format( + major=version[0], minor=version[1], multiarch=multiarch + ) + + # Consider every minor version from X.0 to the minor version prior to the + # version requested by the platform. + for minor in range(version[1] - 1, -1, -1): + yield ios_platform_template.format( + major=version[0], minor=minor, multiarch=multiarch + ) + + for major in range(version[0] - 1, 11, -1): + for minor in range(9, -1, -1): + yield ios_platform_template.format( + major=major, minor=minor, multiarch=multiarch + ) + + +def android_platforms( + api_level: int | None = None, abi: str | None = None +) -> Iterator[str]: + """ + Yields the :attr:`~Tag.platform` tags for Android. If this function is invoked on + non-Android platforms, the ``api_level`` and ``abi`` arguments are required. + + :param int api_level: The maximum `API level + `__ to return. Defaults + to the current system's version, as returned by ``platform.android_ver``. + :param str abi: The `Android ABI `__, + e.g. ``arm64_v8a``. Defaults to the current system's ABI , as returned by + ``sysconfig.get_platform``. Hyphens and periods will be replaced with + underscores. + """ + if platform.system() != "Android" and (api_level is None or abi is None): + raise TypeError( + "on non-Android platforms, the api_level and abi arguments are required" + ) + + if api_level is None: + # Python 3.13 was the first version to return platform.system() == "Android", + # and also the first version to define platform.android_ver(). + api_level = platform.android_ver().api_level # type: ignore[attr-defined] + + if abi is None: + abi = sysconfig.get_platform().split("-")[-1] + abi = _normalize_string(abi) + + # 16 is the minimum API level known to have enough features to support CPython + # without major patching. Yield every API level from the maximum down to the + # minimum, inclusive. + min_api_level = 16 + for ver in range(api_level, min_api_level - 1, -1): + yield f"android_{ver}_{abi}" + + +def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: + linux = _normalize_string(sysconfig.get_platform()) + if not linux.startswith("linux_"): + # we should never be here, just yield the sysconfig one and return + yield linux + return + if is_32bit: + if linux == "linux_x86_64": + linux = "linux_i686" + elif linux == "linux_aarch64": + linux = "linux_armv8l" + _, arch = linux.split("_", 1) + archs = {"armv8l": ["armv8l", "armv7l"]}.get(arch, [arch]) + yield from _manylinux.platform_tags(archs) + yield from _musllinux.platform_tags(archs) + for arch in archs: + yield f"linux_{arch}" + + +def _generic_platforms() -> Iterator[str]: + yield _normalize_string(sysconfig.get_platform()) + + +def platform_tags() -> Iterator[str]: + """ + Provides the platform tags for this installation. + """ + if platform.system() == "Darwin": + return mac_platforms() + elif platform.system() == "iOS": + return ios_platforms() + elif platform.system() == "Android": + return android_platforms() + elif platform.system() == "Linux": + return _linux_platforms() + else: + return _generic_platforms() + + +def interpreter_name() -> str: + """ + Returns the name of the running interpreter. + + Some implementations have a reserved, two-letter abbreviation which will + be returned when appropriate. + """ + name = sys.implementation.name + return INTERPRETER_SHORT_NAMES.get(name) or name + + +def interpreter_version(*, warn: bool = False) -> str: + """ + Returns the version of the running interpreter. + """ + version = _get_config_var("py_version_nodot", warn=warn) + if version: + version = str(version) + else: + version = _version_nodot(sys.version_info[:2]) + return version + + +def _version_nodot(version: PythonVersion) -> str: + return "".join(map(str, version)) + + +def sys_tags(*, warn: bool = False) -> Iterator[Tag]: + """ + Returns the sequence of tag triples for the running interpreter. + + The order of the sequence corresponds to priority order for the + interpreter, from most to least important. + """ + + interp_name = interpreter_name() + if interp_name == "cp": + yield from cpython_tags(warn=warn) + else: + yield from generic_tags() + + if interp_name == "pp": + interp = "pp3" + elif interp_name == "cp": + interp = "cp" + interpreter_version(warn=warn) + else: + interp = None + yield from compatible_tags(interpreter=interp) diff --git a/.venv/lib/python3.13/site-packages/packaging/utils.py b/.venv/lib/python3.13/site-packages/packaging/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..23450953df74eccd9c13cd2a955ce09d1f968565 --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/utils.py @@ -0,0 +1,163 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import annotations + +import functools +import re +from typing import NewType, Tuple, Union, cast + +from .tags import Tag, parse_tag +from .version import InvalidVersion, Version, _TrimmedRelease + +BuildTag = Union[Tuple[()], Tuple[int, str]] +NormalizedName = NewType("NormalizedName", str) + + +class InvalidName(ValueError): + """ + An invalid distribution name; users should refer to the packaging user guide. + """ + + +class InvalidWheelFilename(ValueError): + """ + An invalid wheel filename was found, users should refer to PEP 427. + """ + + +class InvalidSdistFilename(ValueError): + """ + An invalid sdist filename was found, users should refer to the packaging user guide. + """ + + +# Core metadata spec for `Name` +_validate_regex = re.compile( + r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.IGNORECASE +) +_canonicalize_regex = re.compile(r"[-_.]+") +_normalized_regex = re.compile(r"^([a-z0-9]|[a-z0-9]([a-z0-9-](?!--))*[a-z0-9])$") +# PEP 427: The build number must start with a digit. +_build_tag_regex = re.compile(r"(\d+)(.*)") + + +def canonicalize_name(name: str, *, validate: bool = False) -> NormalizedName: + if validate and not _validate_regex.match(name): + raise InvalidName(f"name is invalid: {name!r}") + # This is taken from PEP 503. + value = _canonicalize_regex.sub("-", name).lower() + return cast(NormalizedName, value) + + +def is_normalized_name(name: str) -> bool: + return _normalized_regex.match(name) is not None + + +@functools.singledispatch +def canonicalize_version( + version: Version | str, *, strip_trailing_zero: bool = True +) -> str: + """ + Return a canonical form of a version as a string. + + >>> canonicalize_version('1.0.1') + '1.0.1' + + Per PEP 625, versions may have multiple canonical forms, differing + only by trailing zeros. + + >>> canonicalize_version('1.0.0') + '1' + >>> canonicalize_version('1.0.0', strip_trailing_zero=False) + '1.0.0' + + Invalid versions are returned unaltered. + + >>> canonicalize_version('foo bar baz') + 'foo bar baz' + """ + return str(_TrimmedRelease(str(version)) if strip_trailing_zero else version) + + +@canonicalize_version.register +def _(version: str, *, strip_trailing_zero: bool = True) -> str: + try: + parsed = Version(version) + except InvalidVersion: + # Legacy versions cannot be normalized + return version + return canonicalize_version(parsed, strip_trailing_zero=strip_trailing_zero) + + +def parse_wheel_filename( + filename: str, +) -> tuple[NormalizedName, Version, BuildTag, frozenset[Tag]]: + if not filename.endswith(".whl"): + raise InvalidWheelFilename( + f"Invalid wheel filename (extension must be '.whl'): {filename!r}" + ) + + filename = filename[:-4] + dashes = filename.count("-") + if dashes not in (4, 5): + raise InvalidWheelFilename( + f"Invalid wheel filename (wrong number of parts): {filename!r}" + ) + + parts = filename.split("-", dashes - 2) + name_part = parts[0] + # See PEP 427 for the rules on escaping the project name. + if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: + raise InvalidWheelFilename(f"Invalid project name: {filename!r}") + name = canonicalize_name(name_part) + + try: + version = Version(parts[1]) + except InvalidVersion as e: + raise InvalidWheelFilename( + f"Invalid wheel filename (invalid version): {filename!r}" + ) from e + + if dashes == 5: + build_part = parts[2] + build_match = _build_tag_regex.match(build_part) + if build_match is None: + raise InvalidWheelFilename( + f"Invalid build number: {build_part} in {filename!r}" + ) + build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) + else: + build = () + tags = parse_tag(parts[-1]) + return (name, version, build, tags) + + +def parse_sdist_filename(filename: str) -> tuple[NormalizedName, Version]: + if filename.endswith(".tar.gz"): + file_stem = filename[: -len(".tar.gz")] + elif filename.endswith(".zip"): + file_stem = filename[: -len(".zip")] + else: + raise InvalidSdistFilename( + f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" + f" {filename!r}" + ) + + # We are requiring a PEP 440 version, which cannot contain dashes, + # so we split on the last dash. + name_part, sep, version_part = file_stem.rpartition("-") + if not sep: + raise InvalidSdistFilename(f"Invalid sdist filename: {filename!r}") + + name = canonicalize_name(name_part) + + try: + version = Version(version_part) + except InvalidVersion as e: + raise InvalidSdistFilename( + f"Invalid sdist filename (invalid version): {filename!r}" + ) from e + + return (name, version) diff --git a/.venv/lib/python3.13/site-packages/packaging/version.py b/.venv/lib/python3.13/site-packages/packaging/version.py new file mode 100644 index 0000000000000000000000000000000000000000..c9bbda20e463b8d9389ecd65f74af33810a02bdd --- /dev/null +++ b/.venv/lib/python3.13/site-packages/packaging/version.py @@ -0,0 +1,582 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +.. testsetup:: + + from packaging.version import parse, Version +""" + +from __future__ import annotations + +import itertools +import re +from typing import Any, Callable, NamedTuple, SupportsInt, Tuple, Union + +from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType + +__all__ = ["VERSION_PATTERN", "InvalidVersion", "Version", "parse"] + +LocalType = Tuple[Union[int, str], ...] + +CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, Tuple[str, int]] +CmpLocalType = Union[ + NegativeInfinityType, + Tuple[Union[Tuple[int, str], Tuple[NegativeInfinityType, Union[int, str]]], ...], +] +CmpKey = Tuple[ + int, + Tuple[int, ...], + CmpPrePostDevType, + CmpPrePostDevType, + CmpPrePostDevType, + CmpLocalType, +] +VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool] + + +class _Version(NamedTuple): + epoch: int + release: tuple[int, ...] + dev: tuple[str, int] | None + pre: tuple[str, int] | None + post: tuple[str, int] | None + local: LocalType | None + + +def parse(version: str) -> Version: + """Parse the given version string. + + >>> parse('1.0.dev1') + + + :param version: The version string to parse. + :raises InvalidVersion: When the version string is not a valid version. + """ + return Version(version) + + +class InvalidVersion(ValueError): + """Raised when a version string is not a valid version. + + >>> Version("invalid") + Traceback (most recent call last): + ... + packaging.version.InvalidVersion: Invalid version: 'invalid' + """ + + +class _BaseVersion: + _key: tuple[Any, ...] + + def __hash__(self) -> int: + return hash(self._key) + + # Please keep the duplicated `isinstance` check + # in the six comparisons hereunder + # unless you find a way to avoid adding overhead function calls. + def __lt__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key < other._key + + def __le__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key <= other._key + + def __eq__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key == other._key + + def __ge__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key >= other._key + + def __gt__(self, other: _BaseVersion) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key > other._key + + def __ne__(self, other: object) -> bool: + if not isinstance(other, _BaseVersion): + return NotImplemented + + return self._key != other._key + + +# Deliberately not anchored to the start and end of the string, to make it +# easier for 3rd party code to reuse +_VERSION_PATTERN = r""" + v? + (?: + (?:(?P[0-9]+)!)? # epoch + (?P[0-9]+(?:\.[0-9]+)*) # release segment + (?P
                                          # pre-release
+            [-_\.]?
+            (?Palpha|a|beta|b|preview|pre|c|rc)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+        (?P                                         # post release
+            (?:-(?P[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?Ppost|rev|r)
+                [-_\.]?
+                (?P[0-9]+)?
+            )
+        )?
+        (?P                                          # dev release
+            [-_\.]?
+            (?Pdev)
+            [-_\.]?
+            (?P[0-9]+)?
+        )?
+    )
+    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+VERSION_PATTERN = _VERSION_PATTERN
+"""
+A string containing the regular expression used to match a valid version.
+
+The pattern is not anchored at either end, and is intended for embedding in larger
+expressions (for example, matching a version number as part of a file name). The
+regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
+flags set.
+
+:meta hide-value:
+"""
+
+
+class Version(_BaseVersion):
+    """This class abstracts handling of a project's versions.
+
+    A :class:`Version` instance is comparison aware and can be compared and
+    sorted using the standard Python interfaces.
+
+    >>> v1 = Version("1.0a5")
+    >>> v2 = Version("1.0")
+    >>> v1
+    
+    >>> v2
+    
+    >>> v1 < v2
+    True
+    >>> v1 == v2
+    False
+    >>> v1 > v2
+    False
+    >>> v1 >= v2
+    False
+    >>> v1 <= v2
+    True
+    """
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+    _key: CmpKey
+
+    def __init__(self, version: str) -> None:
+        """Initialize a Version object.
+
+        :param version:
+            The string representation of a version which will be parsed and normalized
+            before use.
+        :raises InvalidVersion:
+            If the ``version`` does not conform to PEP 440 in any way then this
+            exception will be raised.
+        """
+
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: {version!r}")
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self) -> str:
+        """A representation of the Version that shows all internal state.
+
+        >>> Version('1.0.0')
+        
+        """
+        return f""
+
+    def __str__(self) -> str:
+        """A string representation of the version that can be round-tripped.
+
+        >>> str(Version("1.0a5"))
+        '1.0a5'
+        """
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(f".post{self.post}")
+
+        # Development release
+        if self.dev is not None:
+            parts.append(f".dev{self.dev}")
+
+        # Local version segment
+        if self.local is not None:
+            parts.append(f"+{self.local}")
+
+        return "".join(parts)
+
+    @property
+    def epoch(self) -> int:
+        """The epoch of the version.
+
+        >>> Version("2.0.0").epoch
+        0
+        >>> Version("1!2.0.0").epoch
+        1
+        """
+        return self._version.epoch
+
+    @property
+    def release(self) -> tuple[int, ...]:
+        """The components of the "release" segment of the version.
+
+        >>> Version("1.2.3").release
+        (1, 2, 3)
+        >>> Version("2.0.0").release
+        (2, 0, 0)
+        >>> Version("1!2.0.0.post0").release
+        (2, 0, 0)
+
+        Includes trailing zeroes but not the epoch or any pre-release / development /
+        post-release suffixes.
+        """
+        return self._version.release
+
+    @property
+    def pre(self) -> tuple[str, int] | None:
+        """The pre-release segment of the version.
+
+        >>> print(Version("1.2.3").pre)
+        None
+        >>> Version("1.2.3a1").pre
+        ('a', 1)
+        >>> Version("1.2.3b1").pre
+        ('b', 1)
+        >>> Version("1.2.3rc1").pre
+        ('rc', 1)
+        """
+        return self._version.pre
+
+    @property
+    def post(self) -> int | None:
+        """The post-release number of the version.
+
+        >>> print(Version("1.2.3").post)
+        None
+        >>> Version("1.2.3.post1").post
+        1
+        """
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self) -> int | None:
+        """The development number of the version.
+
+        >>> print(Version("1.2.3").dev)
+        None
+        >>> Version("1.2.3.dev1").dev
+        1
+        """
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self) -> str | None:
+        """The local version segment of the version.
+
+        >>> print(Version("1.2.3").local)
+        None
+        >>> Version("1.2.3+abc").local
+        'abc'
+        """
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self) -> str:
+        """The public portion of the version.
+
+        >>> Version("1.2.3").public
+        '1.2.3'
+        >>> Version("1.2.3+abc").public
+        '1.2.3'
+        >>> Version("1!1.2.3dev1+abc").public
+        '1!1.2.3.dev1'
+        """
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self) -> str:
+        """The "base version" of the version.
+
+        >>> Version("1.2.3").base_version
+        '1.2.3'
+        >>> Version("1.2.3+abc").base_version
+        '1.2.3'
+        >>> Version("1!1.2.3dev1+abc").base_version
+        '1!1.2.3'
+
+        The "base version" is the public version of the project without any pre or post
+        release markers.
+        """
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append(f"{self.epoch}!")
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self) -> bool:
+        """Whether this version is a pre-release.
+
+        >>> Version("1.2.3").is_prerelease
+        False
+        >>> Version("1.2.3a1").is_prerelease
+        True
+        >>> Version("1.2.3b1").is_prerelease
+        True
+        >>> Version("1.2.3rc1").is_prerelease
+        True
+        >>> Version("1.2.3dev1").is_prerelease
+        True
+        """
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self) -> bool:
+        """Whether this version is a post-release.
+
+        >>> Version("1.2.3").is_postrelease
+        False
+        >>> Version("1.2.3.post1").is_postrelease
+        True
+        """
+        return self.post is not None
+
+    @property
+    def is_devrelease(self) -> bool:
+        """Whether this version is a development release.
+
+        >>> Version("1.2.3").is_devrelease
+        False
+        >>> Version("1.2.3.dev1").is_devrelease
+        True
+        """
+        return self.dev is not None
+
+    @property
+    def major(self) -> int:
+        """The first item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").major
+        1
+        """
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self) -> int:
+        """The second item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").minor
+        2
+        >>> Version("1").minor
+        0
+        """
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self) -> int:
+        """The third item of :attr:`release` or ``0`` if unavailable.
+
+        >>> Version("1.2.3").micro
+        3
+        >>> Version("1").micro
+        0
+        """
+        return self.release[2] if len(self.release) >= 3 else 0
+
+
+class _TrimmedRelease(Version):
+    @property
+    def release(self) -> tuple[int, ...]:
+        """
+        Release segment without any trailing zeros.
+
+        >>> _TrimmedRelease('1.0.0').release
+        (1,)
+        >>> _TrimmedRelease('0.0').release
+        (0,)
+        """
+        rel = super().release
+        nonzeros = (index for index, val in enumerate(rel) if val)
+        last_nonzero = max(nonzeros, default=0)
+        return rel[: last_nonzero + 1]
+
+
+def _parse_letter_version(
+    letter: str | None, number: str | bytes | SupportsInt | None
+) -> tuple[str, int] | None:
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+
+    assert not letter
+    if number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+    return None
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local: str | None) -> LocalType | None:
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
+
+
+def _cmpkey(
+    epoch: int,
+    release: tuple[int, ...],
+    pre: tuple[str, int] | None,
+    post: tuple[str, int] | None,
+    dev: tuple[str, int] | None,
+    local: LocalType | None,
+) -> CmpKey:
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    _release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        _pre: CmpPrePostDevType = NegativeInfinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        _post: CmpPrePostDevType = NegativeInfinity
+
+    else:
+        _post = post
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        _dev: CmpPrePostDevType = Infinity
+
+    else:
+        _dev = dev
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        _local: CmpLocalType = NegativeInfinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        _local = tuple(
+            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
+        )
+
+    return epoch, _release, _pre, _post, _dev, _local
diff --git a/.venv/lib/python3.13/site-packages/prompt_toolkit/layout/__pycache__/containers.cpython-313.pyc b/.venv/lib/python3.13/site-packages/prompt_toolkit/layout/__pycache__/containers.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..469b6bd229d41c1ca4d75180426d32b56cf18449
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/prompt_toolkit/layout/__pycache__/containers.cpython-313.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:179c46fb3c9591ad04f8f9f9af14a18bdbb7b7238f541de0f713b7ac0000d2d5
+size 100165
diff --git a/.venv/lib/python3.13/site-packages/typing_extensions.py b/.venv/lib/python3.13/site-packages/typing_extensions.py
new file mode 100644
index 0000000000000000000000000000000000000000..efa09d55236d7607a0a869eb7ab9ef4d6254231f
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/typing_extensions.py
@@ -0,0 +1,4244 @@
+import abc
+import builtins
+import collections
+import collections.abc
+import contextlib
+import enum
+import functools
+import inspect
+import io
+import keyword
+import operator
+import sys
+import types as _types
+import typing
+import warnings
+
+if sys.version_info >= (3, 14):
+    import annotationlib
+
+__all__ = [
+    # Super-special typing primitives.
+    'Any',
+    'ClassVar',
+    'Concatenate',
+    'Final',
+    'LiteralString',
+    'ParamSpec',
+    'ParamSpecArgs',
+    'ParamSpecKwargs',
+    'Self',
+    'Type',
+    'TypeVar',
+    'TypeVarTuple',
+    'Unpack',
+
+    # ABCs (from collections.abc).
+    'Awaitable',
+    'AsyncIterator',
+    'AsyncIterable',
+    'Coroutine',
+    'AsyncGenerator',
+    'AsyncContextManager',
+    'Buffer',
+    'ChainMap',
+
+    # Concrete collection types.
+    'ContextManager',
+    'Counter',
+    'Deque',
+    'DefaultDict',
+    'NamedTuple',
+    'OrderedDict',
+    'TypedDict',
+
+    # Structural checks, a.k.a. protocols.
+    'SupportsAbs',
+    'SupportsBytes',
+    'SupportsComplex',
+    'SupportsFloat',
+    'SupportsIndex',
+    'SupportsInt',
+    'SupportsRound',
+    'Reader',
+    'Writer',
+
+    # One-off things.
+    'Annotated',
+    'assert_never',
+    'assert_type',
+    'clear_overloads',
+    'dataclass_transform',
+    'deprecated',
+    'Doc',
+    'evaluate_forward_ref',
+    'get_overloads',
+    'final',
+    'Format',
+    'get_annotations',
+    'get_args',
+    'get_origin',
+    'get_original_bases',
+    'get_protocol_members',
+    'get_type_hints',
+    'IntVar',
+    'is_protocol',
+    'is_typeddict',
+    'Literal',
+    'NewType',
+    'overload',
+    'override',
+    'Protocol',
+    'Sentinel',
+    'reveal_type',
+    'runtime',
+    'runtime_checkable',
+    'Text',
+    'TypeAlias',
+    'TypeAliasType',
+    'TypeForm',
+    'TypeGuard',
+    'TypeIs',
+    'TYPE_CHECKING',
+    'Never',
+    'NoReturn',
+    'ReadOnly',
+    'Required',
+    'NotRequired',
+    'NoDefault',
+    'NoExtraItems',
+
+    # Pure aliases, have always been in typing
+    'AbstractSet',
+    'AnyStr',
+    'BinaryIO',
+    'Callable',
+    'Collection',
+    'Container',
+    'Dict',
+    'ForwardRef',
+    'FrozenSet',
+    'Generator',
+    'Generic',
+    'Hashable',
+    'IO',
+    'ItemsView',
+    'Iterable',
+    'Iterator',
+    'KeysView',
+    'List',
+    'Mapping',
+    'MappingView',
+    'Match',
+    'MutableMapping',
+    'MutableSequence',
+    'MutableSet',
+    'Optional',
+    'Pattern',
+    'Reversible',
+    'Sequence',
+    'Set',
+    'Sized',
+    'TextIO',
+    'Tuple',
+    'Union',
+    'ValuesView',
+    'cast',
+    'no_type_check',
+    'no_type_check_decorator',
+]
+
+# for backward compatibility
+PEP_560 = True
+GenericMeta = type
+_PEP_696_IMPLEMENTED = sys.version_info >= (3, 13, 0, "beta")
+
+# Added with bpo-45166 to 3.10.1+ and some 3.9 versions
+_FORWARD_REF_HAS_CLASS = "__forward_is_class__" in typing.ForwardRef.__slots__
+
+# The functions below are modified copies of typing internal helpers.
+# They are needed by _ProtocolMeta and they provide support for PEP 646.
+
+
+class _Sentinel:
+    def __repr__(self):
+        return ""
+
+
+_marker = _Sentinel()
+
+
+if sys.version_info >= (3, 10):
+    def _should_collect_from_parameters(t):
+        return isinstance(
+            t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType)
+        )
+else:
+    def _should_collect_from_parameters(t):
+        return isinstance(t, (typing._GenericAlias, _types.GenericAlias))
+
+
+NoReturn = typing.NoReturn
+
+# Some unconstrained type variables.  These are used by the container types.
+# (These are not for export.)
+T = typing.TypeVar('T')  # Any type.
+KT = typing.TypeVar('KT')  # Key type.
+VT = typing.TypeVar('VT')  # Value type.
+T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
+T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.
+
+
+if sys.version_info >= (3, 11):
+    from typing import Any
+else:
+
+    class _AnyMeta(type):
+        def __instancecheck__(self, obj):
+            if self is Any:
+                raise TypeError("typing_extensions.Any cannot be used with isinstance()")
+            return super().__instancecheck__(obj)
+
+        def __repr__(self):
+            if self is Any:
+                return "typing_extensions.Any"
+            return super().__repr__()
+
+    class Any(metaclass=_AnyMeta):
+        """Special type indicating an unconstrained type.
+        - Any is compatible with every type.
+        - Any assumed to have all methods.
+        - All values assumed to be instances of Any.
+        Note that all the above statements are true from the point of view of
+        static type checkers. At runtime, Any should not be used with instance
+        checks.
+        """
+        def __new__(cls, *args, **kwargs):
+            if cls is Any:
+                raise TypeError("Any cannot be instantiated")
+            return super().__new__(cls, *args, **kwargs)
+
+
+ClassVar = typing.ClassVar
+
+# Vendored from cpython typing._SpecialFrom
+# Having a separate class means that instances will not be rejected by
+# typing._type_check.
+class _SpecialForm(typing._Final, _root=True):
+    __slots__ = ('_name', '__doc__', '_getitem')
+
+    def __init__(self, getitem):
+        self._getitem = getitem
+        self._name = getitem.__name__
+        self.__doc__ = getitem.__doc__
+
+    def __getattr__(self, item):
+        if item in {'__name__', '__qualname__'}:
+            return self._name
+
+        raise AttributeError(item)
+
+    def __mro_entries__(self, bases):
+        raise TypeError(f"Cannot subclass {self!r}")
+
+    def __repr__(self):
+        return f'typing_extensions.{self._name}'
+
+    def __reduce__(self):
+        return self._name
+
+    def __call__(self, *args, **kwds):
+        raise TypeError(f"Cannot instantiate {self!r}")
+
+    def __or__(self, other):
+        return typing.Union[self, other]
+
+    def __ror__(self, other):
+        return typing.Union[other, self]
+
+    def __instancecheck__(self, obj):
+        raise TypeError(f"{self} cannot be used with isinstance()")
+
+    def __subclasscheck__(self, cls):
+        raise TypeError(f"{self} cannot be used with issubclass()")
+
+    @typing._tp_cache
+    def __getitem__(self, parameters):
+        return self._getitem(self, parameters)
+
+
+# Note that inheriting from this class means that the object will be
+# rejected by typing._type_check, so do not use it if the special form
+# is arguably valid as a type by itself.
+class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
+    def __repr__(self):
+        return 'typing_extensions.' + self._name
+
+
+Final = typing.Final
+
+if sys.version_info >= (3, 11):
+    final = typing.final
+else:
+    # @final exists in 3.8+, but we backport it for all versions
+    # before 3.11 to keep support for the __final__ attribute.
+    # See https://bugs.python.org/issue46342
+    def final(f):
+        """This decorator can be used to indicate to type checkers that
+        the decorated method cannot be overridden, and decorated class
+        cannot be subclassed. For example:
+
+            class Base:
+                @final
+                def done(self) -> None:
+                    ...
+            class Sub(Base):
+                def done(self) -> None:  # Error reported by type checker
+                    ...
+            @final
+            class Leaf:
+                ...
+            class Other(Leaf):  # Error reported by type checker
+                ...
+
+        There is no runtime checking of these properties. The decorator
+        sets the ``__final__`` attribute to ``True`` on the decorated object
+        to allow runtime introspection.
+        """
+        try:
+            f.__final__ = True
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable.
+            # AttributeError happens if the object has __slots__ or a
+            # read-only property, TypeError if it's a builtin class.
+            pass
+        return f
+
+
+def IntVar(name):
+    return typing.TypeVar(name)
+
+
+# A Literal bug was fixed in 3.11.0, 3.10.1 and 3.9.8
+if sys.version_info >= (3, 10, 1):
+    Literal = typing.Literal
+else:
+    def _flatten_literal_params(parameters):
+        """An internal helper for Literal creation: flatten Literals among parameters"""
+        params = []
+        for p in parameters:
+            if isinstance(p, _LiteralGenericAlias):
+                params.extend(p.__args__)
+            else:
+                params.append(p)
+        return tuple(params)
+
+    def _value_and_type_iter(params):
+        for p in params:
+            yield p, type(p)
+
+    class _LiteralGenericAlias(typing._GenericAlias, _root=True):
+        def __eq__(self, other):
+            if not isinstance(other, _LiteralGenericAlias):
+                return NotImplemented
+            these_args_deduped = set(_value_and_type_iter(self.__args__))
+            other_args_deduped = set(_value_and_type_iter(other.__args__))
+            return these_args_deduped == other_args_deduped
+
+        def __hash__(self):
+            return hash(frozenset(_value_and_type_iter(self.__args__)))
+
+    class _LiteralForm(_ExtensionsSpecialForm, _root=True):
+        def __init__(self, doc: str):
+            self._name = 'Literal'
+            self._doc = self.__doc__ = doc
+
+        def __getitem__(self, parameters):
+            if not isinstance(parameters, tuple):
+                parameters = (parameters,)
+
+            parameters = _flatten_literal_params(parameters)
+
+            val_type_pairs = list(_value_and_type_iter(parameters))
+            try:
+                deduped_pairs = set(val_type_pairs)
+            except TypeError:
+                # unhashable parameters
+                pass
+            else:
+                # similar logic to typing._deduplicate on Python 3.9+
+                if len(deduped_pairs) < len(val_type_pairs):
+                    new_parameters = []
+                    for pair in val_type_pairs:
+                        if pair in deduped_pairs:
+                            new_parameters.append(pair[0])
+                            deduped_pairs.remove(pair)
+                    assert not deduped_pairs, deduped_pairs
+                    parameters = tuple(new_parameters)
+
+            return _LiteralGenericAlias(self, parameters)
+
+    Literal = _LiteralForm(doc="""\
+                           A type that can be used to indicate to type checkers
+                           that the corresponding value has a value literally equivalent
+                           to the provided parameter. For example:
+
+                               var: Literal[4] = 4
+
+                           The type checker understands that 'var' is literally equal to
+                           the value 4 and no other value.
+
+                           Literal[...] cannot be subclassed. There is no runtime
+                           checking verifying that the parameter is actually a value
+                           instead of a type.""")
+
+
+_overload_dummy = typing._overload_dummy
+
+
+if hasattr(typing, "get_overloads"):  # 3.11+
+    overload = typing.overload
+    get_overloads = typing.get_overloads
+    clear_overloads = typing.clear_overloads
+else:
+    # {module: {qualname: {firstlineno: func}}}
+    _overload_registry = collections.defaultdict(
+        functools.partial(collections.defaultdict, dict)
+    )
+
+    def overload(func):
+        """Decorator for overloaded functions/methods.
+
+        In a stub file, place two or more stub definitions for the same
+        function in a row, each decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+
+        In a non-stub file (i.e. a regular .py file), do the same but
+        follow it with an implementation.  The implementation should *not*
+        be decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+        def utf8(value):
+            # implementation goes here
+
+        The overloads for a function can be retrieved at runtime using the
+        get_overloads() function.
+        """
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        try:
+            _overload_registry[f.__module__][f.__qualname__][
+                f.__code__.co_firstlineno
+            ] = func
+        except AttributeError:
+            # Not a normal function; ignore.
+            pass
+        return _overload_dummy
+
+    def get_overloads(func):
+        """Return all defined overloads for *func* as a sequence."""
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        if f.__module__ not in _overload_registry:
+            return []
+        mod_dict = _overload_registry[f.__module__]
+        if f.__qualname__ not in mod_dict:
+            return []
+        return list(mod_dict[f.__qualname__].values())
+
+    def clear_overloads():
+        """Clear all overloads in the registry."""
+        _overload_registry.clear()
+
+
+# This is not a real generic class.  Don't use outside annotations.
+Type = typing.Type
+
+# Various ABCs mimicking those in collections.abc.
+# A few are simply re-exported for completeness.
+Awaitable = typing.Awaitable
+Coroutine = typing.Coroutine
+AsyncIterable = typing.AsyncIterable
+AsyncIterator = typing.AsyncIterator
+Deque = typing.Deque
+DefaultDict = typing.DefaultDict
+OrderedDict = typing.OrderedDict
+Counter = typing.Counter
+ChainMap = typing.ChainMap
+Text = typing.Text
+TYPE_CHECKING = typing.TYPE_CHECKING
+
+
+if sys.version_info >= (3, 13, 0, "beta"):
+    from typing import AsyncContextManager, AsyncGenerator, ContextManager, Generator
+else:
+    def _is_dunder(attr):
+        return attr.startswith('__') and attr.endswith('__')
+
+
+    class _SpecialGenericAlias(typing._SpecialGenericAlias, _root=True):
+        def __init__(self, origin, nparams, *, inst=True, name=None, defaults=()):
+            super().__init__(origin, nparams, inst=inst, name=name)
+            self._defaults = defaults
+
+        def __setattr__(self, attr, val):
+            allowed_attrs = {'_name', '_inst', '_nparams', '_defaults'}
+            if _is_dunder(attr) or attr in allowed_attrs:
+                object.__setattr__(self, attr, val)
+            else:
+                setattr(self.__origin__, attr, val)
+
+        @typing._tp_cache
+        def __getitem__(self, params):
+            if not isinstance(params, tuple):
+                params = (params,)
+            msg = "Parameters to generic types must be types."
+            params = tuple(typing._type_check(p, msg) for p in params)
+            if (
+                self._defaults
+                and len(params) < self._nparams
+                and len(params) + len(self._defaults) >= self._nparams
+            ):
+                params = (*params, *self._defaults[len(params) - self._nparams:])
+            actual_len = len(params)
+
+            if actual_len != self._nparams:
+                if self._defaults:
+                    expected = f"at least {self._nparams - len(self._defaults)}"
+                else:
+                    expected = str(self._nparams)
+                if not self._nparams:
+                    raise TypeError(f"{self} is not a generic class")
+                raise TypeError(
+                    f"Too {'many' if actual_len > self._nparams else 'few'}"
+                    f" arguments for {self};"
+                    f" actual {actual_len}, expected {expected}"
+                )
+            return self.copy_with(params)
+
+    _NoneType = type(None)
+    Generator = _SpecialGenericAlias(
+        collections.abc.Generator, 3, defaults=(_NoneType, _NoneType)
+    )
+    AsyncGenerator = _SpecialGenericAlias(
+        collections.abc.AsyncGenerator, 2, defaults=(_NoneType,)
+    )
+    ContextManager = _SpecialGenericAlias(
+        contextlib.AbstractContextManager,
+        2,
+        name="ContextManager",
+        defaults=(typing.Optional[bool],)
+    )
+    AsyncContextManager = _SpecialGenericAlias(
+        contextlib.AbstractAsyncContextManager,
+        2,
+        name="AsyncContextManager",
+        defaults=(typing.Optional[bool],)
+    )
+
+
+_PROTO_ALLOWLIST = {
+    'collections.abc': [
+        'Callable', 'Awaitable', 'Iterable', 'Iterator', 'AsyncIterable',
+        'Hashable', 'Sized', 'Container', 'Collection', 'Reversible', 'Buffer',
+    ],
+    'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'],
+    'typing_extensions': ['Buffer'],
+}
+
+
+_EXCLUDED_ATTRS = frozenset(typing.EXCLUDED_ATTRIBUTES) | {
+    "__match_args__", "__protocol_attrs__", "__non_callable_proto_members__",
+    "__final__",
+}
+
+
+def _get_protocol_attrs(cls):
+    attrs = set()
+    for base in cls.__mro__[:-1]:  # without object
+        if base.__name__ in {'Protocol', 'Generic'}:
+            continue
+        annotations = getattr(base, '__annotations__', {})
+        for attr in (*base.__dict__, *annotations):
+            if (not attr.startswith('_abc_') and attr not in _EXCLUDED_ATTRS):
+                attrs.add(attr)
+    return attrs
+
+
+def _caller(depth=1, default='__main__'):
+    try:
+        return sys._getframemodulename(depth + 1) or default
+    except AttributeError:  # For platforms without _getframemodulename()
+        pass
+    try:
+        return sys._getframe(depth + 1).f_globals.get('__name__', default)
+    except (AttributeError, ValueError):  # For platforms without _getframe()
+        pass
+    return None
+
+
+# `__match_args__` attribute was removed from protocol members in 3.13,
+# we want to backport this change to older Python versions.
+if sys.version_info >= (3, 13):
+    Protocol = typing.Protocol
+else:
+    def _allow_reckless_class_checks(depth=2):
+        """Allow instance and class checks for special stdlib modules.
+        The abc and functools modules indiscriminately call isinstance() and
+        issubclass() on the whole MRO of a user class, which may contain protocols.
+        """
+        return _caller(depth) in {'abc', 'functools', None}
+
+    def _no_init(self, *args, **kwargs):
+        if type(self)._is_protocol:
+            raise TypeError('Protocols cannot be instantiated')
+
+    def _type_check_issubclass_arg_1(arg):
+        """Raise TypeError if `arg` is not an instance of `type`
+        in `issubclass(arg, )`.
+
+        In most cases, this is verified by type.__subclasscheck__.
+        Checking it again unnecessarily would slow down issubclass() checks,
+        so, we don't perform this check unless we absolutely have to.
+
+        For various error paths, however,
+        we want to ensure that *this* error message is shown to the user
+        where relevant, rather than a typing.py-specific error message.
+        """
+        if not isinstance(arg, type):
+            # Same error message as for issubclass(1, int).
+            raise TypeError('issubclass() arg 1 must be a class')
+
+    # Inheriting from typing._ProtocolMeta isn't actually desirable,
+    # but is necessary to allow typing.Protocol and typing_extensions.Protocol
+    # to mix without getting TypeErrors about "metaclass conflict"
+    class _ProtocolMeta(type(typing.Protocol)):
+        # This metaclass is somewhat unfortunate,
+        # but is necessary for several reasons...
+        #
+        # NOTE: DO NOT call super() in any methods in this class
+        # That would call the methods on typing._ProtocolMeta on Python <=3.11
+        # and those are slow
+        def __new__(mcls, name, bases, namespace, **kwargs):
+            if name == "Protocol" and len(bases) < 2:
+                pass
+            elif {Protocol, typing.Protocol} & set(bases):
+                for base in bases:
+                    if not (
+                        base in {object, typing.Generic, Protocol, typing.Protocol}
+                        or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, [])
+                        or is_protocol(base)
+                    ):
+                        raise TypeError(
+                            f"Protocols can only inherit from other protocols, "
+                            f"got {base!r}"
+                        )
+            return abc.ABCMeta.__new__(mcls, name, bases, namespace, **kwargs)
+
+        def __init__(cls, *args, **kwargs):
+            abc.ABCMeta.__init__(cls, *args, **kwargs)
+            if getattr(cls, "_is_protocol", False):
+                cls.__protocol_attrs__ = _get_protocol_attrs(cls)
+
+        def __subclasscheck__(cls, other):
+            if cls is Protocol:
+                return type.__subclasscheck__(cls, other)
+            if (
+                getattr(cls, '_is_protocol', False)
+                and not _allow_reckless_class_checks()
+            ):
+                if not getattr(cls, '_is_runtime_protocol', False):
+                    _type_check_issubclass_arg_1(other)
+                    raise TypeError(
+                        "Instance and class checks can only be used with "
+                        "@runtime_checkable protocols"
+                    )
+                if (
+                    # this attribute is set by @runtime_checkable:
+                    cls.__non_callable_proto_members__
+                    and cls.__dict__.get("__subclasshook__") is _proto_hook
+                ):
+                    _type_check_issubclass_arg_1(other)
+                    non_method_attrs = sorted(cls.__non_callable_proto_members__)
+                    raise TypeError(
+                        "Protocols with non-method members don't support issubclass()."
+                        f" Non-method members: {str(non_method_attrs)[1:-1]}."
+                    )
+            return abc.ABCMeta.__subclasscheck__(cls, other)
+
+        def __instancecheck__(cls, instance):
+            # We need this method for situations where attributes are
+            # assigned in __init__.
+            if cls is Protocol:
+                return type.__instancecheck__(cls, instance)
+            if not getattr(cls, "_is_protocol", False):
+                # i.e., it's a concrete subclass of a protocol
+                return abc.ABCMeta.__instancecheck__(cls, instance)
+
+            if (
+                not getattr(cls, '_is_runtime_protocol', False) and
+                not _allow_reckless_class_checks()
+            ):
+                raise TypeError("Instance and class checks can only be used with"
+                                " @runtime_checkable protocols")
+
+            if abc.ABCMeta.__instancecheck__(cls, instance):
+                return True
+
+            for attr in cls.__protocol_attrs__:
+                try:
+                    val = inspect.getattr_static(instance, attr)
+                except AttributeError:
+                    break
+                # this attribute is set by @runtime_checkable:
+                if val is None and attr not in cls.__non_callable_proto_members__:
+                    break
+            else:
+                return True
+
+            return False
+
+        def __eq__(cls, other):
+            # Hack so that typing.Generic.__class_getitem__
+            # treats typing_extensions.Protocol
+            # as equivalent to typing.Protocol
+            if abc.ABCMeta.__eq__(cls, other) is True:
+                return True
+            return cls is Protocol and other is typing.Protocol
+
+        # This has to be defined, or the abc-module cache
+        # complains about classes with this metaclass being unhashable,
+        # if we define only __eq__!
+        def __hash__(cls) -> int:
+            return type.__hash__(cls)
+
+    @classmethod
+    def _proto_hook(cls, other):
+        if not cls.__dict__.get('_is_protocol', False):
+            return NotImplemented
+
+        for attr in cls.__protocol_attrs__:
+            for base in other.__mro__:
+                # Check if the members appears in the class dictionary...
+                if attr in base.__dict__:
+                    if base.__dict__[attr] is None:
+                        return NotImplemented
+                    break
+
+                # ...or in annotations, if it is a sub-protocol.
+                annotations = getattr(base, '__annotations__', {})
+                if (
+                    isinstance(annotations, collections.abc.Mapping)
+                    and attr in annotations
+                    and is_protocol(other)
+                ):
+                    break
+            else:
+                return NotImplemented
+        return True
+
+    class Protocol(typing.Generic, metaclass=_ProtocolMeta):
+        __doc__ = typing.Protocol.__doc__
+        __slots__ = ()
+        _is_protocol = True
+        _is_runtime_protocol = False
+
+        def __init_subclass__(cls, *args, **kwargs):
+            super().__init_subclass__(*args, **kwargs)
+
+            # Determine if this is a protocol or a concrete subclass.
+            if not cls.__dict__.get('_is_protocol', False):
+                cls._is_protocol = any(b is Protocol for b in cls.__bases__)
+
+            # Set (or override) the protocol subclass hook.
+            if '__subclasshook__' not in cls.__dict__:
+                cls.__subclasshook__ = _proto_hook
+
+            # Prohibit instantiation for protocol classes
+            if cls._is_protocol and cls.__init__ is Protocol.__init__:
+                cls.__init__ = _no_init
+
+
+if sys.version_info >= (3, 13):
+    runtime_checkable = typing.runtime_checkable
+else:
+    def runtime_checkable(cls):
+        """Mark a protocol class as a runtime protocol.
+
+        Such protocol can be used with isinstance() and issubclass().
+        Raise TypeError if applied to a non-protocol class.
+        This allows a simple-minded structural check very similar to
+        one trick ponies in collections.abc such as Iterable.
+
+        For example::
+
+            @runtime_checkable
+            class Closable(Protocol):
+                def close(self): ...
+
+            assert isinstance(open('/some/file'), Closable)
+
+        Warning: this will check only the presence of the required methods,
+        not their type signatures!
+        """
+        if not issubclass(cls, typing.Generic) or not getattr(cls, '_is_protocol', False):
+            raise TypeError(f'@runtime_checkable can be only applied to protocol classes,'
+                            f' got {cls!r}')
+        cls._is_runtime_protocol = True
+
+        # typing.Protocol classes on <=3.11 break if we execute this block,
+        # because typing.Protocol classes on <=3.11 don't have a
+        # `__protocol_attrs__` attribute, and this block relies on the
+        # `__protocol_attrs__` attribute. Meanwhile, typing.Protocol classes on 3.12.2+
+        # break if we *don't* execute this block, because *they* assume that all
+        # protocol classes have a `__non_callable_proto_members__` attribute
+        # (which this block sets)
+        if isinstance(cls, _ProtocolMeta) or sys.version_info >= (3, 12, 2):
+            # PEP 544 prohibits using issubclass()
+            # with protocols that have non-method members.
+            # See gh-113320 for why we compute this attribute here,
+            # rather than in `_ProtocolMeta.__init__`
+            cls.__non_callable_proto_members__ = set()
+            for attr in cls.__protocol_attrs__:
+                try:
+                    is_callable = callable(getattr(cls, attr, None))
+                except Exception as e:
+                    raise TypeError(
+                        f"Failed to determine whether protocol member {attr!r} "
+                        "is a method member"
+                    ) from e
+                else:
+                    if not is_callable:
+                        cls.__non_callable_proto_members__.add(attr)
+
+        return cls
+
+
+# The "runtime" alias exists for backwards compatibility.
+runtime = runtime_checkable
+
+
+# Our version of runtime-checkable protocols is faster on Python <=3.11
+if sys.version_info >= (3, 12):
+    SupportsInt = typing.SupportsInt
+    SupportsFloat = typing.SupportsFloat
+    SupportsComplex = typing.SupportsComplex
+    SupportsBytes = typing.SupportsBytes
+    SupportsIndex = typing.SupportsIndex
+    SupportsAbs = typing.SupportsAbs
+    SupportsRound = typing.SupportsRound
+else:
+    @runtime_checkable
+    class SupportsInt(Protocol):
+        """An ABC with one abstract method __int__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __int__(self) -> int:
+            pass
+
+    @runtime_checkable
+    class SupportsFloat(Protocol):
+        """An ABC with one abstract method __float__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __float__(self) -> float:
+            pass
+
+    @runtime_checkable
+    class SupportsComplex(Protocol):
+        """An ABC with one abstract method __complex__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __complex__(self) -> complex:
+            pass
+
+    @runtime_checkable
+    class SupportsBytes(Protocol):
+        """An ABC with one abstract method __bytes__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __bytes__(self) -> bytes:
+            pass
+
+    @runtime_checkable
+    class SupportsIndex(Protocol):
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __index__(self) -> int:
+            pass
+
+    @runtime_checkable
+    class SupportsAbs(Protocol[T_co]):
+        """
+        An ABC with one abstract method __abs__ that is covariant in its return type.
+        """
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __abs__(self) -> T_co:
+            pass
+
+    @runtime_checkable
+    class SupportsRound(Protocol[T_co]):
+        """
+        An ABC with one abstract method __round__ that is covariant in its return type.
+        """
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __round__(self, ndigits: int = 0) -> T_co:
+            pass
+
+
+if hasattr(io, "Reader") and hasattr(io, "Writer"):
+    Reader = io.Reader
+    Writer = io.Writer
+else:
+    @runtime_checkable
+    class Reader(Protocol[T_co]):
+        """Protocol for simple I/O reader instances.
+
+        This protocol only supports blocking I/O.
+        """
+
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def read(self, size: int = ..., /) -> T_co:
+            """Read data from the input stream and return it.
+
+            If *size* is specified, at most *size* items (bytes/characters) will be
+            read.
+            """
+
+    @runtime_checkable
+    class Writer(Protocol[T_contra]):
+        """Protocol for simple I/O writer instances.
+
+        This protocol only supports blocking I/O.
+        """
+
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def write(self, data: T_contra, /) -> int:
+            """Write *data* to the output stream and return the number of items written."""  # noqa: E501
+
+
+_NEEDS_SINGLETONMETA = (
+    not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems")
+)
+
+if _NEEDS_SINGLETONMETA:
+    class SingletonMeta(type):
+        def __setattr__(cls, attr, value):
+            # TypeError is consistent with the behavior of NoneType
+            raise TypeError(
+                f"cannot set {attr!r} attribute of immutable type {cls.__name__!r}"
+            )
+
+
+if hasattr(typing, "NoDefault"):
+    NoDefault = typing.NoDefault
+else:
+    class NoDefaultType(metaclass=SingletonMeta):
+        """The type of the NoDefault singleton."""
+
+        __slots__ = ()
+
+        def __new__(cls):
+            return globals().get("NoDefault") or object.__new__(cls)
+
+        def __repr__(self):
+            return "typing_extensions.NoDefault"
+
+        def __reduce__(self):
+            return "NoDefault"
+
+    NoDefault = NoDefaultType()
+    del NoDefaultType
+
+if hasattr(typing, "NoExtraItems"):
+    NoExtraItems = typing.NoExtraItems
+else:
+    class NoExtraItemsType(metaclass=SingletonMeta):
+        """The type of the NoExtraItems singleton."""
+
+        __slots__ = ()
+
+        def __new__(cls):
+            return globals().get("NoExtraItems") or object.__new__(cls)
+
+        def __repr__(self):
+            return "typing_extensions.NoExtraItems"
+
+        def __reduce__(self):
+            return "NoExtraItems"
+
+    NoExtraItems = NoExtraItemsType()
+    del NoExtraItemsType
+
+if _NEEDS_SINGLETONMETA:
+    del SingletonMeta
+
+
+# Update this to something like >=3.13.0b1 if and when
+# PEP 728 is implemented in CPython
+_PEP_728_IMPLEMENTED = False
+
+if _PEP_728_IMPLEMENTED:
+    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
+    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
+    # The standard library TypedDict below Python 3.11 does not store runtime
+    # information about optional and required keys when using Required or NotRequired.
+    # Generic TypedDicts are also impossible using typing.TypedDict on Python <3.11.
+    # Aaaand on 3.12 we add __orig_bases__ to TypedDict
+    # to enable better runtime introspection.
+    # On 3.13 we deprecate some odd ways of creating TypedDicts.
+    # Also on 3.13, PEP 705 adds the ReadOnly[] qualifier.
+    # PEP 728 (still pending) makes more changes.
+    TypedDict = typing.TypedDict
+    _TypedDictMeta = typing._TypedDictMeta
+    is_typeddict = typing.is_typeddict
+else:
+    # 3.10.0 and later
+    _TAKES_MODULE = "module" in inspect.signature(typing._type_check).parameters
+
+    def _get_typeddict_qualifiers(annotation_type):
+        while True:
+            annotation_origin = get_origin(annotation_type)
+            if annotation_origin is Annotated:
+                annotation_args = get_args(annotation_type)
+                if annotation_args:
+                    annotation_type = annotation_args[0]
+                else:
+                    break
+            elif annotation_origin is Required:
+                yield Required
+                annotation_type, = get_args(annotation_type)
+            elif annotation_origin is NotRequired:
+                yield NotRequired
+                annotation_type, = get_args(annotation_type)
+            elif annotation_origin is ReadOnly:
+                yield ReadOnly
+                annotation_type, = get_args(annotation_type)
+            else:
+                break
+
+    class _TypedDictMeta(type):
+
+        def __new__(cls, name, bases, ns, *, total=True, closed=None,
+                    extra_items=NoExtraItems):
+            """Create new typed dict class object.
+
+            This method is called when TypedDict is subclassed,
+            or when TypedDict is instantiated. This way
+            TypedDict supports all three syntax forms described in its docstring.
+            Subclasses and instances of TypedDict return actual dictionaries.
+            """
+            for base in bases:
+                if type(base) is not _TypedDictMeta and base is not typing.Generic:
+                    raise TypeError('cannot inherit from both a TypedDict type '
+                                    'and a non-TypedDict base class')
+            if closed is not None and extra_items is not NoExtraItems:
+                raise TypeError(f"Cannot combine closed={closed!r} and extra_items")
+
+            if any(issubclass(b, typing.Generic) for b in bases):
+                generic_base = (typing.Generic,)
+            else:
+                generic_base = ()
+
+            ns_annotations = ns.pop('__annotations__', None)
+
+            # typing.py generally doesn't let you inherit from plain Generic, unless
+            # the name of the class happens to be "Protocol"
+            tp_dict = type.__new__(_TypedDictMeta, "Protocol", (*generic_base, dict), ns)
+            tp_dict.__name__ = name
+            if tp_dict.__qualname__ == "Protocol":
+                tp_dict.__qualname__ = name
+
+            if not hasattr(tp_dict, '__orig_bases__'):
+                tp_dict.__orig_bases__ = bases
+
+            annotations = {}
+            own_annotate = None
+            if ns_annotations is not None:
+                own_annotations = ns_annotations
+            elif sys.version_info >= (3, 14):
+                if hasattr(annotationlib, "get_annotate_from_class_namespace"):
+                    own_annotate = annotationlib.get_annotate_from_class_namespace(ns)
+                else:
+                    # 3.14.0a7 and earlier
+                    own_annotate = ns.get("__annotate__")
+                if own_annotate is not None:
+                    own_annotations = annotationlib.call_annotate_function(
+                        own_annotate, Format.FORWARDREF, owner=tp_dict
+                    )
+                else:
+                    own_annotations = {}
+            else:
+                own_annotations = {}
+            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
+            if _TAKES_MODULE:
+                own_checked_annotations = {
+                    n: typing._type_check(tp, msg, module=tp_dict.__module__)
+                    for n, tp in own_annotations.items()
+                }
+            else:
+                own_checked_annotations = {
+                    n: typing._type_check(tp, msg)
+                    for n, tp in own_annotations.items()
+                }
+            required_keys = set()
+            optional_keys = set()
+            readonly_keys = set()
+            mutable_keys = set()
+            extra_items_type = extra_items
+
+            for base in bases:
+                base_dict = base.__dict__
+
+                if sys.version_info <= (3, 14):
+                    annotations.update(base_dict.get('__annotations__', {}))
+                required_keys.update(base_dict.get('__required_keys__', ()))
+                optional_keys.update(base_dict.get('__optional_keys__', ()))
+                readonly_keys.update(base_dict.get('__readonly_keys__', ()))
+                mutable_keys.update(base_dict.get('__mutable_keys__', ()))
+
+            # This was specified in an earlier version of PEP 728. Support
+            # is retained for backwards compatibility, but only for Python
+            # 3.13 and lower.
+            if (closed and sys.version_info < (3, 14)
+                       and "__extra_items__" in own_checked_annotations):
+                annotation_type = own_checked_annotations.pop("__extra_items__")
+                qualifiers = set(_get_typeddict_qualifiers(annotation_type))
+                if Required in qualifiers:
+                    raise TypeError(
+                        "Special key __extra_items__ does not support "
+                        "Required"
+                    )
+                if NotRequired in qualifiers:
+                    raise TypeError(
+                        "Special key __extra_items__ does not support "
+                        "NotRequired"
+                    )
+                extra_items_type = annotation_type
+
+            annotations.update(own_checked_annotations)
+            for annotation_key, annotation_type in own_checked_annotations.items():
+                qualifiers = set(_get_typeddict_qualifiers(annotation_type))
+
+                if Required in qualifiers:
+                    required_keys.add(annotation_key)
+                elif NotRequired in qualifiers:
+                    optional_keys.add(annotation_key)
+                elif total:
+                    required_keys.add(annotation_key)
+                else:
+                    optional_keys.add(annotation_key)
+                if ReadOnly in qualifiers:
+                    mutable_keys.discard(annotation_key)
+                    readonly_keys.add(annotation_key)
+                else:
+                    mutable_keys.add(annotation_key)
+                    readonly_keys.discard(annotation_key)
+
+            if sys.version_info >= (3, 14):
+                def __annotate__(format):
+                    annos = {}
+                    for base in bases:
+                        if base is Generic:
+                            continue
+                        base_annotate = base.__annotate__
+                        if base_annotate is None:
+                            continue
+                        base_annos = annotationlib.call_annotate_function(
+                            base_annotate, format, owner=base)
+                        annos.update(base_annos)
+                    if own_annotate is not None:
+                        own = annotationlib.call_annotate_function(
+                            own_annotate, format, owner=tp_dict)
+                        if format != Format.STRING:
+                            own = {
+                                n: typing._type_check(tp, msg, module=tp_dict.__module__)
+                                for n, tp in own.items()
+                            }
+                    elif format == Format.STRING:
+                        own = annotationlib.annotations_to_string(own_annotations)
+                    elif format in (Format.FORWARDREF, Format.VALUE):
+                        own = own_checked_annotations
+                    else:
+                        raise NotImplementedError(format)
+                    annos.update(own)
+                    return annos
+
+                tp_dict.__annotate__ = __annotate__
+            else:
+                tp_dict.__annotations__ = annotations
+            tp_dict.__required_keys__ = frozenset(required_keys)
+            tp_dict.__optional_keys__ = frozenset(optional_keys)
+            tp_dict.__readonly_keys__ = frozenset(readonly_keys)
+            tp_dict.__mutable_keys__ = frozenset(mutable_keys)
+            tp_dict.__total__ = total
+            tp_dict.__closed__ = closed
+            tp_dict.__extra_items__ = extra_items_type
+            return tp_dict
+
+        __call__ = dict  # static method
+
+        def __subclasscheck__(cls, other):
+            # Typed dicts are only for static structural subtyping.
+            raise TypeError('TypedDict does not support instance and class checks')
+
+        __instancecheck__ = __subclasscheck__
+
+    _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {})
+
+    def _create_typeddict(
+        typename,
+        fields,
+        /,
+        *,
+        typing_is_inline,
+        total,
+        closed,
+        extra_items,
+        **kwargs,
+    ):
+        if fields is _marker or fields is None:
+            if fields is _marker:
+                deprecated_thing = (
+                    "Failing to pass a value for the 'fields' parameter"
+                )
+            else:
+                deprecated_thing = "Passing `None` as the 'fields' parameter"
+
+            example = f"`{typename} = TypedDict({typename!r}, {{}})`"
+            deprecation_msg = (
+                f"{deprecated_thing} is deprecated and will be disallowed in "
+                "Python 3.15. To create a TypedDict class with 0 fields "
+                "using the functional syntax, pass an empty dictionary, e.g. "
+            ) + example + "."
+            warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
+            # Support a field called "closed"
+            if closed is not False and closed is not True and closed is not None:
+                kwargs["closed"] = closed
+                closed = None
+            # Or "extra_items"
+            if extra_items is not NoExtraItems:
+                kwargs["extra_items"] = extra_items
+                extra_items = NoExtraItems
+            fields = kwargs
+        elif kwargs:
+            raise TypeError("TypedDict takes either a dict or keyword arguments,"
+                            " but not both")
+        if kwargs:
+            if sys.version_info >= (3, 13):
+                raise TypeError("TypedDict takes no keyword arguments")
+            warnings.warn(
+                "The kwargs-based syntax for TypedDict definitions is deprecated "
+                "in Python 3.11, will be removed in Python 3.13, and may not be "
+                "understood by third-party type checkers.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        ns = {'__annotations__': dict(fields)}
+        module = _caller(depth=4 if typing_is_inline else 2)
+        if module is not None:
+            # Setting correct module is necessary to make typed dict classes
+            # pickleable.
+            ns['__module__'] = module
+
+        td = _TypedDictMeta(typename, (), ns, total=total, closed=closed,
+                            extra_items=extra_items)
+        td.__orig_bases__ = (TypedDict,)
+        return td
+
+    class _TypedDictSpecialForm(_SpecialForm, _root=True):
+        def __call__(
+            self,
+            typename,
+            fields=_marker,
+            /,
+            *,
+            total=True,
+            closed=None,
+            extra_items=NoExtraItems,
+            **kwargs
+        ):
+            return _create_typeddict(
+                typename,
+                fields,
+                typing_is_inline=False,
+                total=total,
+                closed=closed,
+                extra_items=extra_items,
+                **kwargs,
+            )
+
+        def __mro_entries__(self, bases):
+            return (_TypedDict,)
+
+    @_TypedDictSpecialForm
+    def TypedDict(self, args):
+        """A simple typed namespace. At runtime it is equivalent to a plain dict.
+
+        TypedDict creates a dictionary type such that a type checker will expect all
+        instances to have a certain set of keys, where each key is
+        associated with a value of a consistent type. This expectation
+        is not checked at runtime.
+
+        Usage::
+
+            class Point2D(TypedDict):
+                x: int
+                y: int
+                label: str
+
+            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
+            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
+
+            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
+
+        The type info can be accessed via the Point2D.__annotations__ dict, and
+        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
+        TypedDict supports an additional equivalent form::
+
+            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
+
+        By default, all keys must be present in a TypedDict. It is possible
+        to override this by specifying totality::
+
+            class Point2D(TypedDict, total=False):
+                x: int
+                y: int
+
+        This means that a Point2D TypedDict can have any of the keys omitted. A type
+        checker is only expected to support a literal False or True as the value of
+        the total argument. True is the default, and makes all items defined in the
+        class body be required.
+
+        The Required and NotRequired special forms can also be used to mark
+        individual keys as being required or not required::
+
+            class Point2D(TypedDict):
+                x: int  # the "x" key must always be present (Required is the default)
+                y: NotRequired[int]  # the "y" key can be omitted
+
+        See PEP 655 for more details on Required and NotRequired.
+        """
+        # This runs when creating inline TypedDicts:
+        if not isinstance(args, dict):
+            raise TypeError(
+                "TypedDict[...] should be used with a single dict argument"
+            )
+
+        return _create_typeddict(
+            "",
+            args,
+            typing_is_inline=True,
+            total=True,
+            closed=True,
+            extra_items=NoExtraItems,
+        )
+
+    _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)
+
+    def is_typeddict(tp):
+        """Check if an annotation is a TypedDict class
+
+        For example::
+            class Film(TypedDict):
+                title: str
+                year: int
+
+            is_typeddict(Film)  # => True
+            is_typeddict(Union[list, str])  # => False
+        """
+        return isinstance(tp, _TYPEDDICT_TYPES)
+
+
+if hasattr(typing, "assert_type"):
+    assert_type = typing.assert_type
+
+else:
+    def assert_type(val, typ, /):
+        """Assert (to the type checker) that the value is of the given type.
+
+        When the type checker encounters a call to assert_type(), it
+        emits an error if the value is not of the specified type::
+
+            def greet(name: str) -> None:
+                assert_type(name, str)  # ok
+                assert_type(name, int)  # type checker error
+
+        At runtime this returns the first argument unchanged and otherwise
+        does nothing.
+        """
+        return val
+
+
+if hasattr(typing, "ReadOnly"):  # 3.13+
+    get_type_hints = typing.get_type_hints
+else:  # <=3.13
+    # replaces _strip_annotations()
+    def _strip_extras(t):
+        """Strips Annotated, Required and NotRequired from a given type."""
+        if isinstance(t, typing._AnnotatedAlias):
+            return _strip_extras(t.__origin__)
+        if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired, ReadOnly):
+            return _strip_extras(t.__args__[0])
+        if isinstance(t, typing._GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return t.copy_with(stripped_args)
+        if hasattr(_types, "GenericAlias") and isinstance(t, _types.GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return _types.GenericAlias(t.__origin__, stripped_args)
+        if hasattr(_types, "UnionType") and isinstance(t, _types.UnionType):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return functools.reduce(operator.or_, stripped_args)
+
+        return t
+
+    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
+        """Return type hints for an object.
+
+        This is often the same as obj.__annotations__, but it handles
+        forward references encoded as string literals, adds Optional[t] if a
+        default value equal to None is set and recursively replaces all
+        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
+        (unless 'include_extras=True').
+
+        The argument may be a module, class, method, or function. The annotations
+        are returned as a dictionary. For classes, annotations include also
+        inherited members.
+
+        TypeError is raised if the argument is not of a type that can contain
+        annotations, and an empty dictionary is returned if no annotations are
+        present.
+
+        BEWARE -- the behavior of globalns and localns is counterintuitive
+        (unless you are familiar with how eval() and exec() work).  The
+        search order is locals first, then globals.
+
+        - If no dict arguments are passed, an attempt is made to use the
+          globals from obj (or the respective module's globals for classes),
+          and these are also used as the locals.  If the object does not appear
+          to have globals, an empty dictionary is used.
+
+        - If one dict argument is passed, it is used for both globals and
+          locals.
+
+        - If two dict arguments are passed, they specify globals and
+          locals, respectively.
+        """
+        hint = typing.get_type_hints(
+            obj, globalns=globalns, localns=localns, include_extras=True
+        )
+        if sys.version_info < (3, 11):
+            _clean_optional(obj, hint, globalns, localns)
+        if include_extras:
+            return hint
+        return {k: _strip_extras(t) for k, t in hint.items()}
+
+    _NoneType = type(None)
+
+    def _could_be_inserted_optional(t):
+        """detects Union[..., None] pattern"""
+        if not isinstance(t, typing._UnionGenericAlias):
+            return False
+        # Assume if last argument is not None they are user defined
+        if t.__args__[-1] is not _NoneType:
+            return False
+        return True
+
+    # < 3.11
+    def _clean_optional(obj, hints, globalns=None, localns=None):
+        # reverts injected Union[..., None] cases from typing.get_type_hints
+        # when a None default value is used.
+        # see https://github.com/python/typing_extensions/issues/310
+        if not hints or isinstance(obj, type):
+            return
+        defaults = typing._get_defaults(obj)  # avoid accessing __annotations___
+        if not defaults:
+            return
+        original_hints = obj.__annotations__
+        for name, value in hints.items():
+            # Not a Union[..., None] or replacement conditions not fullfilled
+            if (not _could_be_inserted_optional(value)
+                or name not in defaults
+                or defaults[name] is not None
+            ):
+                continue
+            original_value = original_hints[name]
+            # value=NoneType should have caused a skip above but check for safety
+            if original_value is None:
+                original_value = _NoneType
+            # Forward reference
+            if isinstance(original_value, str):
+                if globalns is None:
+                    if isinstance(obj, _types.ModuleType):
+                        globalns = obj.__dict__
+                    else:
+                        nsobj = obj
+                        # Find globalns for the unwrapped object.
+                        while hasattr(nsobj, '__wrapped__'):
+                            nsobj = nsobj.__wrapped__
+                        globalns = getattr(nsobj, '__globals__', {})
+                    if localns is None:
+                        localns = globalns
+                elif localns is None:
+                    localns = globalns
+
+                original_value = ForwardRef(
+                    original_value,
+                    is_argument=not isinstance(obj, _types.ModuleType)
+                )
+            original_evaluated = typing._eval_type(original_value, globalns, localns)
+            # Compare if values differ. Note that even if equal
+            # value might be cached by typing._tp_cache contrary to original_evaluated
+            if original_evaluated != value or (
+                # 3.10: ForwardRefs of UnionType might be turned into _UnionGenericAlias
+                hasattr(_types, "UnionType")
+                and isinstance(original_evaluated, _types.UnionType)
+                and not isinstance(value, _types.UnionType)
+            ):
+                hints[name] = original_evaluated
+
+# Python 3.9 has get_origin() and get_args() but those implementations don't support
+# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
+if sys.version_info[:2] >= (3, 10):
+    get_origin = typing.get_origin
+    get_args = typing.get_args
+# 3.9
+else:
+    def get_origin(tp):
+        """Get the unsubscripted version of a type.
+
+        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
+        and Annotated. Return None for unsupported types. Examples::
+
+            get_origin(Literal[42]) is Literal
+            get_origin(int) is None
+            get_origin(ClassVar[int]) is ClassVar
+            get_origin(Generic) is Generic
+            get_origin(Generic[T]) is Generic
+            get_origin(Union[T, int]) is Union
+            get_origin(List[Tuple[T, T]][int]) == list
+            get_origin(P.args) is P
+        """
+        if isinstance(tp, typing._AnnotatedAlias):
+            return Annotated
+        if isinstance(tp, (typing._BaseGenericAlias, _types.GenericAlias,
+                           ParamSpecArgs, ParamSpecKwargs)):
+            return tp.__origin__
+        if tp is typing.Generic:
+            return typing.Generic
+        return None
+
+    def get_args(tp):
+        """Get type arguments with all substitutions performed.
+
+        For unions, basic simplifications used by Union constructor are performed.
+        Examples::
+            get_args(Dict[str, int]) == (str, int)
+            get_args(int) == ()
+            get_args(Union[int, Union[T, int], str][int]) == (int, str)
+            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
+            get_args(Callable[[], T][int]) == ([], int)
+        """
+        if isinstance(tp, typing._AnnotatedAlias):
+            return (tp.__origin__, *tp.__metadata__)
+        if isinstance(tp, (typing._GenericAlias, _types.GenericAlias)):
+            res = tp.__args__
+            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
+                res = (list(res[:-1]), res[-1])
+            return res
+        return ()
+
+
+# 3.10+
+if hasattr(typing, 'TypeAlias'):
+    TypeAlias = typing.TypeAlias
+# 3.9
+else:
+    @_ExtensionsSpecialForm
+    def TypeAlias(self, parameters):
+        """Special marker indicating that an assignment should
+        be recognized as a proper type alias definition by type
+        checkers.
+
+        For example::
+
+            Predicate: TypeAlias = Callable[..., bool]
+
+        It's invalid when used anywhere except as in the example above.
+        """
+        raise TypeError(f"{self} is not subscriptable")
+
+
+def _set_default(type_param, default):
+    type_param.has_default = lambda: default is not NoDefault
+    type_param.__default__ = default
+
+
+def _set_module(typevarlike):
+    # for pickling:
+    def_mod = _caller(depth=2)
+    if def_mod != 'typing_extensions':
+        typevarlike.__module__ = def_mod
+
+
+class _DefaultMixin:
+    """Mixin for TypeVarLike defaults."""
+
+    __slots__ = ()
+    __init__ = _set_default
+
+
+# Classes using this metaclass must provide a _backported_typevarlike ClassVar
+class _TypeVarLikeMeta(type):
+    def __instancecheck__(cls, __instance: Any) -> bool:
+        return isinstance(__instance, cls._backported_typevarlike)
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import TypeVar
+else:
+    # Add default and infer_variance parameters from PEP 696 and 695
+    class TypeVar(metaclass=_TypeVarLikeMeta):
+        """Type variable."""
+
+        _backported_typevarlike = typing.TypeVar
+
+        def __new__(cls, name, *constraints, bound=None,
+                    covariant=False, contravariant=False,
+                    default=NoDefault, infer_variance=False):
+            if hasattr(typing, "TypeAliasType"):
+                # PEP 695 implemented (3.12+), can pass infer_variance to typing.TypeVar
+                typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                         covariant=covariant, contravariant=contravariant,
+                                         infer_variance=infer_variance)
+            else:
+                typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                         covariant=covariant, contravariant=contravariant)
+                if infer_variance and (covariant or contravariant):
+                    raise ValueError("Variance cannot be specified with infer_variance.")
+                typevar.__infer_variance__ = infer_variance
+
+            _set_default(typevar, default)
+            _set_module(typevar)
+
+            def _tvar_prepare_subst(alias, args):
+                if (
+                    typevar.has_default()
+                    and alias.__parameters__.index(typevar) == len(args)
+                ):
+                    args += (typevar.__default__,)
+                return args
+
+            typevar.__typing_prepare_subst__ = _tvar_prepare_subst
+            return typevar
+
+        def __init_subclass__(cls) -> None:
+            raise TypeError(f"type '{__name__}.TypeVar' is not an acceptable base type")
+
+
+# Python 3.10+ has PEP 612
+if hasattr(typing, 'ParamSpecArgs'):
+    ParamSpecArgs = typing.ParamSpecArgs
+    ParamSpecKwargs = typing.ParamSpecKwargs
+# 3.9
+else:
+    class _Immutable:
+        """Mixin to indicate that object should not be copied."""
+        __slots__ = ()
+
+        def __copy__(self):
+            return self
+
+        def __deepcopy__(self, memo):
+            return self
+
+    class ParamSpecArgs(_Immutable):
+        """The args for a ParamSpec object.
+
+        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.
+
+        ParamSpecArgs objects have a reference back to their ParamSpec:
+
+        P.args.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.args"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecArgs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+    class ParamSpecKwargs(_Immutable):
+        """The kwargs for a ParamSpec object.
+
+        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.
+
+        ParamSpecKwargs objects have a reference back to their ParamSpec:
+
+        P.kwargs.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.kwargs"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecKwargs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import ParamSpec
+
+# 3.10+
+elif hasattr(typing, 'ParamSpec'):
+
+    # Add default parameter - PEP 696
+    class ParamSpec(metaclass=_TypeVarLikeMeta):
+        """Parameter specification."""
+
+        _backported_typevarlike = typing.ParamSpec
+
+        def __new__(cls, name, *, bound=None,
+                    covariant=False, contravariant=False,
+                    infer_variance=False, default=NoDefault):
+            if hasattr(typing, "TypeAliasType"):
+                # PEP 695 implemented, can pass infer_variance to typing.TypeVar
+                paramspec = typing.ParamSpec(name, bound=bound,
+                                             covariant=covariant,
+                                             contravariant=contravariant,
+                                             infer_variance=infer_variance)
+            else:
+                paramspec = typing.ParamSpec(name, bound=bound,
+                                             covariant=covariant,
+                                             contravariant=contravariant)
+                paramspec.__infer_variance__ = infer_variance
+
+            _set_default(paramspec, default)
+            _set_module(paramspec)
+
+            def _paramspec_prepare_subst(alias, args):
+                params = alias.__parameters__
+                i = params.index(paramspec)
+                if i == len(args) and paramspec.has_default():
+                    args = [*args, paramspec.__default__]
+                if i >= len(args):
+                    raise TypeError(f"Too few arguments for {alias}")
+                # Special case where Z[[int, str, bool]] == Z[int, str, bool] in PEP 612.
+                if len(params) == 1 and not typing._is_param_expr(args[0]):
+                    assert i == 0
+                    args = (args,)
+                # Convert lists to tuples to help other libraries cache the results.
+                elif isinstance(args[i], list):
+                    args = (*args[:i], tuple(args[i]), *args[i + 1:])
+                return args
+
+            paramspec.__typing_prepare_subst__ = _paramspec_prepare_subst
+            return paramspec
+
+        def __init_subclass__(cls) -> None:
+            raise TypeError(f"type '{__name__}.ParamSpec' is not an acceptable base type")
+
+# 3.9
+else:
+
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+    class ParamSpec(list, _DefaultMixin):
+        """Parameter specification variable.
+
+        Usage::
+
+           P = ParamSpec('P')
+
+        Parameter specification variables exist primarily for the benefit of static
+        type checkers.  They are used to forward the parameter types of one
+        callable to another callable, a pattern commonly found in higher order
+        functions and decorators.  They are only valid when used in ``Concatenate``,
+        or s the first argument to ``Callable``. In Python 3.10 and higher,
+        they are also supported in user-defined Generics at runtime.
+        See class Generic for more information on generic types.  An
+        example for annotating a decorator::
+
+           T = TypeVar('T')
+           P = ParamSpec('P')
+
+           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
+               '''A type-safe decorator to add logging to a function.'''
+               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
+                   logging.info(f'{f.__name__} was called')
+                   return f(*args, **kwargs)
+               return inner
+
+           @add_logging
+           def add_two(x: float, y: float) -> float:
+               '''Add two numbers together.'''
+               return x + y
+
+        Parameter specification variables defined with covariant=True or
+        contravariant=True can be used to declare covariant or contravariant
+        generic types.  These keyword arguments are valid, but their actual semantics
+        are yet to be decided.  See PEP 612 for details.
+
+        Parameter specification variables can be introspected. e.g.:
+
+           P.__name__ == 'T'
+           P.__bound__ == None
+           P.__covariant__ == False
+           P.__contravariant__ == False
+
+        Note that only parameter specification variables defined in global scope can
+        be pickled.
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        @property
+        def args(self):
+            return ParamSpecArgs(self)
+
+        @property
+        def kwargs(self):
+            return ParamSpecKwargs(self)
+
+        def __init__(self, name, *, bound=None, covariant=False, contravariant=False,
+                     infer_variance=False, default=NoDefault):
+            list.__init__(self, [self])
+            self.__name__ = name
+            self.__covariant__ = bool(covariant)
+            self.__contravariant__ = bool(contravariant)
+            self.__infer_variance__ = bool(infer_variance)
+            if bound:
+                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
+            else:
+                self.__bound__ = None
+            _DefaultMixin.__init__(self, default)
+
+            # for pickling:
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+        def __repr__(self):
+            if self.__infer_variance__:
+                prefix = ''
+            elif self.__covariant__:
+                prefix = '+'
+            elif self.__contravariant__:
+                prefix = '-'
+            else:
+                prefix = '~'
+            return prefix + self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        # Hack to get typing._type_check to pass.
+        def __call__(self, *args, **kwargs):
+            pass
+
+
+# 3.9
+if not hasattr(typing, 'Concatenate'):
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+
+    # 3.9.0-1
+    if not hasattr(typing, '_type_convert'):
+        def _type_convert(arg, module=None, *, allow_special_forms=False):
+            """For converting None to type(None), and strings to ForwardRef."""
+            if arg is None:
+                return type(None)
+            if isinstance(arg, str):
+                if sys.version_info <= (3, 9, 6):
+                    return ForwardRef(arg)
+                if sys.version_info <= (3, 9, 7):
+                    return ForwardRef(arg, module=module)
+                return ForwardRef(arg, module=module, is_class=allow_special_forms)
+            return arg
+    else:
+        _type_convert = typing._type_convert
+
+    class _ConcatenateGenericAlias(list):
+
+        # Trick Generic into looking into this for __parameters__.
+        __class__ = typing._GenericAlias
+
+        def __init__(self, origin, args):
+            super().__init__(args)
+            self.__origin__ = origin
+            self.__args__ = args
+
+        def __repr__(self):
+            _type_repr = typing._type_repr
+            return (f'{_type_repr(self.__origin__)}'
+                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')
+
+        def __hash__(self):
+            return hash((self.__origin__, self.__args__))
+
+        # Hack to get typing._type_check to pass in Generic.
+        def __call__(self, *args, **kwargs):
+            pass
+
+        @property
+        def __parameters__(self):
+            return tuple(
+                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
+            )
+
+        # 3.9 used by __getitem__ below
+        def copy_with(self, params):
+            if isinstance(params[-1], _ConcatenateGenericAlias):
+                params = (*params[:-1], *params[-1].__args__)
+            elif isinstance(params[-1], (list, tuple)):
+                return (*params[:-1], *params[-1])
+            elif (not (params[-1] is ... or isinstance(params[-1], ParamSpec))):
+                raise TypeError("The last parameter to Concatenate should be a "
+                        "ParamSpec variable or ellipsis.")
+            return self.__class__(self.__origin__, params)
+
+        # 3.9; accessed during GenericAlias.__getitem__ when substituting
+        def __getitem__(self, args):
+            if self.__origin__ in (Generic, Protocol):
+                # Can't subscript Generic[...] or Protocol[...].
+                raise TypeError(f"Cannot subscript already-subscripted {self}")
+            if not self.__parameters__:
+                raise TypeError(f"{self} is not a generic class")
+
+            if not isinstance(args, tuple):
+                args = (args,)
+            args = _unpack_args(*(_type_convert(p) for p in args))
+            params = self.__parameters__
+            for param in params:
+                prepare = getattr(param, "__typing_prepare_subst__", None)
+                if prepare is not None:
+                    args = prepare(self, args)
+                # 3.9 & typing.ParamSpec
+                elif isinstance(param, ParamSpec):
+                    i = params.index(param)
+                    if (
+                        i == len(args)
+                        and getattr(param, '__default__', NoDefault) is not NoDefault
+                    ):
+                        args = [*args, param.__default__]
+                    if i >= len(args):
+                        raise TypeError(f"Too few arguments for {self}")
+                    # Special case for Z[[int, str, bool]] == Z[int, str, bool]
+                    if len(params) == 1 and not _is_param_expr(args[0]):
+                        assert i == 0
+                        args = (args,)
+                    elif (
+                        isinstance(args[i], list)
+                        # 3.9
+                        # This class inherits from list do not convert
+                        and not isinstance(args[i], _ConcatenateGenericAlias)
+                    ):
+                        args = (*args[:i], tuple(args[i]), *args[i + 1:])
+
+            alen = len(args)
+            plen = len(params)
+            if alen != plen:
+                raise TypeError(
+                    f"Too {'many' if alen > plen else 'few'} arguments for {self};"
+                    f" actual {alen}, expected {plen}"
+                )
+
+            subst = dict(zip(self.__parameters__, args))
+            # determine new args
+            new_args = []
+            for arg in self.__args__:
+                if isinstance(arg, type):
+                    new_args.append(arg)
+                    continue
+                if isinstance(arg, TypeVar):
+                    arg = subst[arg]
+                    if (
+                        (isinstance(arg, typing._GenericAlias) and _is_unpack(arg))
+                        or (
+                            hasattr(_types, "GenericAlias")
+                            and isinstance(arg, _types.GenericAlias)
+                            and getattr(arg, "__unpacked__", False)
+                        )
+                    ):
+                        raise TypeError(f"{arg} is not valid as type argument")
+
+                elif isinstance(arg,
+                    typing._GenericAlias
+                    if not hasattr(_types, "GenericAlias") else
+                    (typing._GenericAlias, _types.GenericAlias)
+                ):
+                    subparams = arg.__parameters__
+                    if subparams:
+                        subargs = tuple(subst[x] for x in subparams)
+                        arg = arg[subargs]
+                new_args.append(arg)
+            return self.copy_with(tuple(new_args))
+
+# 3.10+
+else:
+    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias
+
+    # 3.10
+    if sys.version_info < (3, 11):
+
+        class _ConcatenateGenericAlias(typing._ConcatenateGenericAlias, _root=True):
+            # needed for checks in collections.abc.Callable to accept this class
+            __module__ = "typing"
+
+            def copy_with(self, params):
+                if isinstance(params[-1], (list, tuple)):
+                    return (*params[:-1], *params[-1])
+                if isinstance(params[-1], typing._ConcatenateGenericAlias):
+                    params = (*params[:-1], *params[-1].__args__)
+                elif not (params[-1] is ... or isinstance(params[-1], ParamSpec)):
+                    raise TypeError("The last parameter to Concatenate should be a "
+                            "ParamSpec variable or ellipsis.")
+                return super(typing._ConcatenateGenericAlias, self).copy_with(params)
+
+            def __getitem__(self, args):
+                value = super().__getitem__(args)
+                if isinstance(value, tuple) and any(_is_unpack(t) for t in value):
+                    return tuple(_unpack_args(*(n for n in value)))
+                return value
+
+
+# 3.9.2
+class _EllipsisDummy: ...
+
+
+# <=3.10
+def _create_concatenate_alias(origin, parameters):
+    if parameters[-1] is ... and sys.version_info < (3, 9, 2):
+        # Hack: Arguments must be types, replace it with one.
+        parameters = (*parameters[:-1], _EllipsisDummy)
+    if sys.version_info >= (3, 10, 3):
+        concatenate = _ConcatenateGenericAlias(origin, parameters,
+                                        _typevar_types=(TypeVar, ParamSpec),
+                                        _paramspec_tvars=True)
+    else:
+        concatenate = _ConcatenateGenericAlias(origin, parameters)
+    if parameters[-1] is not _EllipsisDummy:
+        return concatenate
+    # Remove dummy again
+    concatenate.__args__ = tuple(p if p is not _EllipsisDummy else ...
+                                    for p in concatenate.__args__)
+    if sys.version_info < (3, 10):
+        # backport needs __args__ adjustment only
+        return concatenate
+    concatenate.__parameters__ = tuple(p for p in concatenate.__parameters__
+                                        if p is not _EllipsisDummy)
+    return concatenate
+
+
+# <=3.10
+@typing._tp_cache
+def _concatenate_getitem(self, parameters):
+    if parameters == ():
+        raise TypeError("Cannot take a Concatenate of no types.")
+    if not isinstance(parameters, tuple):
+        parameters = (parameters,)
+    if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)):
+        raise TypeError("The last parameter to Concatenate should be a "
+                        "ParamSpec variable or ellipsis.")
+    msg = "Concatenate[arg, ...]: each arg must be a type."
+    parameters = (*(typing._type_check(p, msg) for p in parameters[:-1]),
+                    parameters[-1])
+    return _create_concatenate_alias(self, parameters)
+
+
+# 3.11+; Concatenate does not accept ellipsis in 3.10
+if sys.version_info >= (3, 11):
+    Concatenate = typing.Concatenate
+# <=3.10
+else:
+    @_ExtensionsSpecialForm
+    def Concatenate(self, parameters):
+        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
+        higher order function which adds, removes or transforms parameters of a
+        callable.
+
+        For example::
+
+           Callable[Concatenate[int, P], int]
+
+        See PEP 612 for detailed information.
+        """
+        return _concatenate_getitem(self, parameters)
+
+
+# 3.10+
+if hasattr(typing, 'TypeGuard'):
+    TypeGuard = typing.TypeGuard
+# 3.9
+else:
+    @_ExtensionsSpecialForm
+    def TypeGuard(self, parameters):
+        """Special typing form used to annotate the return type of a user-defined
+        type guard function.  ``TypeGuard`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeGuard`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the type inside ``TypeGuard``.
+
+        For example::
+
+            def is_str(val: Union[str, float]):
+                # "isinstance" type guard
+                if isinstance(val, str):
+                    # Type of ``val`` is narrowed to ``str``
+                    ...
+                else:
+                    # Else, type of ``val`` is narrowed to ``float``.
+                    ...
+
+        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
+        form of ``TypeA`` (it can even be a wider form) and this may lead to
+        type-unsafe results.  The main reason is to allow for things like
+        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
+        a subtype of the former, since ``List`` is invariant.  The responsibility of
+        writing type-safe type guards is left to the user.
+
+        ``TypeGuard`` also works with type variables.  For more information, see
+        PEP 647 (User-Defined Type Guards).
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+
+# 3.13+
+if hasattr(typing, 'TypeIs'):
+    TypeIs = typing.TypeIs
+# <=3.12
+else:
+    @_ExtensionsSpecialForm
+    def TypeIs(self, parameters):
+        """Special typing form used to annotate the return type of a user-defined
+        type narrower function.  ``TypeIs`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeIs[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeIs`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the intersection of the type inside ``TypeIs`` and the argument's
+        previously known type.
+
+        For example::
+
+            def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
+                return hasattr(val, '__await__')
+
+            def f(val: Union[int, Awaitable[int]]) -> int:
+                if is_awaitable(val):
+                    assert_type(val, Awaitable[int])
+                else:
+                    assert_type(val, int)
+
+        ``TypeIs`` also works with type variables.  For more information, see
+        PEP 742 (Narrowing types with TypeIs).
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+
+# 3.14+?
+if hasattr(typing, 'TypeForm'):
+    TypeForm = typing.TypeForm
+# <=3.13
+else:
+    class _TypeFormForm(_ExtensionsSpecialForm, _root=True):
+        # TypeForm(X) is equivalent to X but indicates to the type checker
+        # that the object is a TypeForm.
+        def __call__(self, obj, /):
+            return obj
+
+    @_TypeFormForm
+    def TypeForm(self, parameters):
+        """A special form representing the value that results from the evaluation
+        of a type expression. This value encodes the information supplied in the
+        type expression, and it represents the type described by that type expression.
+
+        When used in a type expression, TypeForm describes a set of type form objects.
+        It accepts a single type argument, which must be a valid type expression.
+        ``TypeForm[T]`` describes the set of all type form objects that represent
+        the type T or types that are assignable to T.
+
+        Usage:
+
+            def cast[T](typ: TypeForm[T], value: Any) -> T: ...
+
+            reveal_type(cast(int, "x"))  # int
+
+        See PEP 747 for more information.
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+
+
+
+if hasattr(typing, "LiteralString"):  # 3.11+
+    LiteralString = typing.LiteralString
+else:
+    @_SpecialForm
+    def LiteralString(self, params):
+        """Represents an arbitrary literal string.
+
+        Example::
+
+          from typing_extensions import LiteralString
+
+          def query(sql: LiteralString) -> ...:
+              ...
+
+          query("SELECT * FROM table")  # ok
+          query(f"SELECT * FROM {input()}")  # not ok
+
+        See PEP 675 for details.
+
+        """
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Self"):  # 3.11+
+    Self = typing.Self
+else:
+    @_SpecialForm
+    def Self(self, params):
+        """Used to spell the type of "self" in classes.
+
+        Example::
+
+          from typing import Self
+
+          class ReturnsSelf:
+              def parse(self, data: bytes) -> Self:
+                  ...
+                  return self
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Never"):  # 3.11+
+    Never = typing.Never
+else:
+    @_SpecialForm
+    def Never(self, params):
+        """The bottom type, a type that has no members.
+
+        This can be used to define a function that should never be
+        called, or a function that never returns::
+
+            from typing_extensions import Never
+
+            def never_call_me(arg: Never) -> None:
+                pass
+
+            def int_or_str(arg: int | str) -> None:
+                never_call_me(arg)  # type checker error
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        never_call_me(arg)  # ok, arg is of type Never
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, 'Required'):  # 3.11+
+    Required = typing.Required
+    NotRequired = typing.NotRequired
+else:  # <=3.10
+    @_ExtensionsSpecialForm
+    def Required(self, parameters):
+        """A special typing construct to mark a key of a total=False TypedDict
+        as required. For example:
+
+            class Movie(TypedDict, total=False):
+                title: Required[str]
+                year: int
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+
+        There is no runtime checking that a required key is actually provided
+        when instantiating a related TypedDict.
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+    @_ExtensionsSpecialForm
+    def NotRequired(self, parameters):
+        """A special typing construct to mark a key of a TypedDict as
+        potentially missing. For example:
+
+            class Movie(TypedDict):
+                title: str
+                year: NotRequired[int]
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+
+if hasattr(typing, 'ReadOnly'):
+    ReadOnly = typing.ReadOnly
+else:  # <=3.12
+    @_ExtensionsSpecialForm
+    def ReadOnly(self, parameters):
+        """A special typing construct to mark an item of a TypedDict as read-only.
+
+        For example:
+
+            class Movie(TypedDict):
+                title: ReadOnly[str]
+                year: int
+
+            def mutate_movie(m: Movie) -> None:
+                m["year"] = 1992  # allowed
+                m["title"] = "The Matrix"  # typechecker error
+
+        There is no runtime checking for this property.
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+
+_UNPACK_DOC = """\
+Type unpack operator.
+
+The type unpack operator takes the child types from some container type,
+such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. For
+example:
+
+  # For some generic class `Foo`:
+  Foo[Unpack[tuple[int, str]]]  # Equivalent to Foo[int, str]
+
+  Ts = TypeVarTuple('Ts')
+  # Specifies that `Bar` is generic in an arbitrary number of types.
+  # (Think of `Ts` as a tuple of an arbitrary number of individual
+  #  `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
+  #  `Generic[]`.)
+  class Bar(Generic[Unpack[Ts]]): ...
+  Bar[int]  # Valid
+  Bar[int, str]  # Also valid
+
+From Python 3.11, this can also be done using the `*` operator:
+
+    Foo[*tuple[int, str]]
+    class Bar(Generic[*Ts]): ...
+
+The operator can also be used along with a `TypedDict` to annotate
+`**kwargs` in a function signature. For instance:
+
+  class Movie(TypedDict):
+    name: str
+    year: int
+
+  # This function expects two keyword arguments - *name* of type `str` and
+  # *year* of type `int`.
+  def foo(**kwargs: Unpack[Movie]): ...
+
+Note that there is only some runtime checking of this operator. Not
+everything the runtime allows may be accepted by static type checkers.
+
+For more information, see PEP 646 and PEP 692.
+"""
+
+
+if sys.version_info >= (3, 12):  # PEP 692 changed the repr of Unpack[]
+    Unpack = typing.Unpack
+
+    def _is_unpack(obj):
+        return get_origin(obj) is Unpack
+
+else:  # <=3.11
+    class _UnpackSpecialForm(_ExtensionsSpecialForm, _root=True):
+        def __init__(self, getitem):
+            super().__init__(getitem)
+            self.__doc__ = _UNPACK_DOC
+
+    class _UnpackAlias(typing._GenericAlias, _root=True):
+        if sys.version_info < (3, 11):
+            # needed for compatibility with Generic[Unpack[Ts]]
+            __class__ = typing.TypeVar
+
+        @property
+        def __typing_unpacked_tuple_args__(self):
+            assert self.__origin__ is Unpack
+            assert len(self.__args__) == 1
+            arg, = self.__args__
+            if isinstance(arg, (typing._GenericAlias, _types.GenericAlias)):
+                if arg.__origin__ is not tuple:
+                    raise TypeError("Unpack[...] must be used with a tuple type")
+                return arg.__args__
+            return None
+
+        @property
+        def __typing_is_unpacked_typevartuple__(self):
+            assert self.__origin__ is Unpack
+            assert len(self.__args__) == 1
+            return isinstance(self.__args__[0], TypeVarTuple)
+
+        def __getitem__(self, args):
+            if self.__typing_is_unpacked_typevartuple__:
+                return args
+            return super().__getitem__(args)
+
+    @_UnpackSpecialForm
+    def Unpack(self, parameters):
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return _UnpackAlias(self, (item,))
+
+    def _is_unpack(obj):
+        return isinstance(obj, _UnpackAlias)
+
+
+def _unpack_args(*args):
+    newargs = []
+    for arg in args:
+        subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
+        if subargs is not None and (not (subargs and subargs[-1] is ...)):
+            newargs.extend(subargs)
+        else:
+            newargs.append(arg)
+    return newargs
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import TypeVarTuple
+
+elif hasattr(typing, "TypeVarTuple"):  # 3.11+
+
+    # Add default parameter - PEP 696
+    class TypeVarTuple(metaclass=_TypeVarLikeMeta):
+        """Type variable tuple."""
+
+        _backported_typevarlike = typing.TypeVarTuple
+
+        def __new__(cls, name, *, default=NoDefault):
+            tvt = typing.TypeVarTuple(name)
+            _set_default(tvt, default)
+            _set_module(tvt)
+
+            def _typevartuple_prepare_subst(alias, args):
+                params = alias.__parameters__
+                typevartuple_index = params.index(tvt)
+                for param in params[typevartuple_index + 1:]:
+                    if isinstance(param, TypeVarTuple):
+                        raise TypeError(
+                            f"More than one TypeVarTuple parameter in {alias}"
+                        )
+
+                alen = len(args)
+                plen = len(params)
+                left = typevartuple_index
+                right = plen - typevartuple_index - 1
+                var_tuple_index = None
+                fillarg = None
+                for k, arg in enumerate(args):
+                    if not isinstance(arg, type):
+                        subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
+                        if subargs and len(subargs) == 2 and subargs[-1] is ...:
+                            if var_tuple_index is not None:
+                                raise TypeError(
+                                    "More than one unpacked "
+                                    "arbitrary-length tuple argument"
+                                )
+                            var_tuple_index = k
+                            fillarg = subargs[0]
+                if var_tuple_index is not None:
+                    left = min(left, var_tuple_index)
+                    right = min(right, alen - var_tuple_index - 1)
+                elif left + right > alen:
+                    raise TypeError(f"Too few arguments for {alias};"
+                                    f" actual {alen}, expected at least {plen - 1}")
+                if left == alen - right and tvt.has_default():
+                    replacement = _unpack_args(tvt.__default__)
+                else:
+                    replacement = args[left: alen - right]
+
+                return (
+                    *args[:left],
+                    *([fillarg] * (typevartuple_index - left)),
+                    replacement,
+                    *([fillarg] * (plen - right - left - typevartuple_index - 1)),
+                    *args[alen - right:],
+                )
+
+            tvt.__typing_prepare_subst__ = _typevartuple_prepare_subst
+            return tvt
+
+        def __init_subclass__(self, *args, **kwds):
+            raise TypeError("Cannot subclass special typing classes")
+
+else:  # <=3.10
+    class TypeVarTuple(_DefaultMixin):
+        """Type variable tuple.
+
+        Usage::
+
+            Ts = TypeVarTuple('Ts')
+
+        In the same way that a normal type variable is a stand-in for a single
+        type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
+        type such as ``Tuple[int, str]``.
+
+        Type variable tuples can be used in ``Generic`` declarations.
+        Consider the following example::
+
+            class Array(Generic[*Ts]): ...
+
+        The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
+        where ``T1`` and ``T2`` are type variables. To use these type variables
+        as type parameters of ``Array``, we must *unpack* the type variable tuple using
+        the star operator: ``*Ts``. The signature of ``Array`` then behaves
+        as if we had simply written ``class Array(Generic[T1, T2]): ...``.
+        In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
+        us to parameterise the class with an *arbitrary* number of type parameters.
+
+        Type variable tuples can be used anywhere a normal ``TypeVar`` can.
+        This includes class definitions, as shown above, as well as function
+        signatures and variable annotations::
+
+            class Array(Generic[*Ts]):
+
+                def __init__(self, shape: Tuple[*Ts]):
+                    self._shape: Tuple[*Ts] = shape
+
+                def get_shape(self) -> Tuple[*Ts]:
+                    return self._shape
+
+            shape = (Height(480), Width(640))
+            x: Array[Height, Width] = Array(shape)
+            y = abs(x)  # Inferred type is Array[Height, Width]
+            z = x + x   #        ...    is Array[Height, Width]
+            x.get_shape()  #     ...    is tuple[Height, Width]
+
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        def __iter__(self):
+            yield self.__unpacked__
+
+        def __init__(self, name, *, default=NoDefault):
+            self.__name__ = name
+            _DefaultMixin.__init__(self, default)
+
+            # for pickling:
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+            self.__unpacked__ = Unpack[self]
+
+        def __repr__(self):
+            return self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        def __init_subclass__(self, *args, **kwds):
+            if '_root' not in kwds:
+                raise TypeError("Cannot subclass special typing classes")
+
+
+if hasattr(typing, "reveal_type"):  # 3.11+
+    reveal_type = typing.reveal_type
+else:  # <=3.10
+    def reveal_type(obj: T, /) -> T:
+        """Reveal the inferred type of a variable.
+
+        When a static type checker encounters a call to ``reveal_type()``,
+        it will emit the inferred type of the argument::
+
+            x: int = 1
+            reveal_type(x)
+
+        Running a static type checker (e.g., ``mypy``) on this example
+        will produce output similar to 'Revealed type is "builtins.int"'.
+
+        At runtime, the function prints the runtime type of the
+        argument and returns it unchanged.
+
+        """
+        print(f"Runtime type is {type(obj).__name__!r}", file=sys.stderr)
+        return obj
+
+
+if hasattr(typing, "_ASSERT_NEVER_REPR_MAX_LENGTH"):  # 3.11+
+    _ASSERT_NEVER_REPR_MAX_LENGTH = typing._ASSERT_NEVER_REPR_MAX_LENGTH
+else:  # <=3.10
+    _ASSERT_NEVER_REPR_MAX_LENGTH = 100
+
+
+if hasattr(typing, "assert_never"):  # 3.11+
+    assert_never = typing.assert_never
+else:  # <=3.10
+    def assert_never(arg: Never, /) -> Never:
+        """Assert to the type checker that a line of code is unreachable.
+
+        Example::
+
+            def int_or_str(arg: int | str) -> None:
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        assert_never(arg)
+
+        If a type checker finds that a call to assert_never() is
+        reachable, it will emit an error.
+
+        At runtime, this throws an exception when called.
+
+        """
+        value = repr(arg)
+        if len(value) > _ASSERT_NEVER_REPR_MAX_LENGTH:
+            value = value[:_ASSERT_NEVER_REPR_MAX_LENGTH] + '...'
+        raise AssertionError(f"Expected code to be unreachable, but got: {value}")
+
+
+if sys.version_info >= (3, 12):  # 3.12+
+    # dataclass_transform exists in 3.11 but lacks the frozen_default parameter
+    dataclass_transform = typing.dataclass_transform
+else:  # <=3.11
+    def dataclass_transform(
+        *,
+        eq_default: bool = True,
+        order_default: bool = False,
+        kw_only_default: bool = False,
+        frozen_default: bool = False,
+        field_specifiers: typing.Tuple[
+            typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]],
+            ...
+        ] = (),
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[T], T]:
+        """Decorator that marks a function, class, or metaclass as providing
+        dataclass-like behavior.
+
+        Example:
+
+            from typing_extensions import dataclass_transform
+
+            _T = TypeVar("_T")
+
+            # Used on a decorator function
+            @dataclass_transform()
+            def create_model(cls: type[_T]) -> type[_T]:
+                ...
+                return cls
+
+            @create_model
+            class CustomerModel:
+                id: int
+                name: str
+
+            # Used on a base class
+            @dataclass_transform()
+            class ModelBase: ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+            # Used on a metaclass
+            @dataclass_transform()
+            class ModelMeta(type): ...
+
+            class ModelBase(metaclass=ModelMeta): ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+        Each of the ``CustomerModel`` classes defined in this example will now
+        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
+        decorator. For example, the type checker will synthesize an ``__init__``
+        method.
+
+        The arguments to this decorator can be used to customize this behavior:
+        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
+          True or False if it is omitted by the caller.
+        - ``order_default`` indicates whether the ``order`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``frozen_default`` indicates whether the ``frozen`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``field_specifiers`` specifies a static list of supported classes
+          or functions that describe fields, similar to ``dataclasses.field()``.
+
+        At runtime, this decorator records its arguments in the
+        ``__dataclass_transform__`` attribute on the decorated object.
+
+        See PEP 681 for details.
+
+        """
+        def decorator(cls_or_fn):
+            cls_or_fn.__dataclass_transform__ = {
+                "eq_default": eq_default,
+                "order_default": order_default,
+                "kw_only_default": kw_only_default,
+                "frozen_default": frozen_default,
+                "field_specifiers": field_specifiers,
+                "kwargs": kwargs,
+            }
+            return cls_or_fn
+        return decorator
+
+
+if hasattr(typing, "override"):  # 3.12+
+    override = typing.override
+else:  # <=3.11
+    _F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any])
+
+    def override(arg: _F, /) -> _F:
+        """Indicate that a method is intended to override a method in a base class.
+
+        Usage:
+
+            class Base:
+                def method(self) -> None:
+                    pass
+
+            class Child(Base):
+                @override
+                def method(self) -> None:
+                    super().method()
+
+        When this decorator is applied to a method, the type checker will
+        validate that it overrides a method with the same name on a base class.
+        This helps prevent bugs that may occur when a base class is changed
+        without an equivalent change to a child class.
+
+        There is no runtime checking of these properties. The decorator
+        sets the ``__override__`` attribute to ``True`` on the decorated object
+        to allow runtime introspection.
+
+        See PEP 698 for details.
+
+        """
+        try:
+            arg.__override__ = True
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable.
+            # AttributeError happens if the object has __slots__ or a
+            # read-only property, TypeError if it's a builtin class.
+            pass
+        return arg
+
+
+# Python 3.13.3+ contains a fix for the wrapped __new__
+if sys.version_info >= (3, 13, 3):
+    deprecated = warnings.deprecated
+else:
+    _T = typing.TypeVar("_T")
+
+    class deprecated:
+        """Indicate that a class, function or overload is deprecated.
+
+        When this decorator is applied to an object, the type checker
+        will generate a diagnostic on usage of the deprecated object.
+
+        Usage:
+
+            @deprecated("Use B instead")
+            class A:
+                pass
+
+            @deprecated("Use g instead")
+            def f():
+                pass
+
+            @overload
+            @deprecated("int support is deprecated")
+            def g(x: int) -> int: ...
+            @overload
+            def g(x: str) -> int: ...
+
+        The warning specified by *category* will be emitted at runtime
+        on use of deprecated objects. For functions, that happens on calls;
+        for classes, on instantiation and on creation of subclasses.
+        If the *category* is ``None``, no warning is emitted at runtime.
+        The *stacklevel* determines where the
+        warning is emitted. If it is ``1`` (the default), the warning
+        is emitted at the direct caller of the deprecated object; if it
+        is higher, it is emitted further up the stack.
+        Static type checker behavior is not affected by the *category*
+        and *stacklevel* arguments.
+
+        The deprecation message passed to the decorator is saved in the
+        ``__deprecated__`` attribute on the decorated object.
+        If applied to an overload, the decorator
+        must be after the ``@overload`` decorator for the attribute to
+        exist on the overload as returned by ``get_overloads()``.
+
+        See PEP 702 for details.
+
+        """
+        def __init__(
+            self,
+            message: str,
+            /,
+            *,
+            category: typing.Optional[typing.Type[Warning]] = DeprecationWarning,
+            stacklevel: int = 1,
+        ) -> None:
+            if not isinstance(message, str):
+                raise TypeError(
+                    "Expected an object of type str for 'message', not "
+                    f"{type(message).__name__!r}"
+                )
+            self.message = message
+            self.category = category
+            self.stacklevel = stacklevel
+
+        def __call__(self, arg: _T, /) -> _T:
+            # Make sure the inner functions created below don't
+            # retain a reference to self.
+            msg = self.message
+            category = self.category
+            stacklevel = self.stacklevel
+            if category is None:
+                arg.__deprecated__ = msg
+                return arg
+            elif isinstance(arg, type):
+                import functools
+                from types import MethodType
+
+                original_new = arg.__new__
+
+                @functools.wraps(original_new)
+                def __new__(cls, /, *args, **kwargs):
+                    if cls is arg:
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    if original_new is not object.__new__:
+                        return original_new(cls, *args, **kwargs)
+                    # Mirrors a similar check in object.__new__.
+                    elif cls.__init__ is object.__init__ and (args or kwargs):
+                        raise TypeError(f"{cls.__name__}() takes no arguments")
+                    else:
+                        return original_new(cls)
+
+                arg.__new__ = staticmethod(__new__)
+
+                original_init_subclass = arg.__init_subclass__
+                # We need slightly different behavior if __init_subclass__
+                # is a bound method (likely if it was implemented in Python)
+                if isinstance(original_init_subclass, MethodType):
+                    original_init_subclass = original_init_subclass.__func__
+
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = classmethod(__init_subclass__)
+                # Or otherwise, which likely means it's a builtin such as
+                # object's implementation of __init_subclass__.
+                else:
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = __init_subclass__
+
+                arg.__deprecated__ = __new__.__deprecated__ = msg
+                __init_subclass__.__deprecated__ = msg
+                return arg
+            elif callable(arg):
+                import asyncio.coroutines
+                import functools
+                import inspect
+
+                @functools.wraps(arg)
+                def wrapper(*args, **kwargs):
+                    warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return arg(*args, **kwargs)
+
+                if asyncio.coroutines.iscoroutinefunction(arg):
+                    if sys.version_info >= (3, 12):
+                        wrapper = inspect.markcoroutinefunction(wrapper)
+                    else:
+                        wrapper._is_coroutine = asyncio.coroutines._is_coroutine
+
+                arg.__deprecated__ = wrapper.__deprecated__ = msg
+                return wrapper
+            else:
+                raise TypeError(
+                    "@deprecated decorator with non-None category must be applied to "
+                    f"a class or callable, not {arg!r}"
+                )
+
+if sys.version_info < (3, 10):
+    def _is_param_expr(arg):
+        return arg is ... or isinstance(
+            arg, (tuple, list, ParamSpec, _ConcatenateGenericAlias)
+        )
+else:
+    def _is_param_expr(arg):
+        return arg is ... or isinstance(
+            arg,
+            (
+                tuple,
+                list,
+                ParamSpec,
+                _ConcatenateGenericAlias,
+                typing._ConcatenateGenericAlias,
+            ),
+        )
+
+
+# We have to do some monkey patching to deal with the dual nature of
+# Unpack/TypeVarTuple:
+# - We want Unpack to be a kind of TypeVar so it gets accepted in
+#   Generic[Unpack[Ts]]
+# - We want it to *not* be treated as a TypeVar for the purposes of
+#   counting generic parameters, so that when we subscript a generic,
+#   the runtime doesn't try to substitute the Unpack with the subscripted type.
+if not hasattr(typing, "TypeVarTuple"):
+    def _check_generic(cls, parameters, elen=_marker):
+        """Check correct count for parameters of a generic cls (internal helper).
+
+        This gives a nice error message in case of count mismatch.
+        """
+        # If substituting a single ParamSpec with multiple arguments
+        # we do not check the count
+        if (inspect.isclass(cls) and issubclass(cls, typing.Generic)
+            and len(cls.__parameters__) == 1
+            and isinstance(cls.__parameters__[0], ParamSpec)
+            and parameters
+            and not _is_param_expr(parameters[0])
+        ):
+            # Generic modifies parameters variable, but here we cannot do this
+            return
+
+        if not elen:
+            raise TypeError(f"{cls} is not a generic class")
+        if elen is _marker:
+            if not hasattr(cls, "__parameters__") or not cls.__parameters__:
+                raise TypeError(f"{cls} is not a generic class")
+            elen = len(cls.__parameters__)
+        alen = len(parameters)
+        if alen != elen:
+            expect_val = elen
+            if hasattr(cls, "__parameters__"):
+                parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
+                num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters)
+                if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples):
+                    return
+
+                # deal with TypeVarLike defaults
+                # required TypeVarLikes cannot appear after a defaulted one.
+                if alen < elen:
+                    # since we validate TypeVarLike default in _collect_type_vars
+                    # or _collect_parameters we can safely check parameters[alen]
+                    if (
+                        getattr(parameters[alen], '__default__', NoDefault)
+                        is not NoDefault
+                    ):
+                        return
+
+                    num_default_tv = sum(getattr(p, '__default__', NoDefault)
+                                         is not NoDefault for p in parameters)
+
+                    elen -= num_default_tv
+
+                    expect_val = f"at least {elen}"
+
+            things = "arguments" if sys.version_info >= (3, 10) else "parameters"
+            raise TypeError(f"Too {'many' if alen > elen else 'few'} {things}"
+                            f" for {cls}; actual {alen}, expected {expect_val}")
+else:
+    # Python 3.11+
+
+    def _check_generic(cls, parameters, elen):
+        """Check correct count for parameters of a generic cls (internal helper).
+
+        This gives a nice error message in case of count mismatch.
+        """
+        if not elen:
+            raise TypeError(f"{cls} is not a generic class")
+        alen = len(parameters)
+        if alen != elen:
+            expect_val = elen
+            if hasattr(cls, "__parameters__"):
+                parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
+
+                # deal with TypeVarLike defaults
+                # required TypeVarLikes cannot appear after a defaulted one.
+                if alen < elen:
+                    # since we validate TypeVarLike default in _collect_type_vars
+                    # or _collect_parameters we can safely check parameters[alen]
+                    if (
+                        getattr(parameters[alen], '__default__', NoDefault)
+                        is not NoDefault
+                    ):
+                        return
+
+                    num_default_tv = sum(getattr(p, '__default__', NoDefault)
+                                         is not NoDefault for p in parameters)
+
+                    elen -= num_default_tv
+
+                    expect_val = f"at least {elen}"
+
+            raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments"
+                            f" for {cls}; actual {alen}, expected {expect_val}")
+
+if not _PEP_696_IMPLEMENTED:
+    typing._check_generic = _check_generic
+
+
+def _has_generic_or_protocol_as_origin() -> bool:
+    try:
+        frame = sys._getframe(2)
+    # - Catch AttributeError: not all Python implementations have sys._getframe()
+    # - Catch ValueError: maybe we're called from an unexpected module
+    #   and the call stack isn't deep enough
+    except (AttributeError, ValueError):
+        return False  # err on the side of leniency
+    else:
+        # If we somehow get invoked from outside typing.py,
+        # also err on the side of leniency
+        if frame.f_globals.get("__name__") != "typing":
+            return False
+        origin = frame.f_locals.get("origin")
+        # Cannot use "in" because origin may be an object with a buggy __eq__ that
+        # throws an error.
+        return origin is typing.Generic or origin is Protocol or origin is typing.Protocol
+
+
+_TYPEVARTUPLE_TYPES = {TypeVarTuple, getattr(typing, "TypeVarTuple", None)}
+
+
+def _is_unpacked_typevartuple(x) -> bool:
+    if get_origin(x) is not Unpack:
+        return False
+    args = get_args(x)
+    return (
+        bool(args)
+        and len(args) == 1
+        and type(args[0]) in _TYPEVARTUPLE_TYPES
+    )
+
+
+# Python 3.11+ _collect_type_vars was renamed to _collect_parameters
+if hasattr(typing, '_collect_type_vars'):
+    def _collect_type_vars(types, typevar_types=None):
+        """Collect all type variable contained in types in order of
+        first appearance (lexicographic order). For example::
+
+            _collect_type_vars((T, List[S, T])) == (T, S)
+        """
+        if typevar_types is None:
+            typevar_types = typing.TypeVar
+        tvars = []
+
+        # A required TypeVarLike cannot appear after a TypeVarLike with a default
+        # if it was a direct call to `Generic[]` or `Protocol[]`
+        enforce_default_ordering = _has_generic_or_protocol_as_origin()
+        default_encountered = False
+
+        # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple
+        type_var_tuple_encountered = False
+
+        for t in types:
+            if _is_unpacked_typevartuple(t):
+                type_var_tuple_encountered = True
+            elif (
+                isinstance(t, typevar_types) and not isinstance(t, _UnpackAlias)
+                and t not in tvars
+            ):
+                if enforce_default_ordering:
+                    has_default = getattr(t, '__default__', NoDefault) is not NoDefault
+                    if has_default:
+                        if type_var_tuple_encountered:
+                            raise TypeError('Type parameter with a default'
+                                            ' follows TypeVarTuple')
+                        default_encountered = True
+                    elif default_encountered:
+                        raise TypeError(f'Type parameter {t!r} without a default'
+                                        ' follows type parameter with a default')
+
+                tvars.append(t)
+            if _should_collect_from_parameters(t):
+                tvars.extend([t for t in t.__parameters__ if t not in tvars])
+            elif isinstance(t, tuple):
+                # Collect nested type_vars
+                # tuple wrapped by  _prepare_paramspec_params(cls, params)
+                for x in t:
+                    for collected in _collect_type_vars([x]):
+                        if collected not in tvars:
+                            tvars.append(collected)
+        return tuple(tvars)
+
+    typing._collect_type_vars = _collect_type_vars
+else:
+    def _collect_parameters(args):
+        """Collect all type variables and parameter specifications in args
+        in order of first appearance (lexicographic order).
+
+        For example::
+
+            assert _collect_parameters((T, Callable[P, T])) == (T, P)
+        """
+        parameters = []
+
+        # A required TypeVarLike cannot appear after a TypeVarLike with default
+        # if it was a direct call to `Generic[]` or `Protocol[]`
+        enforce_default_ordering = _has_generic_or_protocol_as_origin()
+        default_encountered = False
+
+        # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple
+        type_var_tuple_encountered = False
+
+        for t in args:
+            if isinstance(t, type):
+                # We don't want __parameters__ descriptor of a bare Python class.
+                pass
+            elif isinstance(t, tuple):
+                # `t` might be a tuple, when `ParamSpec` is substituted with
+                # `[T, int]`, or `[int, *Ts]`, etc.
+                for x in t:
+                    for collected in _collect_parameters([x]):
+                        if collected not in parameters:
+                            parameters.append(collected)
+            elif hasattr(t, '__typing_subst__'):
+                if t not in parameters:
+                    if enforce_default_ordering:
+                        has_default = (
+                            getattr(t, '__default__', NoDefault) is not NoDefault
+                        )
+
+                        if type_var_tuple_encountered and has_default:
+                            raise TypeError('Type parameter with a default'
+                                            ' follows TypeVarTuple')
+
+                        if has_default:
+                            default_encountered = True
+                        elif default_encountered:
+                            raise TypeError(f'Type parameter {t!r} without a default'
+                                            ' follows type parameter with a default')
+
+                    parameters.append(t)
+            else:
+                if _is_unpacked_typevartuple(t):
+                    type_var_tuple_encountered = True
+                for x in getattr(t, '__parameters__', ()):
+                    if x not in parameters:
+                        parameters.append(x)
+
+        return tuple(parameters)
+
+    if not _PEP_696_IMPLEMENTED:
+        typing._collect_parameters = _collect_parameters
+
+# Backport typing.NamedTuple as it exists in Python 3.13.
+# In 3.11, the ability to define generic `NamedTuple`s was supported.
+# This was explicitly disallowed in 3.9-3.10, and only half-worked in <=3.8.
+# On 3.12, we added __orig_bases__ to call-based NamedTuples
+# On 3.13, we deprecated kwargs-based NamedTuples
+if sys.version_info >= (3, 13):
+    NamedTuple = typing.NamedTuple
+else:
+    def _make_nmtuple(name, types, module, defaults=()):
+        fields = [n for n, t in types]
+        annotations = {n: typing._type_check(t, f"field {n} annotation must be a type")
+                       for n, t in types}
+        nm_tpl = collections.namedtuple(name, fields,
+                                        defaults=defaults, module=module)
+        nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations
+        return nm_tpl
+
+    _prohibited_namedtuple_fields = typing._prohibited
+    _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})
+
+    class _NamedTupleMeta(type):
+        def __new__(cls, typename, bases, ns):
+            assert _NamedTuple in bases
+            for base in bases:
+                if base is not _NamedTuple and base is not typing.Generic:
+                    raise TypeError(
+                        'can only inherit from a NamedTuple type and Generic')
+            bases = tuple(tuple if base is _NamedTuple else base for base in bases)
+            if "__annotations__" in ns:
+                types = ns["__annotations__"]
+            elif "__annotate__" in ns:
+                # TODO: Use inspect.VALUE here, and make the annotations lazily evaluated
+                types = ns["__annotate__"](1)
+            else:
+                types = {}
+            default_names = []
+            for field_name in types:
+                if field_name in ns:
+                    default_names.append(field_name)
+                elif default_names:
+                    raise TypeError(f"Non-default namedtuple field {field_name} "
+                                    f"cannot follow default field"
+                                    f"{'s' if len(default_names) > 1 else ''} "
+                                    f"{', '.join(default_names)}")
+            nm_tpl = _make_nmtuple(
+                typename, types.items(),
+                defaults=[ns[n] for n in default_names],
+                module=ns['__module__']
+            )
+            nm_tpl.__bases__ = bases
+            if typing.Generic in bases:
+                if hasattr(typing, '_generic_class_getitem'):  # 3.12+
+                    nm_tpl.__class_getitem__ = classmethod(typing._generic_class_getitem)
+                else:
+                    class_getitem = typing.Generic.__class_getitem__.__func__
+                    nm_tpl.__class_getitem__ = classmethod(class_getitem)
+            # update from user namespace without overriding special namedtuple attributes
+            for key, val in ns.items():
+                if key in _prohibited_namedtuple_fields:
+                    raise AttributeError("Cannot overwrite NamedTuple attribute " + key)
+                elif key not in _special_namedtuple_fields:
+                    if key not in nm_tpl._fields:
+                        setattr(nm_tpl, key, ns[key])
+                    try:
+                        set_name = type(val).__set_name__
+                    except AttributeError:
+                        pass
+                    else:
+                        try:
+                            set_name(val, nm_tpl, key)
+                        except BaseException as e:
+                            msg = (
+                                f"Error calling __set_name__ on {type(val).__name__!r} "
+                                f"instance {key!r} in {typename!r}"
+                            )
+                            # BaseException.add_note() existed on py311,
+                            # but the __set_name__ machinery didn't start
+                            # using add_note() until py312.
+                            # Making sure exceptions are raised in the same way
+                            # as in "normal" classes seems most important here.
+                            if sys.version_info >= (3, 12):
+                                e.add_note(msg)
+                                raise
+                            else:
+                                raise RuntimeError(msg) from e
+
+            if typing.Generic in bases:
+                nm_tpl.__init_subclass__()
+            return nm_tpl
+
+    _NamedTuple = type.__new__(_NamedTupleMeta, 'NamedTuple', (), {})
+
+    def _namedtuple_mro_entries(bases):
+        assert NamedTuple in bases
+        return (_NamedTuple,)
+
+    def NamedTuple(typename, fields=_marker, /, **kwargs):
+        """Typed version of namedtuple.
+
+        Usage::
+
+            class Employee(NamedTuple):
+                name: str
+                id: int
+
+        This is equivalent to::
+
+            Employee = collections.namedtuple('Employee', ['name', 'id'])
+
+        The resulting class has an extra __annotations__ attribute, giving a
+        dict that maps field names to types.  (The field names are also in
+        the _fields attribute, which is part of the namedtuple API.)
+        An alternative equivalent functional syntax is also accepted::
+
+            Employee = NamedTuple('Employee', [('name', str), ('id', int)])
+        """
+        if fields is _marker:
+            if kwargs:
+                deprecated_thing = "Creating NamedTuple classes using keyword arguments"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "Use the class-based or functional syntax instead."
+                )
+            else:
+                deprecated_thing = "Failing to pass a value for the 'fields' parameter"
+                example = f"`{typename} = NamedTuple({typename!r}, [])`"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "To create a NamedTuple class with 0 fields "
+                    "using the functional syntax, "
+                    "pass an empty list, e.g. "
+                ) + example + "."
+        elif fields is None:
+            if kwargs:
+                raise TypeError(
+                    "Cannot pass `None` as the 'fields' parameter "
+                    "and also specify fields using keyword arguments"
+                )
+            else:
+                deprecated_thing = "Passing `None` as the 'fields' parameter"
+                example = f"`{typename} = NamedTuple({typename!r}, [])`"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "To create a NamedTuple class with 0 fields "
+                    "using the functional syntax, "
+                    "pass an empty list, e.g. "
+                ) + example + "."
+        elif kwargs:
+            raise TypeError("Either list of fields or keywords"
+                            " can be provided to NamedTuple, not both")
+        if fields is _marker or fields is None:
+            warnings.warn(
+                deprecation_msg.format(name=deprecated_thing, remove="3.15"),
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            fields = kwargs.items()
+        nt = _make_nmtuple(typename, fields, module=_caller())
+        nt.__orig_bases__ = (NamedTuple,)
+        return nt
+
+    NamedTuple.__mro_entries__ = _namedtuple_mro_entries
+
+
+if hasattr(collections.abc, "Buffer"):
+    Buffer = collections.abc.Buffer
+else:
+    class Buffer(abc.ABC):  # noqa: B024
+        """Base class for classes that implement the buffer protocol.
+
+        The buffer protocol allows Python objects to expose a low-level
+        memory buffer interface. Before Python 3.12, it is not possible
+        to implement the buffer protocol in pure Python code, or even
+        to check whether a class implements the buffer protocol. In
+        Python 3.12 and higher, the ``__buffer__`` method allows access
+        to the buffer protocol from Python code, and the
+        ``collections.abc.Buffer`` ABC allows checking whether a class
+        implements the buffer protocol.
+
+        To indicate support for the buffer protocol in earlier versions,
+        inherit from this ABC, either in a stub file or at runtime,
+        or use ABC registration. This ABC provides no methods, because
+        there is no Python-accessible methods shared by pre-3.12 buffer
+        classes. It is useful primarily for static checks.
+
+        """
+
+    # As a courtesy, register the most common stdlib buffer classes.
+    Buffer.register(memoryview)
+    Buffer.register(bytearray)
+    Buffer.register(bytes)
+
+
+# Backport of types.get_original_bases, available on 3.12+ in CPython
+if hasattr(_types, "get_original_bases"):
+    get_original_bases = _types.get_original_bases
+else:
+    def get_original_bases(cls, /):
+        """Return the class's "original" bases prior to modification by `__mro_entries__`.
+
+        Examples::
+
+            from typing import TypeVar, Generic
+            from typing_extensions import NamedTuple, TypedDict
+
+            T = TypeVar("T")
+            class Foo(Generic[T]): ...
+            class Bar(Foo[int], float): ...
+            class Baz(list[str]): ...
+            Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
+            Spam = TypedDict("Spam", {"a": int, "b": str})
+
+            assert get_original_bases(Bar) == (Foo[int], float)
+            assert get_original_bases(Baz) == (list[str],)
+            assert get_original_bases(Eggs) == (NamedTuple,)
+            assert get_original_bases(Spam) == (TypedDict,)
+            assert get_original_bases(int) == (object,)
+        """
+        try:
+            return cls.__dict__.get("__orig_bases__", cls.__bases__)
+        except AttributeError:
+            raise TypeError(
+                f'Expected an instance of type, not {type(cls).__name__!r}'
+            ) from None
+
+
+# NewType is a class on Python 3.10+, making it pickleable
+# The error message for subclassing instances of NewType was improved on 3.11+
+if sys.version_info >= (3, 11):
+    NewType = typing.NewType
+else:
+    class NewType:
+        """NewType creates simple unique types with almost zero
+        runtime overhead. NewType(name, tp) is considered a subtype of tp
+        by static type checkers. At runtime, NewType(name, tp) returns
+        a dummy callable that simply returns its argument. Usage::
+            UserId = NewType('UserId', int)
+            def name_by_id(user_id: UserId) -> str:
+                ...
+            UserId('user')          # Fails type check
+            name_by_id(42)          # Fails type check
+            name_by_id(UserId(42))  # OK
+            num = UserId(5) + 1     # type: int
+        """
+
+        def __call__(self, obj, /):
+            return obj
+
+        def __init__(self, name, tp):
+            self.__qualname__ = name
+            if '.' in name:
+                name = name.rpartition('.')[-1]
+            self.__name__ = name
+            self.__supertype__ = tp
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+        def __mro_entries__(self, bases):
+            # We defined __mro_entries__ to get a better error message
+            # if a user attempts to subclass a NewType instance. bpo-46170
+            supercls_name = self.__name__
+
+            class Dummy:
+                def __init_subclass__(cls):
+                    subcls_name = cls.__name__
+                    raise TypeError(
+                        f"Cannot subclass an instance of NewType. "
+                        f"Perhaps you were looking for: "
+                        f"`{subcls_name} = NewType({subcls_name!r}, {supercls_name})`"
+                    )
+
+            return (Dummy,)
+
+        def __repr__(self):
+            return f'{self.__module__}.{self.__qualname__}'
+
+        def __reduce__(self):
+            return self.__qualname__
+
+        if sys.version_info >= (3, 10):
+            # PEP 604 methods
+            # It doesn't make sense to have these methods on Python <3.10
+
+            def __or__(self, other):
+                return typing.Union[self, other]
+
+            def __ror__(self, other):
+                return typing.Union[other, self]
+
+
+if sys.version_info >= (3, 14):
+    TypeAliasType = typing.TypeAliasType
+# <=3.13
+else:
+    if sys.version_info >= (3, 12):
+        # 3.12-3.13
+        def _is_unionable(obj):
+            """Corresponds to is_unionable() in unionobject.c in CPython."""
+            return obj is None or isinstance(obj, (
+                type,
+                _types.GenericAlias,
+                _types.UnionType,
+                typing.TypeAliasType,
+                TypeAliasType,
+            ))
+    else:
+        # <=3.11
+        def _is_unionable(obj):
+            """Corresponds to is_unionable() in unionobject.c in CPython."""
+            return obj is None or isinstance(obj, (
+                type,
+                _types.GenericAlias,
+                _types.UnionType,
+                TypeAliasType,
+            ))
+
+    if sys.version_info < (3, 10):
+        # Copied and pasted from https://github.com/python/cpython/blob/986a4e1b6fcae7fe7a1d0a26aea446107dd58dd2/Objects/genericaliasobject.c#L568-L582,
+        # so that we emulate the behaviour of `types.GenericAlias`
+        # on the latest versions of CPython
+        _ATTRIBUTE_DELEGATION_EXCLUSIONS = frozenset({
+            "__class__",
+            "__bases__",
+            "__origin__",
+            "__args__",
+            "__unpacked__",
+            "__parameters__",
+            "__typing_unpacked_tuple_args__",
+            "__mro_entries__",
+            "__reduce_ex__",
+            "__reduce__",
+            "__copy__",
+            "__deepcopy__",
+        })
+
+        class _TypeAliasGenericAlias(typing._GenericAlias, _root=True):
+            def __getattr__(self, attr):
+                if attr in _ATTRIBUTE_DELEGATION_EXCLUSIONS:
+                    return object.__getattr__(self, attr)
+                return getattr(self.__origin__, attr)
+
+
+    class TypeAliasType:
+        """Create named, parameterized type aliases.
+
+        This provides a backport of the new `type` statement in Python 3.12:
+
+            type ListOrSet[T] = list[T] | set[T]
+
+        is equivalent to:
+
+            T = TypeVar("T")
+            ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
+
+        The name ListOrSet can then be used as an alias for the type it refers to.
+
+        The type_params argument should contain all the type parameters used
+        in the value of the type alias. If the alias is not generic, this
+        argument is omitted.
+
+        Static type checkers should only support type aliases declared using
+        TypeAliasType that follow these rules:
+
+        - The first argument (the name) must be a string literal.
+        - The TypeAliasType instance must be immediately assigned to a variable
+          of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid,
+          as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)').
+
+        """
+
+        def __init__(self, name: str, value, *, type_params=()):
+            if not isinstance(name, str):
+                raise TypeError("TypeAliasType name must be a string")
+            if not isinstance(type_params, tuple):
+                raise TypeError("type_params must be a tuple")
+            self.__value__ = value
+            self.__type_params__ = type_params
+
+            default_value_encountered = False
+            parameters = []
+            for type_param in type_params:
+                if (
+                    not isinstance(type_param, (TypeVar, TypeVarTuple, ParamSpec))
+                    # <=3.11
+                    # Unpack Backport passes isinstance(type_param, TypeVar)
+                    or _is_unpack(type_param)
+                ):
+                    raise TypeError(f"Expected a type param, got {type_param!r}")
+                has_default = (
+                    getattr(type_param, '__default__', NoDefault) is not NoDefault
+                )
+                if default_value_encountered and not has_default:
+                    raise TypeError(f"non-default type parameter '{type_param!r}'"
+                                    " follows default type parameter")
+                if has_default:
+                    default_value_encountered = True
+                if isinstance(type_param, TypeVarTuple):
+                    parameters.extend(type_param)
+                else:
+                    parameters.append(type_param)
+            self.__parameters__ = tuple(parameters)
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+            # Setting this attribute closes the TypeAliasType from further modification
+            self.__name__ = name
+
+        def __setattr__(self, name: str, value: object, /) -> None:
+            if hasattr(self, "__name__"):
+                self._raise_attribute_error(name)
+            super().__setattr__(name, value)
+
+        def __delattr__(self, name: str, /) -> Never:
+            self._raise_attribute_error(name)
+
+        def _raise_attribute_error(self, name: str) -> Never:
+            # Match the Python 3.12 error messages exactly
+            if name == "__name__":
+                raise AttributeError("readonly attribute")
+            elif name in {"__value__", "__type_params__", "__parameters__", "__module__"}:
+                raise AttributeError(
+                    f"attribute '{name}' of 'typing.TypeAliasType' objects "
+                    "is not writable"
+                )
+            else:
+                raise AttributeError(
+                    f"'typing.TypeAliasType' object has no attribute '{name}'"
+                )
+
+        def __repr__(self) -> str:
+            return self.__name__
+
+        if sys.version_info < (3, 11):
+            def _check_single_param(self, param, recursion=0):
+                # Allow [], [int], [int, str], [int, ...], [int, T]
+                if param is ...:
+                    return ...
+                if param is None:
+                    return None
+                # Note in <= 3.9 _ConcatenateGenericAlias inherits from list
+                if isinstance(param, list) and recursion == 0:
+                    return [self._check_single_param(arg, recursion+1)
+                            for arg in param]
+                return typing._type_check(
+                        param, f'Subscripting {self.__name__} requires a type.'
+                    )
+
+        def _check_parameters(self, parameters):
+            if sys.version_info < (3, 11):
+                return tuple(
+                    self._check_single_param(item)
+                    for item in parameters
+                )
+            return tuple(typing._type_check(
+                        item, f'Subscripting {self.__name__} requires a type.'
+                    )
+                    for item in parameters
+            )
+
+        def __getitem__(self, parameters):
+            if not self.__type_params__:
+                raise TypeError("Only generic type aliases are subscriptable")
+            if not isinstance(parameters, tuple):
+                parameters = (parameters,)
+            # Using 3.9 here will create problems with Concatenate
+            if sys.version_info >= (3, 10):
+                return _types.GenericAlias(self, parameters)
+            type_vars = _collect_type_vars(parameters)
+            parameters = self._check_parameters(parameters)
+            alias = _TypeAliasGenericAlias(self, parameters)
+            # alias.__parameters__ is not complete if Concatenate is present
+            # as it is converted to a list from which no parameters are extracted.
+            if alias.__parameters__ != type_vars:
+                alias.__parameters__ = type_vars
+            return alias
+
+        def __reduce__(self):
+            return self.__name__
+
+        def __init_subclass__(cls, *args, **kwargs):
+            raise TypeError(
+                "type 'typing_extensions.TypeAliasType' is not an acceptable base type"
+            )
+
+        # The presence of this method convinces typing._type_check
+        # that TypeAliasTypes are types.
+        def __call__(self):
+            raise TypeError("Type alias is not callable")
+
+        if sys.version_info >= (3, 10):
+            def __or__(self, right):
+                # For forward compatibility with 3.12, reject Unions
+                # that are not accepted by the built-in Union.
+                if not _is_unionable(right):
+                    return NotImplemented
+                return typing.Union[self, right]
+
+            def __ror__(self, left):
+                if not _is_unionable(left):
+                    return NotImplemented
+                return typing.Union[left, self]
+
+
+if hasattr(typing, "is_protocol"):
+    is_protocol = typing.is_protocol
+    get_protocol_members = typing.get_protocol_members
+else:
+    def is_protocol(tp: type, /) -> bool:
+        """Return True if the given type is a Protocol.
+
+        Example::
+
+            >>> from typing_extensions import Protocol, is_protocol
+            >>> class P(Protocol):
+            ...     def a(self) -> str: ...
+            ...     b: int
+            >>> is_protocol(P)
+            True
+            >>> is_protocol(int)
+            False
+        """
+        return (
+            isinstance(tp, type)
+            and getattr(tp, '_is_protocol', False)
+            and tp is not Protocol
+            and tp is not typing.Protocol
+        )
+
+    def get_protocol_members(tp: type, /) -> typing.FrozenSet[str]:
+        """Return the set of members defined in a Protocol.
+
+        Example::
+
+            >>> from typing_extensions import Protocol, get_protocol_members
+            >>> class P(Protocol):
+            ...     def a(self) -> str: ...
+            ...     b: int
+            >>> get_protocol_members(P)
+            frozenset({'a', 'b'})
+
+        Raise a TypeError for arguments that are not Protocols.
+        """
+        if not is_protocol(tp):
+            raise TypeError(f'{tp!r} is not a Protocol')
+        if hasattr(tp, '__protocol_attrs__'):
+            return frozenset(tp.__protocol_attrs__)
+        return frozenset(_get_protocol_attrs(tp))
+
+
+if hasattr(typing, "Doc"):
+    Doc = typing.Doc
+else:
+    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::
+
+            >>> from typing_extensions import Annotated, Doc
+            >>> def hi(to: Annotated[str, Doc("Who to say hi to")]) -> None: ...
+        """
+        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
+
+
+_CapsuleType = getattr(_types, "CapsuleType", None)
+
+if _CapsuleType is None:
+    try:
+        import _socket
+    except ImportError:
+        pass
+    else:
+        _CAPI = getattr(_socket, "CAPI", None)
+        if _CAPI is not None:
+            _CapsuleType = type(_CAPI)
+
+if _CapsuleType is not None:
+    CapsuleType = _CapsuleType
+    __all__.append("CapsuleType")
+
+
+if sys.version_info >= (3,14):
+    from annotationlib import Format, get_annotations
+else:
+    class Format(enum.IntEnum):
+        VALUE = 1
+        VALUE_WITH_FAKE_GLOBALS = 2
+        FORWARDREF = 3
+        STRING = 4
+
+    def get_annotations(obj, *, globals=None, locals=None, eval_str=False,
+                        format=Format.VALUE):
+        """Compute the annotations dict for an object.
+
+        obj may be a callable, class, or module.
+        Passing in an object of any other type raises TypeError.
+
+        Returns a dict.  get_annotations() returns a new dict every time
+        it's called; calling it twice on the same object will return two
+        different but equivalent dicts.
+
+        This is a backport of `inspect.get_annotations`, which has been
+        in the standard library since Python 3.10. See the standard library
+        documentation for more:
+
+            https://docs.python.org/3/library/inspect.html#inspect.get_annotations
+
+        This backport adds the *format* argument introduced by PEP 649. The
+        three formats supported are:
+        * VALUE: the annotations are returned as-is. This is the default and
+          it is compatible with the behavior on previous Python versions.
+        * FORWARDREF: return annotations as-is if possible, but replace any
+          undefined names with ForwardRef objects. The implementation proposed by
+          PEP 649 relies on language changes that cannot be backported; the
+          typing-extensions implementation simply returns the same result as VALUE.
+        * STRING: return annotations as strings, in a format close to the original
+          source. Again, this behavior cannot be replicated directly in a backport.
+          As an approximation, typing-extensions retrieves the annotations under
+          VALUE semantics and then stringifies them.
+
+        The purpose of this backport is to allow users who would like to use
+        FORWARDREF or STRING semantics once PEP 649 is implemented, but who also
+        want to support earlier Python versions, to simply write:
+
+            typing_extensions.get_annotations(obj, format=Format.FORWARDREF)
+
+        """
+        format = Format(format)
+        if format is Format.VALUE_WITH_FAKE_GLOBALS:
+            raise ValueError(
+                "The VALUE_WITH_FAKE_GLOBALS format is for internal use only"
+            )
+
+        if eval_str and format is not Format.VALUE:
+            raise ValueError("eval_str=True is only supported with format=Format.VALUE")
+
+        if isinstance(obj, type):
+            # class
+            obj_dict = getattr(obj, '__dict__', None)
+            if obj_dict and hasattr(obj_dict, 'get'):
+                ann = obj_dict.get('__annotations__', None)
+                if isinstance(ann, _types.GetSetDescriptorType):
+                    ann = None
+            else:
+                ann = None
+
+            obj_globals = None
+            module_name = getattr(obj, '__module__', None)
+            if module_name:
+                module = sys.modules.get(module_name, None)
+                if module:
+                    obj_globals = getattr(module, '__dict__', None)
+            obj_locals = dict(vars(obj))
+            unwrap = obj
+        elif isinstance(obj, _types.ModuleType):
+            # module
+            ann = getattr(obj, '__annotations__', None)
+            obj_globals = obj.__dict__
+            obj_locals = None
+            unwrap = None
+        elif callable(obj):
+            # this includes types.Function, types.BuiltinFunctionType,
+            # types.BuiltinMethodType, functools.partial, functools.singledispatch,
+            # "class funclike" from Lib/test/test_inspect... on and on it goes.
+            ann = getattr(obj, '__annotations__', None)
+            obj_globals = getattr(obj, '__globals__', None)
+            obj_locals = None
+            unwrap = obj
+        elif hasattr(obj, '__annotations__'):
+            ann = obj.__annotations__
+            obj_globals = obj_locals = unwrap = None
+        else:
+            raise TypeError(f"{obj!r} is not a module, class, or callable.")
+
+        if ann is None:
+            return {}
+
+        if not isinstance(ann, dict):
+            raise ValueError(f"{obj!r}.__annotations__ is neither a dict nor None")
+
+        if not ann:
+            return {}
+
+        if not eval_str:
+            if format is Format.STRING:
+                return {
+                    key: value if isinstance(value, str) else typing._type_repr(value)
+                    for key, value in ann.items()
+                }
+            return dict(ann)
+
+        if unwrap is not None:
+            while True:
+                if hasattr(unwrap, '__wrapped__'):
+                    unwrap = unwrap.__wrapped__
+                    continue
+                if isinstance(unwrap, functools.partial):
+                    unwrap = unwrap.func
+                    continue
+                break
+            if hasattr(unwrap, "__globals__"):
+                obj_globals = unwrap.__globals__
+
+        if globals is None:
+            globals = obj_globals
+        if locals is None:
+            locals = obj_locals or {}
+
+        # "Inject" type parameters into the local namespace
+        # (unless they are shadowed by assignments *in* the local namespace),
+        # as a way of emulating annotation scopes when calling `eval()`
+        if type_params := getattr(obj, "__type_params__", ()):
+            locals = {param.__name__: param for param in type_params} | locals
+
+        return_value = {key:
+            value if not isinstance(value, str) else eval(value, globals, locals)
+            for key, value in ann.items() }
+        return return_value
+
+
+if hasattr(typing, "evaluate_forward_ref"):
+    evaluate_forward_ref = typing.evaluate_forward_ref
+else:
+    # Implements annotationlib.ForwardRef.evaluate
+    def _eval_with_owner(
+        forward_ref, *, owner=None, globals=None, locals=None, type_params=None
+    ):
+        if forward_ref.__forward_evaluated__:
+            return forward_ref.__forward_value__
+        if getattr(forward_ref, "__cell__", None) is not None:
+            try:
+                value = forward_ref.__cell__.cell_contents
+            except ValueError:
+                pass
+            else:
+                forward_ref.__forward_evaluated__ = True
+                forward_ref.__forward_value__ = value
+                return value
+        if owner is None:
+            owner = getattr(forward_ref, "__owner__", None)
+
+        if (
+            globals is None
+            and getattr(forward_ref, "__forward_module__", None) is not None
+        ):
+            globals = getattr(
+                sys.modules.get(forward_ref.__forward_module__, None), "__dict__", None
+            )
+        if globals is None:
+            globals = getattr(forward_ref, "__globals__", None)
+        if globals is None:
+            if isinstance(owner, type):
+                module_name = getattr(owner, "__module__", None)
+                if module_name:
+                    module = sys.modules.get(module_name, None)
+                    if module:
+                        globals = getattr(module, "__dict__", None)
+            elif isinstance(owner, _types.ModuleType):
+                globals = getattr(owner, "__dict__", None)
+            elif callable(owner):
+                globals = getattr(owner, "__globals__", None)
+
+        # If we pass None to eval() below, the globals of this module are used.
+        if globals is None:
+            globals = {}
+
+        if locals is None:
+            locals = {}
+            if isinstance(owner, type):
+                locals.update(vars(owner))
+
+        if type_params is None and owner is not None:
+            # "Inject" type parameters into the local namespace
+            # (unless they are shadowed by assignments *in* the local namespace),
+            # as a way of emulating annotation scopes when calling `eval()`
+            type_params = getattr(owner, "__type_params__", None)
+
+        # type parameters require some special handling,
+        # as they exist in their own scope
+        # but `eval()` does not have a dedicated parameter for that scope.
+        # For classes, names in type parameter scopes should override
+        # names in the global scope (which here are called `localns`!),
+        # but should in turn be overridden by names in the class scope
+        # (which here are called `globalns`!)
+        if type_params is not None:
+            globals = dict(globals)
+            locals = dict(locals)
+            for param in type_params:
+                param_name = param.__name__
+                if (
+                    _FORWARD_REF_HAS_CLASS and not forward_ref.__forward_is_class__
+                ) or param_name not in globals:
+                    globals[param_name] = param
+                    locals.pop(param_name, None)
+
+        arg = forward_ref.__forward_arg__
+        if arg.isidentifier() and not keyword.iskeyword(arg):
+            if arg in locals:
+                value = locals[arg]
+            elif arg in globals:
+                value = globals[arg]
+            elif hasattr(builtins, arg):
+                return getattr(builtins, arg)
+            else:
+                raise NameError(arg)
+        else:
+            code = forward_ref.__forward_code__
+            value = eval(code, globals, locals)
+        forward_ref.__forward_evaluated__ = True
+        forward_ref.__forward_value__ = value
+        return value
+
+    def evaluate_forward_ref(
+        forward_ref,
+        *,
+        owner=None,
+        globals=None,
+        locals=None,
+        type_params=None,
+        format=None,
+        _recursive_guard=frozenset(),
+    ):
+        """Evaluate a forward reference as a type hint.
+
+        This is similar to calling the ForwardRef.evaluate() method,
+        but unlike that method, evaluate_forward_ref() also:
+
+        * Recursively evaluates forward references nested within the type hint.
+        * Rejects certain objects that are not valid type hints.
+        * Replaces type hints that evaluate to None with types.NoneType.
+        * Supports the *FORWARDREF* and *STRING* formats.
+
+        *forward_ref* must be an instance of ForwardRef. *owner*, if given,
+        should be the object that holds the annotations that the forward reference
+        derived from, such as a module, class object, or function. It is used to
+        infer the namespaces to use for looking up names. *globals* and *locals*
+        can also be explicitly given to provide the global and local namespaces.
+        *type_params* is a tuple of type parameters that are in scope when
+        evaluating the forward reference. This parameter must be provided (though
+        it may be an empty tuple) if *owner* is not given and the forward reference
+        does not already have an owner set. *format* specifies the format of the
+        annotation and is a member of the annotationlib.Format enum.
+
+        """
+        if format == Format.STRING:
+            return forward_ref.__forward_arg__
+        if forward_ref.__forward_arg__ in _recursive_guard:
+            return forward_ref
+
+        # Evaluate the forward reference
+        try:
+            value = _eval_with_owner(
+                forward_ref,
+                owner=owner,
+                globals=globals,
+                locals=locals,
+                type_params=type_params,
+            )
+        except NameError:
+            if format == Format.FORWARDREF:
+                return forward_ref
+            else:
+                raise
+
+        if isinstance(value, str):
+            value = ForwardRef(value)
+
+        # Recursively evaluate the type
+        if isinstance(value, ForwardRef):
+            if getattr(value, "__forward_module__", True) is not None:
+                globals = None
+            return evaluate_forward_ref(
+                value,
+                globals=globals,
+                locals=locals,
+                 type_params=type_params, owner=owner,
+                _recursive_guard=_recursive_guard, format=format
+            )
+        if sys.version_info < (3, 12, 5) and type_params:
+            # Make use of type_params
+            locals = dict(locals) if locals else {}
+            for tvar in type_params:
+                if tvar.__name__ not in locals:  # lets not overwrite something present
+                    locals[tvar.__name__] = tvar
+        if sys.version_info < (3, 12, 5):
+            return typing._eval_type(
+                value,
+                globals,
+                locals,
+                recursive_guard=_recursive_guard | {forward_ref.__forward_arg__},
+            )
+        else:
+            return typing._eval_type(
+                value,
+                globals,
+                locals,
+                type_params,
+                recursive_guard=_recursive_guard | {forward_ref.__forward_arg__},
+            )
+
+
+class Sentinel:
+    """Create a unique sentinel object.
+
+    *name* should be the name of the variable to which the return value shall be assigned.
+
+    *repr*, if supplied, will be used for the repr of the sentinel object.
+    If not provided, "" will be used.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        repr: typing.Optional[str] = None,
+    ):
+        self._name = name
+        self._repr = repr if repr is not None else f'<{name}>'
+
+    def __repr__(self):
+        return self._repr
+
+    if sys.version_info < (3, 11):
+        # The presence of this method convinces typing._type_check
+        # that Sentinels are types.
+        def __call__(self, *args, **kwargs):
+            raise TypeError(f"{type(self).__name__!r} object is not callable")
+
+    if sys.version_info >= (3, 10):
+        def __or__(self, other):
+            return typing.Union[self, other]
+
+        def __ror__(self, other):
+            return typing.Union[other, self]
+
+    def __getstate__(self):
+        raise TypeError(f"Cannot pickle {type(self).__name__!r} object")
+
+
+# Aliases for items that are in typing in all supported versions.
+# We use hasattr() checks so this library will continue to import on
+# future versions of Python that may remove these names.
+_typing_names = [
+    "AbstractSet",
+    "AnyStr",
+    "BinaryIO",
+    "Callable",
+    "Collection",
+    "Container",
+    "Dict",
+    "FrozenSet",
+    "Hashable",
+    "IO",
+    "ItemsView",
+    "Iterable",
+    "Iterator",
+    "KeysView",
+    "List",
+    "Mapping",
+    "MappingView",
+    "Match",
+    "MutableMapping",
+    "MutableSequence",
+    "MutableSet",
+    "Optional",
+    "Pattern",
+    "Reversible",
+    "Sequence",
+    "Set",
+    "Sized",
+    "TextIO",
+    "Tuple",
+    "Union",
+    "ValuesView",
+    "cast",
+    "no_type_check",
+    "no_type_check_decorator",
+    # This is private, but it was defined by typing_extensions for a long time
+    # and some users rely on it.
+    "_AnnotatedAlias",
+]
+globals().update(
+    {name: getattr(typing, name) for name in _typing_names if hasattr(typing, name)}
+)
+# These are defined unconditionally because they are used in
+# typing-extensions itself.
+Generic = typing.Generic
+ForwardRef = typing.ForwardRef
+Annotated = typing.Annotated
diff --git a/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/INSTALLER b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..5c69047b2eb8235994febeeae1da4a82365a240a
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+uv
\ No newline at end of file
diff --git a/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/METADATA b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..15116c784ed1f8f0f524513d606a26bf6765e923
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/METADATA
@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: urllib3
+Version: 2.5.0
+Summary: HTTP library with thread-safe connection pooling, file post, and more.
+Project-URL: Changelog, https://github.com/urllib3/urllib3/blob/main/CHANGES.rst
+Project-URL: Documentation, https://urllib3.readthedocs.io
+Project-URL: Code, https://github.com/urllib3/urllib3
+Project-URL: Issue tracker, https://github.com/urllib3/urllib3/issues
+Author-email: Andrey Petrov 
+Maintainer-email: Seth Michael Larson , Quentin Pradet , Illia Volochii 
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: filepost,http,httplib,https,pooling,ssl,threadsafe,urllib
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Provides-Extra: brotli
+Requires-Dist: brotli>=1.0.9; (platform_python_implementation == 'CPython') and extra == 'brotli'
+Requires-Dist: brotlicffi>=0.8.0; (platform_python_implementation != 'CPython') and extra == 'brotli'
+Provides-Extra: h2
+Requires-Dist: h2<5,>=4; extra == 'h2'
+Provides-Extra: socks
+Requires-Dist: pysocks!=1.5.7,<2.0,>=1.5.6; extra == 'socks'
+Provides-Extra: zstd
+Requires-Dist: zstandard>=0.18.0; extra == 'zstd'
+Description-Content-Type: text/markdown
+
+

+
+![urllib3](https://github.com/urllib3/urllib3/raw/main/docs/_static/banner_github.svg)
+
+

+
+

+  PyPI Version
+  Python Versions
+  Join our Discord
+  Coverage Status
+  Build Status on GitHub
+  Documentation Status

+  OpenSSF Scorecard
+  SLSA 3
+  CII Best Practices
+

+
+urllib3 is a powerful, *user-friendly* HTTP client for Python. Much of the
+Python ecosystem already uses urllib3 and you should too.
+urllib3 brings many critical features that are missing from the Python
+standard libraries:
+
+- Thread safety.
+- Connection pooling.
+- Client-side SSL/TLS verification.
+- File uploads with multipart encoding.
+- Helpers for retrying requests and dealing with HTTP redirects.
+- Support for gzip, deflate, brotli, and zstd encoding.
+- Proxy support for HTTP and SOCKS.
+- 100% test coverage.
+
+urllib3 is powerful and easy to use:
+
+```python3
+>>> import urllib3
+>>> resp = urllib3.request("GET", "http://httpbin.org/robots.txt")
+>>> resp.status
+200
+>>> resp.data
+b"User-agent: *\nDisallow: /deny\n"
+```
+
+## Installing
+
+urllib3 can be installed with [pip](https://pip.pypa.io):
+
+```bash
+$ python -m pip install urllib3
+```
+
+Alternatively, you can grab the latest source code from [GitHub](https://github.com/urllib3/urllib3):
+
+```bash
+$ git clone https://github.com/urllib3/urllib3.git
+$ cd urllib3
+$ pip install .
+```
+
+
+## Documentation
+
+urllib3 has usage and reference documentation at [urllib3.readthedocs.io](https://urllib3.readthedocs.io).
+
+
+## Community
+
+urllib3 has a [community Discord channel](https://discord.gg/urllib3) for asking questions and
+collaborating with other contributors. Drop by and say hello 👋
+
+
+## Contributing
+
+urllib3 happily accepts contributions. Please see our
+[contributing documentation](https://urllib3.readthedocs.io/en/latest/contributing.html)
+for some tips on getting started.
+
+
+## Security Disclosures
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure with maintainers.
+
+
+## Maintainers
+
+- [@sethmlarson](https://github.com/sethmlarson) (Seth M. Larson)
+- [@pquentin](https://github.com/pquentin) (Quentin Pradet)
+- [@illia-v](https://github.com/illia-v) (Illia Volochii)
+- [@theacodes](https://github.com/theacodes) (Thea Flowers)
+- [@haikuginger](https://github.com/haikuginger) (Jess Shapiro)
+- [@lukasa](https://github.com/lukasa) (Cory Benfield)
+- [@sigmavirus24](https://github.com/sigmavirus24) (Ian Stapleton Cordasco)
+- [@shazow](https://github.com/shazow) (Andrey Petrov)
+
+👋
+
+
+## Sponsorship
+
+If your company benefits from this library, please consider [sponsoring its
+development](https://urllib3.readthedocs.io/en/latest/sponsors.html).
+
+
+## For Enterprise
+
+Professional support for urllib3 is available as part of the [Tidelift
+Subscription][1].  Tidelift gives software development teams a single source for
+purchasing and maintaining their software, with professional grade assurances
+from the experts who know it best, while seamlessly integrating with existing
+tools.
+
+[1]: https://tidelift.com/subscription/pkg/pypi-urllib3?utm_source=pypi-urllib3&utm_medium=referral&utm_campaign=readme
diff --git a/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/RECORD b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..69197e5c04c7e1336cf995b73ce0b33ce22e2ff8
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/RECORD
@@ -0,0 +1,44 @@
+urllib3-2.5.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+urllib3-2.5.0.dist-info/METADATA,sha256=maYkTIZt0a-lkEC-hMZWbCBmcGZyJcYOeRk4_nuTrNc,6461
+urllib3-2.5.0.dist-info/RECORD,,
+urllib3-2.5.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3-2.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+urllib3-2.5.0.dist-info/licenses/LICENSE.txt,sha256=Ew46ZNX91dCWp1JpRjSn2d8oRGnehuVzIQAmgEHj1oY,1093
+urllib3/__init__.py,sha256=JMo1tg1nIV1AeJ2vENC_Txfl0e5h6Gzl9DGVk1rWRbo,6979
+urllib3/_base_connection.py,sha256=T1cwH3RhzsrBh6Bz3AOGVDboRsE7veijqZPXXQTR2Rg,5568
+urllib3/_collections.py,sha256=tM7c6J1iKtWZYV_QGYb8-r7Nr1524Dehnsa0Ufh6_mU,17295
+urllib3/_request_methods.py,sha256=gCeF85SO_UU4WoPwYHIoz_tw-eM_EVOkLFp8OFsC7DA,9931
+urllib3/_version.py,sha256=ZlSUkBo_Pd90B6pM0GDO7l2vitQD3QCK3xPR_K0zFJA,511
+urllib3/connection.py,sha256=iP4pgSJtpusXyYlejzNn-gih_wWCxMU-qy6OU1kaapc,42613
+urllib3/connectionpool.py,sha256=ZEhudsa8BIubD2M0XoxBBsjxbsXwMgUScH7oQ9i-j1Y,43371
+urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urllib3/contrib/emscripten/__init__.py,sha256=u6KNgzjlFZbuAAXa_ybCR7gQ71VJESnF-IIdDA73brw,733
+urllib3/contrib/emscripten/connection.py,sha256=j8DR_flE7hsoFhNfiqHLiaPaCsVbzG44jgahwvsQ52A,8771
+urllib3/contrib/emscripten/emscripten_fetch_worker.js,sha256=CDfYF_9CDobtx2lGidyJ1zjDEvwNT5F-dchmVWXDh0E,3655
+urllib3/contrib/emscripten/fetch.py,sha256=kco06lWoQ-fdFfN51-nzeTywPVBEHg89WIst33H3xcg,23484
+urllib3/contrib/emscripten/request.py,sha256=mL28szy1KvE3NJhWor5jNmarp8gwplDU-7gwGZY5g0Q,566
+urllib3/contrib/emscripten/response.py,sha256=7oVPENYZHuzEGRtG40HonpH5tAIYHsGcHPbJt2Z0U-Y,9507
+urllib3/contrib/pyopenssl.py,sha256=Xp5Ym05VgXGhHa0C4wlutvHxY8SnKSS6WLb2t5Miu0s,19720
+urllib3/contrib/socks.py,sha256=-iardc61GypsJzD6W6yuRS7KVCyfowcQrl_719H7lIM,7549
+urllib3/exceptions.py,sha256=pziumHf0Vwx3z4gvUy7ou8nlM2yIYX0N3l3znEdeF5U,9938
+urllib3/fields.py,sha256=FCf7UULSkf10cuTRUWTQESzxgl1WT8e2aCy3kfyZins,10829
+urllib3/filepost.py,sha256=U8eNZ-mpKKHhrlbHEEiTxxgK16IejhEa7uz42yqA_dI,2388
+urllib3/http2/__init__.py,sha256=xzrASH7R5ANRkPJOot5lGnATOq3KKuyXzI42rcnwmqs,1741
+urllib3/http2/connection.py,sha256=4DB0DkZEC3yIkhGjUDIHB17wrYCLaL0Ag5bDW2_mGPI,12694
+urllib3/http2/probe.py,sha256=nnAkqbhAakOiF75rz7W0udZ38Eeh_uD8fjV74N73FEI,3014
+urllib3/poolmanager.py,sha256=oKsgP1EsAI4OVgK9-9D3AYXZS5HYV8yKUSog-QbJ8Ts,23866
+urllib3/py.typed,sha256=UaCuPFa3H8UAakbt-5G8SPacldTOGvJv18pPjUJ5gDY,93
+urllib3/response.py,sha256=TVTSu6Q1U0U7hoHYMIRxxuh4zroeMo8b5EI4DOA13Eo,46480
+urllib3/util/__init__.py,sha256=-qeS0QceivazvBEKDNFCAI-6ACcdDOE4TMvo7SLNlAQ,1001
+urllib3/util/connection.py,sha256=JjO722lzHlzLXPTkr9ZWBdhseXnMVjMSb1DJLVrXSnQ,4444
+urllib3/util/proxy.py,sha256=seP8-Q5B6bB0dMtwPj-YcZZQ30vHuLqRu-tI0JZ2fzs,1148
+urllib3/util/request.py,sha256=XuAsEBT58DAZYUTwpMH5Hr3A1OPoMNvNIYIunbIqbc8,8411
+urllib3/util/response.py,sha256=vQE639uoEhj1vpjEdxu5lNIhJCSUZkd7pqllUI0BZOA,3374
+urllib3/util/retry.py,sha256=bj-2YUqblxLlv8THg5fxww-DM54XCbjgZXIQ71XioCY,18459
+urllib3/util/ssl_.py,sha256=jxnQ3msYkVaokJVWqHNnAVdVtDdidrTHDeyk50gwqaQ,19786
+urllib3/util/ssl_match_hostname.py,sha256=Di7DU7zokoltapT_F0Sj21ffYxwaS_cE5apOtwueeyA,5845
+urllib3/util/ssltransport.py,sha256=Ez4O8pR_vT8dan_FvqBYS6dgDfBXEMfVfrzcdUoWfi4,8847
+urllib3/util/timeout.py,sha256=4eT1FVeZZU7h7mYD1Jq2OXNe4fxekdNvhoWUkZusRpA,10346
+urllib3/util/url.py,sha256=WRh-TMYXosmgp8m8lT4H5spoHw5yUjlcMCfU53AkoAs,15205
+urllib3/util/util.py,sha256=j3lbZK1jPyiwD34T8IgJzdWEZVT-4E-0vYIJi9UjeNA,1146
+urllib3/util/wait.py,sha256=_ph8IrUR3sqPqi0OopQgJUlH4wzkGeM5CiyA7XGGtmI,4423
diff --git a/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/REQUESTED b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/WHEEL b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..12228d414b6cfed7c39d3781c85c63256a1d7fb5
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3-2.5.0.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.13/site-packages/urllib3/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a25f5d6d0731332adf3d814d26a53ddf52a13d23
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/__init__.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_base_connection.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_base_connection.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4eddf530dd7cb4d76e3e5ca1b5c8e51870c11fbf
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_base_connection.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_collections.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_collections.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d98c9afcbeed22baf8e2ed0a1da8c5ded3a34f35
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_collections.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_request_methods.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_request_methods.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a812eb9c089136a4ca9c2d79b8a4954e23175100
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_request_methods.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_version.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_version.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68494bbba0ef1370912eb1b4433e11e5ffe304f1
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/_version.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connection.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connection.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ba06ae928c83d91458cc1d910c3d43ca4ac8ef1
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connection.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connectionpool.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connectionpool.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e999f79df77ee0e2dacf667e4c358dd1348e8d5
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/connectionpool.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/exceptions.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/exceptions.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc21ffc7fff4ef483fcc2884f7750a90f64ea0f8
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/exceptions.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/fields.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/fields.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a44135b86948c4c4a47c996ba94712514c990b2
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/fields.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/filepost.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/filepost.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..878f1ef5a30900058ba8aadbf4cea57829bdd29c
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/filepost.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/poolmanager.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/poolmanager.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..617e74ab4470e781cef1ef10c571ab0bb6836d8d
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/poolmanager.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/__pycache__/response.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/response.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aae19afe9110b53010f53ef8c6881b035b061914
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/__pycache__/response.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/__init__.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcd7fd46de94ba8c2271af6513ac2b6590f0f51c
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/__init__.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/socks.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/socks.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47005953bf08551550ab3f0bf0549ef80ac89810
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/contrib/__pycache__/socks.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/__init__.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a3c5bebdc151eef715663628a697118bb2932ed
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/__init__.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import urllib3.connection
+
+from ...connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from .connection import EmscriptenHTTPConnection, EmscriptenHTTPSConnection
+
+
+def inject_into_urllib3() -> None:
+    # override connection classes to use emscripten specific classes
+    # n.b. mypy complains about the overriding of classes below
+    # if it isn't ignored
+    HTTPConnectionPool.ConnectionCls = EmscriptenHTTPConnection
+    HTTPSConnectionPool.ConnectionCls = EmscriptenHTTPSConnection
+    urllib3.connection.HTTPConnection = EmscriptenHTTPConnection  # type: ignore[misc,assignment]
+    urllib3.connection.HTTPSConnection = EmscriptenHTTPSConnection  # type: ignore[misc,assignment]
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/connection.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..41bfd2797ffeef54fa50f708026c4cc44b7d2c12
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/connection.py
@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import os
+import typing
+
+# use http.client.HTTPException for consistency with non-emscripten
+from http.client import HTTPException as HTTPException  # noqa: F401
+from http.client import ResponseNotReady
+
+from ..._base_connection import _TYPE_BODY
+from ...connection import HTTPConnection, ProxyConfig, port_by_scheme
+from ...exceptions import TimeoutError
+from ...response import BaseHTTPResponse
+from ...util.connection import _TYPE_SOCKET_OPTIONS
+from ...util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
+from ...util.url import Url
+from .fetch import _RequestError, _TimeoutError, send_request, send_streaming_request
+from .request import EmscriptenRequest
+from .response import EmscriptenHttpResponseWrapper, EmscriptenResponse
+
+if typing.TYPE_CHECKING:
+    from ..._base_connection import BaseHTTPConnection, BaseHTTPSConnection
+
+
+class EmscriptenHTTPConnection:
+    default_port: typing.ClassVar[int] = port_by_scheme["http"]
+    default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS]
+
+    timeout: None | (float)
+
+    host: str
+    port: int
+    blocksize: int
+    source_address: tuple[str, int] | None
+    socket_options: _TYPE_SOCKET_OPTIONS | None
+
+    proxy: Url | None
+    proxy_config: ProxyConfig | None
+
+    is_verified: bool = False
+    proxy_is_verified: bool | None = None
+
+    _response: EmscriptenResponse | None
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 0,
+        *,
+        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 8192,
+        socket_options: _TYPE_SOCKET_OPTIONS | None = None,
+        proxy: Url | None = None,
+        proxy_config: ProxyConfig | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.timeout = timeout if isinstance(timeout, float) else 0.0
+        self.scheme = "http"
+        self._closed = True
+        self._response = None
+        # ignore these things because we don't
+        # have control over that stuff
+        self.proxy = None
+        self.proxy_config = None
+        self.blocksize = blocksize
+        self.source_address = None
+        self.socket_options = None
+        self.is_verified = False
+
+    def set_tunnel(
+        self,
+        host: str,
+        port: int | None = 0,
+        headers: typing.Mapping[str, str] | None = None,
+        scheme: str = "http",
+    ) -> None:
+        pass
+
+    def connect(self) -> None:
+        pass
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        body: _TYPE_BODY | None = None,
+        headers: typing.Mapping[str, str] | None = None,
+        # We know *at least* botocore is depending on the order of the
+        # first 3 parameters so to be safe we only mark the later ones
+        # as keyword-only to ensure we have space to extend.
+        *,
+        chunked: bool = False,
+        preload_content: bool = True,
+        decode_content: bool = True,
+        enforce_content_length: bool = True,
+    ) -> None:
+        self._closed = False
+        if url.startswith("/"):
+            # no scheme / host / port included, make a full url
+            url = f"{self.scheme}://{self.host}:{self.port}" + url
+        request = EmscriptenRequest(
+            url=url,
+            method=method,
+            timeout=self.timeout if self.timeout else 0,
+            decode_content=decode_content,
+        )
+        request.set_body(body)
+        if headers:
+            for k, v in headers.items():
+                request.set_header(k, v)
+        self._response = None
+        try:
+            if not preload_content:
+                self._response = send_streaming_request(request)
+            if self._response is None:
+                self._response = send_request(request)
+        except _TimeoutError as e:
+            raise TimeoutError(e.message) from e
+        except _RequestError as e:
+            raise HTTPException(e.message) from e
+
+    def getresponse(self) -> BaseHTTPResponse:
+        if self._response is not None:
+            return EmscriptenHttpResponseWrapper(
+                internal_response=self._response,
+                url=self._response.request.url,
+                connection=self,
+            )
+        else:
+            raise ResponseNotReady()
+
+    def close(self) -> None:
+        self._closed = True
+        self._response = None
+
+    @property
+    def is_closed(self) -> bool:
+        """Whether the connection either is brand new or has been previously closed.
+        If this property is True then both ``is_connected`` and ``has_connected_to_proxy``
+        properties must be False.
+        """
+        return self._closed
+
+    @property
+    def is_connected(self) -> bool:
+        """Whether the connection is actively connected to any origin (proxy or target)"""
+        return True
+
+    @property
+    def has_connected_to_proxy(self) -> bool:
+        """Whether the connection has successfully connected to its proxy.
+        This returns False if no proxy is in use. Used to determine whether
+        errors are coming from the proxy layer or from tunnelling to the target origin.
+        """
+        return False
+
+
+class EmscriptenHTTPSConnection(EmscriptenHTTPConnection):
+    default_port = port_by_scheme["https"]
+    # all this is basically ignored, as browser handles https
+    cert_reqs: int | str | None = None
+    ca_certs: str | None = None
+    ca_cert_dir: str | None = None
+    ca_cert_data: None | str | bytes = None
+    cert_file: str | None
+    key_file: str | None
+    key_password: str | None
+    ssl_context: typing.Any | None
+    ssl_version: int | str | None = None
+    ssl_minimum_version: int | None = None
+    ssl_maximum_version: int | None = None
+    assert_hostname: None | str | typing.Literal[False]
+    assert_fingerprint: str | None = None
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 0,
+        *,
+        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+        source_address: tuple[str, int] | None = None,
+        blocksize: int = 16384,
+        socket_options: (
+            None | _TYPE_SOCKET_OPTIONS
+        ) = HTTPConnection.default_socket_options,
+        proxy: Url | None = None,
+        proxy_config: ProxyConfig | None = None,
+        cert_reqs: int | str | None = None,
+        assert_hostname: None | str | typing.Literal[False] = None,
+        assert_fingerprint: str | None = None,
+        server_hostname: str | None = None,
+        ssl_context: typing.Any | None = None,
+        ca_certs: str | None = None,
+        ca_cert_dir: str | None = None,
+        ca_cert_data: None | str | bytes = None,
+        ssl_minimum_version: int | None = None,
+        ssl_maximum_version: int | None = None,
+        ssl_version: int | str | None = None,  # Deprecated
+        cert_file: str | None = None,
+        key_file: str | None = None,
+        key_password: str | None = None,
+    ) -> None:
+        super().__init__(
+            host,
+            port=port,
+            timeout=timeout,
+            source_address=source_address,
+            blocksize=blocksize,
+            socket_options=socket_options,
+            proxy=proxy,
+            proxy_config=proxy_config,
+        )
+        self.scheme = "https"
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.key_password = key_password
+        self.ssl_context = ssl_context
+        self.server_hostname = server_hostname
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+        self.ssl_version = ssl_version
+        self.ssl_minimum_version = ssl_minimum_version
+        self.ssl_maximum_version = ssl_maximum_version
+        self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
+        self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
+        self.ca_cert_data = ca_cert_data
+
+        self.cert_reqs = None
+
+        # The browser will automatically verify all requests.
+        # We have no control over that setting.
+        self.is_verified = True
+
+    def set_cert(
+        self,
+        key_file: str | None = None,
+        cert_file: str | None = None,
+        cert_reqs: int | str | None = None,
+        key_password: str | None = None,
+        ca_certs: str | None = None,
+        assert_hostname: None | str | typing.Literal[False] = None,
+        assert_fingerprint: str | None = None,
+        ca_cert_dir: str | None = None,
+        ca_cert_data: None | str | bytes = None,
+    ) -> None:
+        pass
+
+
+# verify that this class implements BaseHTTP(s) connection correctly
+if typing.TYPE_CHECKING:
+    _supports_http_protocol: BaseHTTPConnection = EmscriptenHTTPConnection("", 0)
+    _supports_https_protocol: BaseHTTPSConnection = EmscriptenHTTPSConnection("", 0)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/emscripten_fetch_worker.js b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/emscripten_fetch_worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..243b86222f90a9be4b6b4ce0bf997eefd29289af
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/emscripten_fetch_worker.js
@@ -0,0 +1,110 @@
+let Status = {
+  SUCCESS_HEADER: -1,
+  SUCCESS_EOF: -2,
+  ERROR_TIMEOUT: -3,
+  ERROR_EXCEPTION: -4,
+};
+
+let connections = {};
+let nextConnectionID = 1;
+const encoder = new TextEncoder();
+
+self.addEventListener("message", async function (event) {
+  if (event.data.close) {
+    let connectionID = event.data.close;
+    delete connections[connectionID];
+    return;
+  } else if (event.data.getMore) {
+    let connectionID = event.data.getMore;
+    let { curOffset, value, reader, intBuffer, byteBuffer } =
+      connections[connectionID];
+    // if we still have some in buffer, then just send it back straight away
+    if (!value || curOffset >= value.length) {
+      // read another buffer if required
+      try {
+        let readResponse = await reader.read();
+
+        if (readResponse.done) {
+          // read everything - clear connection and return
+          delete connections[connectionID];
+          Atomics.store(intBuffer, 0, Status.SUCCESS_EOF);
+          Atomics.notify(intBuffer, 0);
+          // finished reading successfully
+          // return from event handler
+          return;
+        }
+        curOffset = 0;
+        connections[connectionID].value = readResponse.value;
+        value = readResponse.value;
+      } catch (error) {
+        console.log("Request exception:", error);
+        let errorBytes = encoder.encode(error.message);
+        let written = errorBytes.length;
+        byteBuffer.set(errorBytes);
+        intBuffer[1] = written;
+        Atomics.store(intBuffer, 0, Status.ERROR_EXCEPTION);
+        Atomics.notify(intBuffer, 0);
+      }
+    }
+
+    // send as much buffer as we can
+    let curLen = value.length - curOffset;
+    if (curLen > byteBuffer.length) {
+      curLen = byteBuffer.length;
+    }
+    byteBuffer.set(value.subarray(curOffset, curOffset + curLen), 0);
+
+    Atomics.store(intBuffer, 0, curLen); // store current length in bytes
+    Atomics.notify(intBuffer, 0);
+    curOffset += curLen;
+    connections[connectionID].curOffset = curOffset;
+
+    return;
+  } else {
+    // start fetch
+    let connectionID = nextConnectionID;
+    nextConnectionID += 1;
+    const intBuffer = new Int32Array(event.data.buffer);
+    const byteBuffer = new Uint8Array(event.data.buffer, 8);
+    try {
+      const response = await fetch(event.data.url, event.data.fetchParams);
+      // return the headers first via textencoder
+      var headers = [];
+      for (const pair of response.headers.entries()) {
+        headers.push([pair[0], pair[1]]);
+      }
+      let headerObj = {
+        headers: headers,
+        status: response.status,
+        connectionID,
+      };
+      const headerText = JSON.stringify(headerObj);
+      let headerBytes = encoder.encode(headerText);
+      let written = headerBytes.length;
+      byteBuffer.set(headerBytes);
+      intBuffer[1] = written;
+      // make a connection
+      connections[connectionID] = {
+        reader: response.body.getReader(),
+        intBuffer: intBuffer,
+        byteBuffer: byteBuffer,
+        value: undefined,
+        curOffset: 0,
+      };
+      // set header ready
+      Atomics.store(intBuffer, 0, Status.SUCCESS_HEADER);
+      Atomics.notify(intBuffer, 0);
+      // all fetching after this goes through a new postmessage call with getMore
+      // this allows for parallel requests
+    } catch (error) {
+      console.log("Request exception:", error);
+      let errorBytes = encoder.encode(error.message);
+      let written = errorBytes.length;
+      byteBuffer.set(errorBytes);
+      intBuffer[1] = written;
+      Atomics.store(intBuffer, 0, Status.ERROR_EXCEPTION);
+      Atomics.notify(intBuffer, 0);
+    }
+  }
+});
+self.postMessage({ inited: true });
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/fetch.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/fetch.py
new file mode 100644
index 0000000000000000000000000000000000000000..66958217a9fdc8a03eb991d6da2558d7e7910150
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/fetch.py
@@ -0,0 +1,728 @@
+"""
+Support for streaming http requests in emscripten.
+
+A few caveats -
+
+If your browser (or Node.js) has WebAssembly JavaScript Promise Integration enabled
+https://github.com/WebAssembly/js-promise-integration/blob/main/proposals/js-promise-integration/Overview.md
+*and* you launch pyodide using `pyodide.runPythonAsync`, this will fetch data using the
+JavaScript asynchronous fetch api (wrapped via `pyodide.ffi.call_sync`). In this case
+timeouts and streaming should just work.
+
+Otherwise, it uses a combination of XMLHttpRequest and a web-worker for streaming.
+
+This approach has several caveats:
+
+Firstly, you can't do streaming http in the main UI thread, because atomics.wait isn't allowed.
+Streaming only works if you're running pyodide in a web worker.
+
+Secondly, this uses an extra web worker and SharedArrayBuffer to do the asynchronous fetch
+operation, so it requires that you have crossOriginIsolation enabled, by serving over https
+(or from localhost) with the two headers below set:
+
+    Cross-Origin-Opener-Policy: same-origin
+    Cross-Origin-Embedder-Policy: require-corp
+
+You can tell if cross origin isolation is successfully enabled by looking at the global crossOriginIsolated variable in
+JavaScript console. If it isn't, streaming requests will fallback to XMLHttpRequest, i.e. getting the whole
+request into a buffer and then returning it. it shows a warning in the JavaScript console in this case.
+
+Finally, the webworker which does the streaming fetch is created on initial import, but will only be started once
+control is returned to javascript. Call `await wait_for_streaming_ready()` to wait for streaming fetch.
+
+NB: in this code, there are a lot of JavaScript objects. They are named js_*
+to make it clear what type of object they are.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+from email.parser import Parser
+from importlib.resources import files
+from typing import TYPE_CHECKING, Any
+
+import js  # type: ignore[import-not-found]
+from pyodide.ffi import (  # type: ignore[import-not-found]
+    JsArray,
+    JsException,
+    JsProxy,
+    to_js,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Buffer
+
+from .request import EmscriptenRequest
+from .response import EmscriptenResponse
+
+"""
+There are some headers that trigger unintended CORS preflight requests.
+See also https://github.com/koenvo/pyodide-http/issues/22
+"""
+HEADERS_TO_IGNORE = ("user-agent",)
+
+SUCCESS_HEADER = -1
+SUCCESS_EOF = -2
+ERROR_TIMEOUT = -3
+ERROR_EXCEPTION = -4
+
+_STREAMING_WORKER_CODE = (
+    files(__package__)
+    .joinpath("emscripten_fetch_worker.js")
+    .read_text(encoding="utf-8")
+)
+
+
+class _RequestError(Exception):
+    def __init__(
+        self,
+        message: str | None = None,
+        *,
+        request: EmscriptenRequest | None = None,
+        response: EmscriptenResponse | None = None,
+    ):
+        self.request = request
+        self.response = response
+        self.message = message
+        super().__init__(self.message)
+
+
+class _StreamingError(_RequestError):
+    pass
+
+
+class _TimeoutError(_RequestError):
+    pass
+
+
+def _obj_from_dict(dict_val: dict[str, Any]) -> JsProxy:
+    return to_js(dict_val, dict_converter=js.Object.fromEntries)
+
+
+class _ReadStream(io.RawIOBase):
+    def __init__(
+        self,
+        int_buffer: JsArray,
+        byte_buffer: JsArray,
+        timeout: float,
+        worker: JsProxy,
+        connection_id: int,
+        request: EmscriptenRequest,
+    ):
+        self.int_buffer = int_buffer
+        self.byte_buffer = byte_buffer
+        self.read_pos = 0
+        self.read_len = 0
+        self.connection_id = connection_id
+        self.worker = worker
+        self.timeout = int(1000 * timeout) if timeout > 0 else None
+        self.is_live = True
+        self._is_closed = False
+        self.request: EmscriptenRequest | None = request
+
+    def __del__(self) -> None:
+        self.close()
+
+    # this is compatible with _base_connection
+    def is_closed(self) -> bool:
+        return self._is_closed
+
+    # for compatibility with RawIOBase
+    @property
+    def closed(self) -> bool:
+        return self.is_closed()
+
+    def close(self) -> None:
+        if self.is_closed():
+            return
+        self.read_len = 0
+        self.read_pos = 0
+        self.int_buffer = None
+        self.byte_buffer = None
+        self._is_closed = True
+        self.request = None
+        if self.is_live:
+            self.worker.postMessage(_obj_from_dict({"close": self.connection_id}))
+            self.is_live = False
+        super().close()
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return False
+
+    def readinto(self, byte_obj: Buffer) -> int:
+        if not self.int_buffer:
+            raise _StreamingError(
+                "No buffer for stream in _ReadStream.readinto",
+                request=self.request,
+                response=None,
+            )
+        if self.read_len == 0:
+            # wait for the worker to send something
+            js.Atomics.store(self.int_buffer, 0, ERROR_TIMEOUT)
+            self.worker.postMessage(_obj_from_dict({"getMore": self.connection_id}))
+            if (
+                js.Atomics.wait(self.int_buffer, 0, ERROR_TIMEOUT, self.timeout)
+                == "timed-out"
+            ):
+                raise _TimeoutError
+            data_len = self.int_buffer[0]
+            if data_len > 0:
+                self.read_len = data_len
+                self.read_pos = 0
+            elif data_len == ERROR_EXCEPTION:
+                string_len = self.int_buffer[1]
+                # decode the error string
+                js_decoder = js.TextDecoder.new()
+                json_str = js_decoder.decode(self.byte_buffer.slice(0, string_len))
+                raise _StreamingError(
+                    f"Exception thrown in fetch: {json_str}",
+                    request=self.request,
+                    response=None,
+                )
+            else:
+                # EOF, free the buffers and return zero
+                # and free the request
+                self.is_live = False
+                self.close()
+                return 0
+        # copy from int32array to python bytes
+        ret_length = min(self.read_len, len(memoryview(byte_obj)))
+        subarray = self.byte_buffer.subarray(
+            self.read_pos, self.read_pos + ret_length
+        ).to_py()
+        memoryview(byte_obj)[0:ret_length] = subarray
+        self.read_len -= ret_length
+        self.read_pos += ret_length
+        return ret_length
+
+
+class _StreamingFetcher:
+    def __init__(self) -> None:
+        # make web-worker and data buffer on startup
+        self.streaming_ready = False
+
+        js_data_blob = js.Blob.new(
+            to_js([_STREAMING_WORKER_CODE], create_pyproxies=False),
+            _obj_from_dict({"type": "application/javascript"}),
+        )
+
+        def promise_resolver(js_resolve_fn: JsProxy, js_reject_fn: JsProxy) -> None:
+            def onMsg(e: JsProxy) -> None:
+                self.streaming_ready = True
+                js_resolve_fn(e)
+
+            def onErr(e: JsProxy) -> None:
+                js_reject_fn(e)  # Defensive: never happens in ci
+
+            self.js_worker.onmessage = onMsg
+            self.js_worker.onerror = onErr
+
+        js_data_url = js.URL.createObjectURL(js_data_blob)
+        self.js_worker = js.globalThis.Worker.new(js_data_url)
+        self.js_worker_ready_promise = js.globalThis.Promise.new(promise_resolver)
+
+    def send(self, request: EmscriptenRequest) -> EmscriptenResponse:
+        headers = {
+            k: v for k, v in request.headers.items() if k not in HEADERS_TO_IGNORE
+        }
+
+        body = request.body
+        fetch_data = {"headers": headers, "body": to_js(body), "method": request.method}
+        # start the request off in the worker
+        timeout = int(1000 * request.timeout) if request.timeout > 0 else None
+        js_shared_buffer = js.SharedArrayBuffer.new(1048576)
+        js_int_buffer = js.Int32Array.new(js_shared_buffer)
+        js_byte_buffer = js.Uint8Array.new(js_shared_buffer, 8)
+
+        js.Atomics.store(js_int_buffer, 0, ERROR_TIMEOUT)
+        js.Atomics.notify(js_int_buffer, 0)
+        js_absolute_url = js.URL.new(request.url, js.location).href
+        self.js_worker.postMessage(
+            _obj_from_dict(
+                {
+                    "buffer": js_shared_buffer,
+                    "url": js_absolute_url,
+                    "fetchParams": fetch_data,
+                }
+            )
+        )
+        # wait for the worker to send something
+        js.Atomics.wait(js_int_buffer, 0, ERROR_TIMEOUT, timeout)
+        if js_int_buffer[0] == ERROR_TIMEOUT:
+            raise _TimeoutError(
+                "Timeout connecting to streaming request",
+                request=request,
+                response=None,
+            )
+        elif js_int_buffer[0] == SUCCESS_HEADER:
+            # got response
+            # header length is in second int of intBuffer
+            string_len = js_int_buffer[1]
+            # decode the rest to a JSON string
+            js_decoder = js.TextDecoder.new()
+            # this does a copy (the slice) because decode can't work on shared array
+            # for some silly reason
+            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
+            # get it as an object
+            response_obj = json.loads(json_str)
+            return EmscriptenResponse(
+                request=request,
+                status_code=response_obj["status"],
+                headers=response_obj["headers"],
+                body=_ReadStream(
+                    js_int_buffer,
+                    js_byte_buffer,
+                    request.timeout,
+                    self.js_worker,
+                    response_obj["connectionID"],
+                    request,
+                ),
+            )
+        elif js_int_buffer[0] == ERROR_EXCEPTION:
+            string_len = js_int_buffer[1]
+            # decode the error string
+            js_decoder = js.TextDecoder.new()
+            json_str = js_decoder.decode(js_byte_buffer.slice(0, string_len))
+            raise _StreamingError(
+                f"Exception thrown in fetch: {json_str}", request=request, response=None
+            )
+        else:
+            raise _StreamingError(
+                f"Unknown status from worker in fetch: {js_int_buffer[0]}",
+                request=request,
+                response=None,
+            )
+
+
+class _JSPIReadStream(io.RawIOBase):
+    """
+    A read stream that uses pyodide.ffi.run_sync to read from a JavaScript fetch
+    response. This requires support for WebAssembly JavaScript Promise Integration
+    in the containing browser, and for pyodide to be launched via runPythonAsync.
+
+    :param js_read_stream:
+        The JavaScript stream reader
+
+    :param timeout:
+        Timeout in seconds
+
+    :param request:
+        The request we're handling
+
+    :param response:
+        The response this stream relates to
+
+    :param js_abort_controller:
+        A JavaScript AbortController object, used for timeouts
+    """
+
+    def __init__(
+        self,
+        js_read_stream: Any,
+        timeout: float,
+        request: EmscriptenRequest,
+        response: EmscriptenResponse,
+        js_abort_controller: Any,  # JavaScript AbortController for timeouts
+    ):
+        self.js_read_stream = js_read_stream
+        self.timeout = timeout
+        self._is_closed = False
+        self._is_done = False
+        self.request: EmscriptenRequest | None = request
+        self.response: EmscriptenResponse | None = response
+        self.current_buffer = None
+        self.current_buffer_pos = 0
+        self.js_abort_controller = js_abort_controller
+
+    def __del__(self) -> None:
+        self.close()
+
+    # this is compatible with _base_connection
+    def is_closed(self) -> bool:
+        return self._is_closed
+
+    # for compatibility with RawIOBase
+    @property
+    def closed(self) -> bool:
+        return self.is_closed()
+
+    def close(self) -> None:
+        if self.is_closed():
+            return
+        self.read_len = 0
+        self.read_pos = 0
+        self.js_read_stream.cancel()
+        self.js_read_stream = None
+        self._is_closed = True
+        self._is_done = True
+        self.request = None
+        self.response = None
+        super().close()
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return False
+
+    def seekable(self) -> bool:
+        return False
+
+    def _get_next_buffer(self) -> bool:
+        result_js = _run_sync_with_timeout(
+            self.js_read_stream.read(),
+            self.timeout,
+            self.js_abort_controller,
+            request=self.request,
+            response=self.response,
+        )
+        if result_js.done:
+            self._is_done = True
+            return False
+        else:
+            self.current_buffer = result_js.value.to_py()
+            self.current_buffer_pos = 0
+            return True
+
+    def readinto(self, byte_obj: Buffer) -> int:
+        if self.current_buffer is None:
+            if not self._get_next_buffer() or self.current_buffer is None:
+                self.close()
+                return 0
+        ret_length = min(
+            len(byte_obj), len(self.current_buffer) - self.current_buffer_pos
+        )
+        byte_obj[0:ret_length] = self.current_buffer[
+            self.current_buffer_pos : self.current_buffer_pos + ret_length
+        ]
+        self.current_buffer_pos += ret_length
+        if self.current_buffer_pos == len(self.current_buffer):
+            self.current_buffer = None
+        return ret_length
+
+
+# check if we are in a worker or not
+def is_in_browser_main_thread() -> bool:
+    return hasattr(js, "window") and hasattr(js, "self") and js.self == js.window
+
+
+def is_cross_origin_isolated() -> bool:
+    return hasattr(js, "crossOriginIsolated") and js.crossOriginIsolated
+
+
+def is_in_node() -> bool:
+    return (
+        hasattr(js, "process")
+        and hasattr(js.process, "release")
+        and hasattr(js.process.release, "name")
+        and js.process.release.name == "node"
+    )
+
+
+def is_worker_available() -> bool:
+    return hasattr(js, "Worker") and hasattr(js, "Blob")
+
+
+_fetcher: _StreamingFetcher | None = None
+
+if is_worker_available() and (
+    (is_cross_origin_isolated() and not is_in_browser_main_thread())
+    and (not is_in_node())
+):
+    _fetcher = _StreamingFetcher()
+else:
+    _fetcher = None
+
+
+NODE_JSPI_ERROR = (
+    "urllib3 only works in Node.js with pyodide.runPythonAsync"
+    " and requires the flag --experimental-wasm-stack-switching in "
+    " versions of node <24."
+)
+
+
+def send_streaming_request(request: EmscriptenRequest) -> EmscriptenResponse | None:
+    if has_jspi():
+        return send_jspi_request(request, True)
+    elif is_in_node():
+        raise _RequestError(
+            message=NODE_JSPI_ERROR,
+            request=request,
+            response=None,
+        )
+
+    if _fetcher and streaming_ready():
+        return _fetcher.send(request)
+    else:
+        _show_streaming_warning()
+        return None
+
+
+_SHOWN_TIMEOUT_WARNING = False
+
+
+def _show_timeout_warning() -> None:
+    global _SHOWN_TIMEOUT_WARNING
+    if not _SHOWN_TIMEOUT_WARNING:
+        _SHOWN_TIMEOUT_WARNING = True
+        message = "Warning: Timeout is not available on main browser thread"
+        js.console.warn(message)
+
+
+_SHOWN_STREAMING_WARNING = False
+
+
+def _show_streaming_warning() -> None:
+    global _SHOWN_STREAMING_WARNING
+    if not _SHOWN_STREAMING_WARNING:
+        _SHOWN_STREAMING_WARNING = True
+        message = "Can't stream HTTP requests because: \n"
+        if not is_cross_origin_isolated():
+            message += "  Page is not cross-origin isolated\n"
+        if is_in_browser_main_thread():
+            message += "  Python is running in main browser thread\n"
+        if not is_worker_available():
+            message += " Worker or Blob classes are not available in this environment."  # Defensive: this is always False in browsers that we test in
+        if streaming_ready() is False:
+            message += """ Streaming fetch worker isn't ready. If you want to be sure that streaming fetch
+is working, you need to call: 'await urllib3.contrib.emscripten.fetch.wait_for_streaming_ready()`"""
+        from js import console
+
+        console.warn(message)
+
+
+def send_request(request: EmscriptenRequest) -> EmscriptenResponse:
+    if has_jspi():
+        return send_jspi_request(request, False)
+    elif is_in_node():
+        raise _RequestError(
+            message=NODE_JSPI_ERROR,
+            request=request,
+            response=None,
+        )
+    try:
+        js_xhr = js.XMLHttpRequest.new()
+
+        if not is_in_browser_main_thread():
+            js_xhr.responseType = "arraybuffer"
+            if request.timeout:
+                js_xhr.timeout = int(request.timeout * 1000)
+        else:
+            js_xhr.overrideMimeType("text/plain; charset=ISO-8859-15")
+            if request.timeout:
+                # timeout isn't available on the main thread - show a warning in console
+                # if it is set
+                _show_timeout_warning()
+
+        js_xhr.open(request.method, request.url, False)
+        for name, value in request.headers.items():
+            if name.lower() not in HEADERS_TO_IGNORE:
+                js_xhr.setRequestHeader(name, value)
+
+        js_xhr.send(to_js(request.body))
+
+        headers = dict(Parser().parsestr(js_xhr.getAllResponseHeaders()))
+
+        if not is_in_browser_main_thread():
+            body = js_xhr.response.to_py().tobytes()
+        else:
+            body = js_xhr.response.encode("ISO-8859-15")
+        return EmscriptenResponse(
+            status_code=js_xhr.status, headers=headers, body=body, request=request
+        )
+    except JsException as err:
+        if err.name == "TimeoutError":
+            raise _TimeoutError(err.message, request=request)
+        elif err.name == "NetworkError":
+            raise _RequestError(err.message, request=request)
+        else:
+            # general http error
+            raise _RequestError(err.message, request=request)
+
+
+def send_jspi_request(
+    request: EmscriptenRequest, streaming: bool
+) -> EmscriptenResponse:
+    """
+    Send a request using WebAssembly JavaScript Promise Integration
+    to wrap the asynchronous JavaScript fetch api (experimental).
+
+    :param request:
+        Request to send
+
+    :param streaming:
+        Whether to stream the response
+
+    :return: The response object
+    :rtype: EmscriptenResponse
+    """
+    timeout = request.timeout
+    js_abort_controller = js.AbortController.new()
+    headers = {k: v for k, v in request.headers.items() if k not in HEADERS_TO_IGNORE}
+    req_body = request.body
+    fetch_data = {
+        "headers": headers,
+        "body": to_js(req_body),
+        "method": request.method,
+        "signal": js_abort_controller.signal,
+    }
+    # Node.js returns the whole response (unlike opaqueredirect in browsers),
+    # so urllib3 can set `redirect: manual` to control redirects itself.
+    # https://stackoverflow.com/a/78524615
+    if _is_node_js():
+        fetch_data["redirect"] = "manual"
+    # Call JavaScript fetch (async api, returns a promise)
+    fetcher_promise_js = js.fetch(request.url, _obj_from_dict(fetch_data))
+    # Now suspend WebAssembly until we resolve that promise
+    # or time out.
+    response_js = _run_sync_with_timeout(
+        fetcher_promise_js,
+        timeout,
+        js_abort_controller,
+        request=request,
+        response=None,
+    )
+    headers = {}
+    header_iter = response_js.headers.entries()
+    while True:
+        iter_value_js = header_iter.next()
+        if getattr(iter_value_js, "done", False):
+            break
+        else:
+            headers[str(iter_value_js.value[0])] = str(iter_value_js.value[1])
+    status_code = response_js.status
+    body: bytes | io.RawIOBase = b""
+
+    response = EmscriptenResponse(
+        status_code=status_code, headers=headers, body=b"", request=request
+    )
+    if streaming:
+        # get via inputstream
+        if response_js.body is not None:
+            # get a reader from the fetch response
+            body_stream_js = response_js.body.getReader()
+            body = _JSPIReadStream(
+                body_stream_js, timeout, request, response, js_abort_controller
+            )
+    else:
+        # get directly via arraybuffer
+        # n.b. this is another async JavaScript call.
+        body = _run_sync_with_timeout(
+            response_js.arrayBuffer(),
+            timeout,
+            js_abort_controller,
+            request=request,
+            response=response,
+        ).to_py()
+    response.body = body
+    return response
+
+
+def _run_sync_with_timeout(
+    promise: Any,
+    timeout: float,
+    js_abort_controller: Any,
+    request: EmscriptenRequest | None,
+    response: EmscriptenResponse | None,
+) -> Any:
+    """
+    Await a JavaScript promise synchronously with a timeout which is implemented
+    via the AbortController
+
+    :param promise:
+        Javascript promise to await
+
+    :param timeout:
+        Timeout in seconds
+
+    :param js_abort_controller:
+        A JavaScript AbortController object, used on timeout
+
+    :param request:
+        The request being handled
+
+    :param response:
+        The response being handled (if it exists yet)
+
+    :raises _TimeoutError: If the request times out
+    :raises _RequestError: If the request raises a JavaScript exception
+
+    :return: The result of awaiting the promise.
+    """
+    timer_id = None
+    if timeout > 0:
+        timer_id = js.setTimeout(
+            js_abort_controller.abort.bind(js_abort_controller), int(timeout * 1000)
+        )
+    try:
+        from pyodide.ffi import run_sync
+
+        # run_sync here uses WebAssembly JavaScript Promise Integration to
+        # suspend python until the JavaScript promise resolves.
+        return run_sync(promise)
+    except JsException as err:
+        if err.name == "AbortError":
+            raise _TimeoutError(
+                message="Request timed out", request=request, response=response
+            )
+        else:
+            raise _RequestError(message=err.message, request=request, response=response)
+    finally:
+        if timer_id is not None:
+            js.clearTimeout(timer_id)
+
+
+def has_jspi() -> bool:
+    """
+    Return true if jspi can be used.
+
+    This requires both browser support and also WebAssembly
+    to be in the correct state - i.e. that the javascript
+    call into python was async not sync.
+
+    :return: True if jspi can be used.
+    :rtype: bool
+    """
+    try:
+        from pyodide.ffi import can_run_sync, run_sync  # noqa: F401
+
+        return bool(can_run_sync())
+    except ImportError:
+        return False
+
+
+def _is_node_js() -> bool:
+    """
+    Check if we are in Node.js.
+
+    :return: True if we are in Node.js.
+    :rtype: bool
+    """
+    return (
+        hasattr(js, "process")
+        and hasattr(js.process, "release")
+        # According to the Node.js documentation, the release name is always "node".
+        and js.process.release.name == "node"
+    )
+
+
+def streaming_ready() -> bool | None:
+    if _fetcher:
+        return _fetcher.streaming_ready
+    else:
+        return None  # no fetcher, return None to signify that
+
+
+async def wait_for_streaming_ready() -> bool:
+    if _fetcher:
+        await _fetcher.js_worker_ready_promise
+        return True
+    else:
+        return False
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/request.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/request.py
new file mode 100644
index 0000000000000000000000000000000000000000..e692e692bd0d38f6a0677992a6993fc68050dff3
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/request.py
@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..._base_connection import _TYPE_BODY
+
+
+@dataclass
+class EmscriptenRequest:
+    method: str
+    url: str
+    params: dict[str, str] | None = None
+    body: _TYPE_BODY | None = None
+    headers: dict[str, str] = field(default_factory=dict)
+    timeout: float = 0
+    decode_content: bool = True
+
+    def set_header(self, name: str, value: str) -> None:
+        self.headers[name.capitalize()] = value
+
+    def set_body(self, body: _TYPE_BODY | None) -> None:
+        self.body = body
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/response.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/response.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb1088a1826d089e1b603c51e85560b8583a3e3d
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/response.py
@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import json as _json
+import logging
+import typing
+from contextlib import contextmanager
+from dataclasses import dataclass
+from http.client import HTTPException as HTTPException
+from io import BytesIO, IOBase
+
+from ...exceptions import InvalidHeader, TimeoutError
+from ...response import BaseHTTPResponse
+from ...util.retry import Retry
+from .request import EmscriptenRequest
+
+if typing.TYPE_CHECKING:
+    from ..._base_connection import BaseHTTPConnection, BaseHTTPSConnection
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class EmscriptenResponse:
+    status_code: int
+    headers: dict[str, str]
+    body: IOBase | bytes
+    request: EmscriptenRequest
+
+
+class EmscriptenHttpResponseWrapper(BaseHTTPResponse):
+    def __init__(
+        self,
+        internal_response: EmscriptenResponse,
+        url: str | None = None,
+        connection: BaseHTTPConnection | BaseHTTPSConnection | None = None,
+    ):
+        self._pool = None  # set by pool class
+        self._body = None
+        self._response = internal_response
+        self._url = url
+        self._connection = connection
+        self._closed = False
+        super().__init__(
+            headers=internal_response.headers,
+            status=internal_response.status_code,
+            request_url=url,
+            version=0,
+            version_string="HTTP/?",
+            reason="",
+            decode_content=True,
+        )
+        self.length_remaining = self._init_length(self._response.request.method)
+        self.length_is_certain = False
+
+    @property
+    def url(self) -> str | None:
+        return self._url
+
+    @url.setter
+    def url(self, url: str | None) -> None:
+        self._url = url
+
+    @property
+    def connection(self) -> BaseHTTPConnection | BaseHTTPSConnection | None:
+        return self._connection
+
+    @property
+    def retries(self) -> Retry | None:
+        return self._retries
+
+    @retries.setter
+    def retries(self, retries: Retry | None) -> None:
+        # Override the request_url if retries has a redirect location.
+        self._retries = retries
+
+    def stream(
+        self, amt: int | None = 2**16, decode_content: bool | None = None
+    ) -> typing.Generator[bytes]:
+        """
+        A generator wrapper for the read() method. A call will block until
+        ``amt`` bytes have been read from the connection or until the
+        connection is closed.
+
+        :param amt:
+            How much of the content to read. The generator will return up to
+            much data per iteration, but may return less. This is particularly
+            likely when using compressed data. However, the empty string will
+            never be returned.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        while True:
+            data = self.read(amt=amt, decode_content=decode_content)
+
+            if data:
+                yield data
+            else:
+                break
+
+    def _init_length(self, request_method: str | None) -> int | None:
+        length: int | None
+        content_length: str | None = self.headers.get("content-length")
+
+        if content_length is not None:
+            try:
+                # RFC 7230 section 3.3.2 specifies multiple content lengths can
+                # be sent in a single Content-Length header
+                # (e.g. Content-Length: 42, 42). This line ensures the values
+                # are all valid ints and that as long as the `set` length is 1,
+                # all values are the same. Otherwise, the header is invalid.
+                lengths = {int(val) for val in content_length.split(",")}
+                if len(lengths) > 1:
+                    raise InvalidHeader(
+                        "Content-Length contained multiple "
+                        "unmatching values (%s)" % content_length
+                    )
+                length = lengths.pop()
+            except ValueError:
+                length = None
+            else:
+                if length < 0:
+                    length = None
+
+        else:  # if content_length is None
+            length = None
+
+        # Check for responses that shouldn't include a body
+        if (
+            self.status in (204, 304)
+            or 100 <= self.status < 200
+            or request_method == "HEAD"
+        ):
+            length = 0
+
+        return length
+
+    def read(
+        self,
+        amt: int | None = None,
+        decode_content: bool | None = None,  # ignored because browser decodes always
+        cache_content: bool = False,
+    ) -> bytes:
+        if (
+            self._closed
+            or self._response is None
+            or (isinstance(self._response.body, IOBase) and self._response.body.closed)
+        ):
+            return b""
+
+        with self._error_catcher():
+            # body has been preloaded as a string by XmlHttpRequest
+            if not isinstance(self._response.body, IOBase):
+                self.length_remaining = len(self._response.body)
+                self.length_is_certain = True
+                # wrap body in IOStream
+                self._response.body = BytesIO(self._response.body)
+            if amt is not None and amt >= 0:
+                # don't cache partial content
+                cache_content = False
+                data = self._response.body.read(amt)
+            else:  # read all we can (and cache it)
+                data = self._response.body.read()
+                if cache_content:
+                    self._body = data
+            if self.length_remaining is not None:
+                self.length_remaining = max(self.length_remaining - len(data), 0)
+            if len(data) == 0 or (
+                self.length_is_certain and self.length_remaining == 0
+            ):
+                # definitely finished reading, close response stream
+                self._response.body.close()
+            return typing.cast(bytes, data)
+
+    def read_chunked(
+        self,
+        amt: int | None = None,
+        decode_content: bool | None = None,
+    ) -> typing.Generator[bytes]:
+        # chunked is handled by browser
+        while True:
+            bytes = self.read(amt, decode_content)
+            if not bytes:
+                break
+            yield bytes
+
+    def release_conn(self) -> None:
+        if not self._pool or not self._connection:
+            return None
+
+        self._pool._put_conn(self._connection)
+        self._connection = None
+
+    def drain_conn(self) -> None:
+        self.close()
+
+    @property
+    def data(self) -> bytes:
+        if self._body:
+            return self._body
+        else:
+            return self.read(cache_content=True)
+
+    def json(self) -> typing.Any:
+        """
+        Deserializes the body of the HTTP response as a Python object.
+
+        The body of the HTTP response must be encoded using UTF-8, as per
+        `RFC 8529 Section 8.1 `_.
+
+        To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to
+        your custom decoder instead.
+
+        If the body of the HTTP response is not decodable to UTF-8, a
+        `UnicodeDecodeError` will be raised. If the body of the HTTP response is not a
+        valid JSON document, a `json.JSONDecodeError` will be raised.
+
+        Read more :ref:`here `.
+
+        :returns: The body of the HTTP response as a Python object.
+        """
+        data = self.data.decode("utf-8")
+        return _json.loads(data)
+
+    def close(self) -> None:
+        if not self._closed:
+            if isinstance(self._response.body, IOBase):
+                self._response.body.close()
+            if self._connection:
+                self._connection.close()
+                self._connection = None
+            self._closed = True
+
+    @contextmanager
+    def _error_catcher(self) -> typing.Generator[None]:
+        """
+        Catch Emscripten specific exceptions thrown by fetch.py,
+        instead re-raising urllib3 variants, so that low-level exceptions
+        are not leaked in the high-level api.
+
+        On exit, release the connection back to the pool.
+        """
+        from .fetch import _RequestError, _TimeoutError  # avoid circular import
+
+        clean_exit = False
+
+        try:
+            yield
+            # If no exception is thrown, we should avoid cleaning up
+            # unnecessarily.
+            clean_exit = True
+        except _TimeoutError as e:
+            raise TimeoutError(str(e))
+        except _RequestError as e:
+            raise HTTPException(str(e))
+        finally:
+            # If we didn't terminate cleanly, we need to throw away our
+            # connection.
+            if not clean_exit:
+                # The response may not be closed but we're not going to use it
+                # anymore so close it now
+                if (
+                    isinstance(self._response.body, IOBase)
+                    and not self._response.body.closed
+                ):
+                    self._response.body.close()
+                # release the connection back to the pool
+                self.release_conn()
+            else:
+                # If we have read everything from the response stream,
+                # return the connection back to the pool.
+                if (
+                    isinstance(self._response.body, IOBase)
+                    and self._response.body.closed
+                ):
+                    self.release_conn()
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/pyopenssl.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/pyopenssl.py
new file mode 100644
index 0000000000000000000000000000000000000000..3714500ec2e1c104b92dff1bb8f7244b8b458ed8
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/pyopenssl.py
@@ -0,0 +1,564 @@
+"""
+Module for using pyOpenSSL as a TLS backend. This module was relevant before
+the standard library ``ssl`` module supported SNI, but now that we've dropped
+support for Python 2.7 all relevant Python versions support SNI so
+**this module is no longer recommended**.
+
+This needs the following packages installed:
+
+* `pyOpenSSL`_ (tested with 16.0.0)
+* `cryptography`_ (minimum 1.3.4, from pyopenssl)
+* `idna`_ (minimum 2.0)
+
+However, pyOpenSSL depends on cryptography, so while we use all three directly here we
+end up having relatively few packages required.
+
+You can install them with the following command:
+
+.. code-block:: bash
+
+    $ python -m pip install pyopenssl cryptography idna
+
+To activate certificate checking, call
+:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code
+before you begin making HTTP requests. This can be done in a ``sitecustomize``
+module, or at any other time before your application begins using ``urllib3``,
+like this:
+
+.. code-block:: python
+
+    try:
+        import urllib3.contrib.pyopenssl
+        urllib3.contrib.pyopenssl.inject_into_urllib3()
+    except ImportError:
+        pass
+
+.. _pyopenssl: https://www.pyopenssl.org
+.. _cryptography: https://cryptography.io
+.. _idna: https://github.com/kjd/idna
+"""
+
+from __future__ import annotations
+
+import OpenSSL.SSL  # type: ignore[import-untyped]
+from cryptography import x509
+
+try:
+    from cryptography.x509 import UnsupportedExtension  # type: ignore[attr-defined]
+except ImportError:
+    # UnsupportedExtension is gone in cryptography >= 2.1.0
+    class UnsupportedExtension(Exception):  # type: ignore[no-redef]
+        pass
+
+
+import logging
+import ssl
+import typing
+from io import BytesIO
+from socket import socket as socket_cls
+from socket import timeout
+
+from .. import util
+
+if typing.TYPE_CHECKING:
+    from OpenSSL.crypto import X509  # type: ignore[import-untyped]
+
+
+__all__ = ["inject_into_urllib3", "extract_from_urllib3"]
+
+# Map from urllib3 to PyOpenSSL compatible parameter-values.
+_openssl_versions: dict[int, int] = {
+    util.ssl_.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD,  # type: ignore[attr-defined]
+    util.ssl_.PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD,  # type: ignore[attr-defined]
+    ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD,
+}
+
+if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD
+
+if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD
+
+
+_stdlib_to_openssl_verify = {
+    ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE,
+    ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER,
+    ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER
+    + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
+}
+_openssl_to_stdlib_verify = {v: k for k, v in _stdlib_to_openssl_verify.items()}
+
+# The SSLvX values are the most likely to be missing in the future
+# but we check them all just to be sure.
+_OP_NO_SSLv2_OR_SSLv3: int = getattr(OpenSSL.SSL, "OP_NO_SSLv2", 0) | getattr(
+    OpenSSL.SSL, "OP_NO_SSLv3", 0
+)
+_OP_NO_TLSv1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1", 0)
+_OP_NO_TLSv1_1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_1", 0)
+_OP_NO_TLSv1_2: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_2", 0)
+_OP_NO_TLSv1_3: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_3", 0)
+
+_openssl_to_ssl_minimum_version: dict[int, int] = {
+    ssl.TLSVersion.MINIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3,
+    ssl.TLSVersion.TLSv1: _OP_NO_SSLv2_OR_SSLv3,
+    ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1,
+    ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1,
+    ssl.TLSVersion.TLSv1_3: (
+        _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2
+    ),
+    ssl.TLSVersion.MAXIMUM_SUPPORTED: (
+        _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2
+    ),
+}
+_openssl_to_ssl_maximum_version: dict[int, int] = {
+    ssl.TLSVersion.MINIMUM_SUPPORTED: (
+        _OP_NO_SSLv2_OR_SSLv3
+        | _OP_NO_TLSv1
+        | _OP_NO_TLSv1_1
+        | _OP_NO_TLSv1_2
+        | _OP_NO_TLSv1_3
+    ),
+    ssl.TLSVersion.TLSv1: (
+        _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3
+    ),
+    ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3,
+    ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_3,
+    ssl.TLSVersion.TLSv1_3: _OP_NO_SSLv2_OR_SSLv3,
+    ssl.TLSVersion.MAXIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3,
+}
+
+# OpenSSL will only write 16K at a time
+SSL_WRITE_BLOCKSIZE = 16384
+
+orig_util_SSLContext = util.ssl_.SSLContext
+
+
+log = logging.getLogger(__name__)
+
+
+def inject_into_urllib3() -> None:
+    "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support."
+
+    _validate_dependencies_met()
+
+    util.SSLContext = PyOpenSSLContext  # type: ignore[assignment]
+    util.ssl_.SSLContext = PyOpenSSLContext  # type: ignore[assignment]
+    util.IS_PYOPENSSL = True
+    util.ssl_.IS_PYOPENSSL = True
+
+
+def extract_from_urllib3() -> None:
+    "Undo monkey-patching by :func:`inject_into_urllib3`."
+
+    util.SSLContext = orig_util_SSLContext
+    util.ssl_.SSLContext = orig_util_SSLContext
+    util.IS_PYOPENSSL = False
+    util.ssl_.IS_PYOPENSSL = False
+
+
+def _validate_dependencies_met() -> None:
+    """
+    Verifies that PyOpenSSL's package-level dependencies have been met.
+    Throws `ImportError` if they are not met.
+    """
+    # Method added in `cryptography==1.1`; not available in older versions
+    from cryptography.x509.extensions import Extensions
+
+    if getattr(Extensions, "get_extension_for_class", None) is None:
+        raise ImportError(
+            "'cryptography' module missing required functionality.  "
+            "Try upgrading to v1.3.4 or newer."
+        )
+
+    # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509
+    # attribute is only present on those versions.
+    from OpenSSL.crypto import X509
+
+    x509 = X509()
+    if getattr(x509, "_x509", None) is None:
+        raise ImportError(
+            "'pyOpenSSL' module missing required functionality. "
+            "Try upgrading to v0.14 or newer."
+        )
+
+
+def _dnsname_to_stdlib(name: str) -> str | None:
+    """
+    Converts a dNSName SubjectAlternativeName field to the form used by the
+    standard library on the given Python version.
+
+    Cryptography produces a dNSName as a unicode string that was idna-decoded
+    from ASCII bytes. We need to idna-encode that string to get it back, and
+    then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib
+    uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8).
+
+    If the name cannot be idna-encoded then we return None signalling that
+    the name given should be skipped.
+    """
+
+    def idna_encode(name: str) -> bytes | None:
+        """
+        Borrowed wholesale from the Python Cryptography Project. It turns out
+        that we can't just safely call `idna.encode`: it can explode for
+        wildcard names. This avoids that problem.
+        """
+        import idna
+
+        try:
+            for prefix in ["*.", "."]:
+                if name.startswith(prefix):
+                    name = name[len(prefix) :]
+                    return prefix.encode("ascii") + idna.encode(name)
+            return idna.encode(name)
+        except idna.core.IDNAError:
+            return None
+
+    # Don't send IPv6 addresses through the IDNA encoder.
+    if ":" in name:
+        return name
+
+    encoded_name = idna_encode(name)
+    if encoded_name is None:
+        return None
+    return encoded_name.decode("utf-8")
+
+
+def get_subj_alt_name(peer_cert: X509) -> list[tuple[str, str]]:
+    """
+    Given an PyOpenSSL certificate, provides all the subject alternative names.
+    """
+    cert = peer_cert.to_cryptography()
+
+    # We want to find the SAN extension. Ask Cryptography to locate it (it's
+    # faster than looping in Python)
+    try:
+        ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
+    except x509.ExtensionNotFound:
+        # No such extension, return the empty list.
+        return []
+    except (
+        x509.DuplicateExtension,
+        UnsupportedExtension,
+        x509.UnsupportedGeneralNameType,
+        UnicodeError,
+    ) as e:
+        # A problem has been found with the quality of the certificate. Assume
+        # no SAN field is present.
+        log.warning(
+            "A problem was encountered with the certificate that prevented "
+            "urllib3 from finding the SubjectAlternativeName field. This can "
+            "affect certificate validation. The error was %s",
+            e,
+        )
+        return []
+
+    # We want to return dNSName and iPAddress fields. We need to cast the IPs
+    # back to strings because the match_hostname function wants them as
+    # strings.
+    # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8
+    # decoded. This is pretty frustrating, but that's what the standard library
+    # does with certificates, and so we need to attempt to do the same.
+    # We also want to skip over names which cannot be idna encoded.
+    names = [
+        ("DNS", name)
+        for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName))
+        if name is not None
+    ]
+    names.extend(
+        ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress)
+    )
+
+    return names
+
+
+class WrappedSocket:
+    """API-compatibility wrapper for Python OpenSSL's Connection-class."""
+
+    def __init__(
+        self,
+        connection: OpenSSL.SSL.Connection,
+        socket: socket_cls,
+        suppress_ragged_eofs: bool = True,
+    ) -> None:
+        self.connection = connection
+        self.socket = socket
+        self.suppress_ragged_eofs = suppress_ragged_eofs
+        self._io_refs = 0
+        self._closed = False
+
+    def fileno(self) -> int:
+        return self.socket.fileno()
+
+    # Copy-pasted from Python 3.5 source code
+    def _decref_socketios(self) -> None:
+        if self._io_refs > 0:
+            self._io_refs -= 1
+        if self._closed:
+            self.close()
+
+    def recv(self, *args: typing.Any, **kwargs: typing.Any) -> bytes:
+        try:
+            data = self.connection.recv(*args, **kwargs)
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"):
+                return b""
+            else:
+                raise OSError(e.args[0], str(e)) from e
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return b""
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError as e:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout("The read operation timed out") from e
+            else:
+                return self.recv(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError(f"read error: {e!r}") from e
+        else:
+            return data  # type: ignore[no-any-return]
+
+    def recv_into(self, *args: typing.Any, **kwargs: typing.Any) -> int:
+        try:
+            return self.connection.recv_into(*args, **kwargs)  # type: ignore[no-any-return]
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"):
+                return 0
+            else:
+                raise OSError(e.args[0], str(e)) from e
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return 0
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError as e:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout("The read operation timed out") from e
+            else:
+                return self.recv_into(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError(f"read error: {e!r}") from e
+
+    def settimeout(self, timeout: float) -> None:
+        return self.socket.settimeout(timeout)
+
+    def _send_until_done(self, data: bytes) -> int:
+        while True:
+            try:
+                return self.connection.send(data)  # type: ignore[no-any-return]
+            except OpenSSL.SSL.WantWriteError as e:
+                if not util.wait_for_write(self.socket, self.socket.gettimeout()):
+                    raise timeout() from e
+                continue
+            except OpenSSL.SSL.SysCallError as e:
+                raise OSError(e.args[0], str(e)) from e
+
+    def sendall(self, data: bytes) -> None:
+        total_sent = 0
+        while total_sent < len(data):
+            sent = self._send_until_done(
+                data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE]
+            )
+            total_sent += sent
+
+    def shutdown(self, how: int) -> None:
+        try:
+            self.connection.shutdown()
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError(f"shutdown error: {e!r}") from e
+
+    def close(self) -> None:
+        self._closed = True
+        if self._io_refs <= 0:
+            self._real_close()
+
+    def _real_close(self) -> None:
+        try:
+            return self.connection.close()  # type: ignore[no-any-return]
+        except OpenSSL.SSL.Error:
+            return
+
+    def getpeercert(
+        self, binary_form: bool = False
+    ) -> dict[str, list[typing.Any]] | None:
+        x509 = self.connection.get_peer_certificate()
+
+        if not x509:
+            return x509  # type: ignore[no-any-return]
+
+        if binary_form:
+            return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509)  # type: ignore[no-any-return]
+
+        return {
+            "subject": ((("commonName", x509.get_subject().CN),),),  # type: ignore[dict-item]
+            "subjectAltName": get_subj_alt_name(x509),
+        }
+
+    def version(self) -> str:
+        return self.connection.get_protocol_version_name()  # type: ignore[no-any-return]
+
+    def selected_alpn_protocol(self) -> str | None:
+        alpn_proto = self.connection.get_alpn_proto_negotiated()
+        return alpn_proto.decode() if alpn_proto else None
+
+
+WrappedSocket.makefile = socket_cls.makefile  # type: ignore[attr-defined]
+
+
+class PyOpenSSLContext:
+    """
+    I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible
+    for translating the interface of the standard library ``SSLContext`` object
+    to calls into PyOpenSSL.
+    """
+
+    def __init__(self, protocol: int) -> None:
+        self.protocol = _openssl_versions[protocol]
+        self._ctx = OpenSSL.SSL.Context(self.protocol)
+        self._options = 0
+        self.check_hostname = False
+        self._minimum_version: int = ssl.TLSVersion.MINIMUM_SUPPORTED
+        self._maximum_version: int = ssl.TLSVersion.MAXIMUM_SUPPORTED
+        self._verify_flags: int = ssl.VERIFY_X509_TRUSTED_FIRST
+
+    @property
+    def options(self) -> int:
+        return self._options
+
+    @options.setter
+    def options(self, value: int) -> None:
+        self._options = value
+        self._set_ctx_options()
+
+    @property
+    def verify_flags(self) -> int:
+        return self._verify_flags
+
+    @verify_flags.setter
+    def verify_flags(self, value: int) -> None:
+        self._verify_flags = value
+        self._ctx.get_cert_store().set_flags(self._verify_flags)
+
+    @property
+    def verify_mode(self) -> int:
+        return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()]
+
+    @verify_mode.setter
+    def verify_mode(self, value: ssl.VerifyMode) -> None:
+        self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback)
+
+    def set_default_verify_paths(self) -> None:
+        self._ctx.set_default_verify_paths()
+
+    def set_ciphers(self, ciphers: bytes | str) -> None:
+        if isinstance(ciphers, str):
+            ciphers = ciphers.encode("utf-8")
+        self._ctx.set_cipher_list(ciphers)
+
+    def load_verify_locations(
+        self,
+        cafile: str | None = None,
+        capath: str | None = None,
+        cadata: bytes | None = None,
+    ) -> None:
+        if cafile is not None:
+            cafile = cafile.encode("utf-8")  # type: ignore[assignment]
+        if capath is not None:
+            capath = capath.encode("utf-8")  # type: ignore[assignment]
+        try:
+            self._ctx.load_verify_locations(cafile, capath)
+            if cadata is not None:
+                self._ctx.load_verify_locations(BytesIO(cadata))
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError(f"unable to load trusted certificates: {e!r}") from e
+
+    def load_cert_chain(
+        self,
+        certfile: str,
+        keyfile: str | None = None,
+        password: str | None = None,
+    ) -> None:
+        try:
+            self._ctx.use_certificate_chain_file(certfile)
+            if password is not None:
+                if not isinstance(password, bytes):
+                    password = password.encode("utf-8")  # type: ignore[assignment]
+                self._ctx.set_passwd_cb(lambda *_: password)
+            self._ctx.use_privatekey_file(keyfile or certfile)
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError(f"Unable to load certificate chain: {e!r}") from e
+
+    def set_alpn_protocols(self, protocols: list[bytes | str]) -> None:
+        protocols = [util.util.to_bytes(p, "ascii") for p in protocols]
+        return self._ctx.set_alpn_protos(protocols)  # type: ignore[no-any-return]
+
+    def wrap_socket(
+        self,
+        sock: socket_cls,
+        server_side: bool = False,
+        do_handshake_on_connect: bool = True,
+        suppress_ragged_eofs: bool = True,
+        server_hostname: bytes | str | None = None,
+    ) -> WrappedSocket:
+        cnx = OpenSSL.SSL.Connection(self._ctx, sock)
+
+        # If server_hostname is an IP, don't use it for SNI, per RFC6066 Section 3
+        if server_hostname and not util.ssl_.is_ipaddress(server_hostname):
+            if isinstance(server_hostname, str):
+                server_hostname = server_hostname.encode("utf-8")
+            cnx.set_tlsext_host_name(server_hostname)
+
+        cnx.set_connect_state()
+
+        while True:
+            try:
+                cnx.do_handshake()
+            except OpenSSL.SSL.WantReadError as e:
+                if not util.wait_for_read(sock, sock.gettimeout()):
+                    raise timeout("select timed out") from e
+                continue
+            except OpenSSL.SSL.Error as e:
+                raise ssl.SSLError(f"bad handshake: {e!r}") from e
+            break
+
+        return WrappedSocket(cnx, sock)
+
+    def _set_ctx_options(self) -> None:
+        self._ctx.set_options(
+            self._options
+            | _openssl_to_ssl_minimum_version[self._minimum_version]
+            | _openssl_to_ssl_maximum_version[self._maximum_version]
+        )
+
+    @property
+    def minimum_version(self) -> int:
+        return self._minimum_version
+
+    @minimum_version.setter
+    def minimum_version(self, minimum_version: int) -> None:
+        self._minimum_version = minimum_version
+        self._set_ctx_options()
+
+    @property
+    def maximum_version(self) -> int:
+        return self._maximum_version
+
+    @maximum_version.setter
+    def maximum_version(self, maximum_version: int) -> None:
+        self._maximum_version = maximum_version
+        self._set_ctx_options()
+
+
+def _verify_callback(
+    cnx: OpenSSL.SSL.Connection,
+    x509: X509,
+    err_no: int,
+    err_depth: int,
+    return_code: int,
+) -> bool:
+    return err_no == 0
diff --git a/.venv/lib/python3.13/site-packages/urllib3/contrib/socks.py b/.venv/lib/python3.13/site-packages/urllib3/contrib/socks.py
new file mode 100644
index 0000000000000000000000000000000000000000..c62b5e0332e7004d3a20da1fd555033f6f88780b
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/contrib/socks.py
@@ -0,0 +1,228 @@
+"""
+This module contains provisional support for SOCKS proxies from within
+urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
+SOCKS5. To enable its functionality, either install PySocks or install this
+module with the ``socks`` extra.
+
+The SOCKS implementation supports the full range of urllib3 features. It also
+supports the following SOCKS features:
+
+- SOCKS4A (``proxy_url='socks4a://...``)
+- SOCKS4 (``proxy_url='socks4://...``)
+- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
+- SOCKS5 with local DNS (``proxy_url='socks5://...``)
+- Usernames and passwords for the SOCKS proxy
+
+.. note::
+   It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
+   your ``proxy_url`` to ensure that DNS resolution is done from the remote
+   server instead of client-side when connecting to a domain name.
+
+SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
+supports IPv4, IPv6, and domain names.
+
+When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
+will be sent as the ``userid`` section of the SOCKS request:
+
+.. code-block:: python
+
+    proxy_url="socks4a://@proxy-host"
+
+When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
+of the ``proxy_url`` will be sent as the username/password to authenticate
+with the proxy:
+
+.. code-block:: python
+
+    proxy_url="socks5h://:@proxy-host"
+
+"""
+
+from __future__ import annotations
+
+try:
+    import socks  # type: ignore[import-not-found]
+except ImportError:
+    import warnings
+
+    from ..exceptions import DependencyWarning
+
+    warnings.warn(
+        (
+            "SOCKS support in urllib3 requires the installation of optional "
+            "dependencies: specifically, PySocks.  For more information, see "
+            "https://urllib3.readthedocs.io/en/latest/advanced-usage.html#socks-proxies"
+        ),
+        DependencyWarning,
+    )
+    raise
+
+import typing
+from socket import timeout as SocketTimeout
+
+from ..connection import HTTPConnection, HTTPSConnection
+from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from ..exceptions import ConnectTimeoutError, NewConnectionError
+from ..poolmanager import PoolManager
+from ..util.url import parse_url
+
+try:
+    import ssl
+except ImportError:
+    ssl = None  # type: ignore[assignment]
+
+
+class _TYPE_SOCKS_OPTIONS(typing.TypedDict):
+    socks_version: int
+    proxy_host: str | None
+    proxy_port: str | None
+    username: str | None
+    password: str | None
+    rdns: bool
+
+
+class SOCKSConnection(HTTPConnection):
+    """
+    A plain-text HTTP connection that connects via a SOCKS proxy.
+    """
+
+    def __init__(
+        self,
+        _socks_options: _TYPE_SOCKS_OPTIONS,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> None:
+        self._socks_options = _socks_options
+        super().__init__(*args, **kwargs)
+
+    def _new_conn(self) -> socks.socksocket:
+        """
+        Establish a new connection via the SOCKS proxy.
+        """
+        extra_kw: dict[str, typing.Any] = {}
+        if self.source_address:
+            extra_kw["source_address"] = self.source_address
+
+        if self.socket_options:
+            extra_kw["socket_options"] = self.socket_options
+
+        try:
+            conn = socks.create_connection(
+                (self.host, self.port),
+                proxy_type=self._socks_options["socks_version"],
+                proxy_addr=self._socks_options["proxy_host"],
+                proxy_port=self._socks_options["proxy_port"],
+                proxy_username=self._socks_options["username"],
+                proxy_password=self._socks_options["password"],
+                proxy_rdns=self._socks_options["rdns"],
+                timeout=self.timeout,
+                **extra_kw,
+            )
+
+        except SocketTimeout as e:
+            raise ConnectTimeoutError(
+                self,
+                f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+            ) from e
+
+        except socks.ProxyError as e:
+            # This is fragile as hell, but it seems to be the only way to raise
+            # useful errors here.
+            if e.socket_err:
+                error = e.socket_err
+                if isinstance(error, SocketTimeout):
+                    raise ConnectTimeoutError(
+                        self,
+                        f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
+                    ) from e
+                else:
+                    # Adding `from e` messes with coverage somehow, so it's omitted.
+                    # See #2386.
+                    raise NewConnectionError(
+                        self, f"Failed to establish a new connection: {error}"
+                    )
+            else:
+                raise NewConnectionError(
+                    self, f"Failed to establish a new connection: {e}"
+                ) from e
+
+        except OSError as e:  # Defensive: PySocks should catch all these.
+            raise NewConnectionError(
+                self, f"Failed to establish a new connection: {e}"
+            ) from e
+
+        return conn
+
+
+# We don't need to duplicate the Verified/Unverified distinction from
+# urllib3/connection.py here because the HTTPSConnection will already have been
+# correctly set to either the Verified or Unverified form by that module. This
+# means the SOCKSHTTPSConnection will automatically be the correct type.
+class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
+    pass
+
+
+class SOCKSHTTPConnectionPool(HTTPConnectionPool):
+    ConnectionCls = SOCKSConnection
+
+
+class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
+    ConnectionCls = SOCKSHTTPSConnection
+
+
+class SOCKSProxyManager(PoolManager):
+    """
+    A version of the urllib3 ProxyManager that routes connections via the
+    defined SOCKS proxy.
+    """
+
+    pool_classes_by_scheme = {
+        "http": SOCKSHTTPConnectionPool,
+        "https": SOCKSHTTPSConnectionPool,
+    }
+
+    def __init__(
+        self,
+        proxy_url: str,
+        username: str | None = None,
+        password: str | None = None,
+        num_pools: int = 10,
+        headers: typing.Mapping[str, str] | None = None,
+        **connection_pool_kw: typing.Any,
+    ):
+        parsed = parse_url(proxy_url)
+
+        if username is None and password is None and parsed.auth is not None:
+            split = parsed.auth.split(":")
+            if len(split) == 2:
+                username, password = split
+        if parsed.scheme == "socks5":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = False
+        elif parsed.scheme == "socks5h":
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = True
+        elif parsed.scheme == "socks4":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = False
+        elif parsed.scheme == "socks4a":
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = True
+        else:
+            raise ValueError(f"Unable to determine SOCKS version from {proxy_url}")
+
+        self.proxy_url = proxy_url
+
+        socks_options = {
+            "socks_version": socks_version,
+            "proxy_host": parsed.host,
+            "proxy_port": parsed.port,
+            "username": username,
+            "password": password,
+            "rdns": rdns,
+        }
+        connection_pool_kw["_socks_options"] = socks_options
+
+        super().__init__(num_pools, headers, **connection_pool_kw)
+
+        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme
diff --git a/.venv/lib/python3.13/site-packages/urllib3/http2/__init__.py b/.venv/lib/python3.13/site-packages/urllib3/http2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..133e1d8f237f6fddd557ae1c0e0cf738f7cc2748
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/http2/__init__.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__all__ = [
+    "inject_into_urllib3",
+    "extract_from_urllib3",
+]
+
+import typing
+
+orig_HTTPSConnection: typing.Any = None
+
+
+def inject_into_urllib3() -> None:
+    # First check if h2 version is valid
+    h2_version = version("h2")
+    if not h2_version.startswith("4."):
+        raise ImportError(
+            "urllib3 v2 supports h2 version 4.x.x, currently "
+            f"the 'h2' module is compiled with {h2_version!r}. "
+            "See: https://github.com/urllib3/urllib3/issues/3290"
+        )
+
+    # Import here to avoid circular dependencies.
+    from .. import connection as urllib3_connection
+    from .. import util as urllib3_util
+    from ..connectionpool import HTTPSConnectionPool
+    from ..util import ssl_ as urllib3_util_ssl
+    from .connection import HTTP2Connection
+
+    global orig_HTTPSConnection
+    orig_HTTPSConnection = urllib3_connection.HTTPSConnection
+
+    HTTPSConnectionPool.ConnectionCls = HTTP2Connection
+    urllib3_connection.HTTPSConnection = HTTP2Connection  # type: ignore[misc]
+
+    # TODO: Offer 'http/1.1' as well, but for testing purposes this is handy.
+    urllib3_util.ALPN_PROTOCOLS = ["h2"]
+    urllib3_util_ssl.ALPN_PROTOCOLS = ["h2"]
+
+
+def extract_from_urllib3() -> None:
+    from .. import connection as urllib3_connection
+    from .. import util as urllib3_util
+    from ..connectionpool import HTTPSConnectionPool
+    from ..util import ssl_ as urllib3_util_ssl
+
+    HTTPSConnectionPool.ConnectionCls = orig_HTTPSConnection
+    urllib3_connection.HTTPSConnection = orig_HTTPSConnection  # type: ignore[misc]
+
+    urllib3_util.ALPN_PROTOCOLS = ["http/1.1"]
+    urllib3_util_ssl.ALPN_PROTOCOLS = ["http/1.1"]
diff --git a/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afa68fb6c2733dbd8fcac8f46473dec8fbdc0c86
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/__init__.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/probe.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/probe.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99bbd4e351eaf2fff1b4caedc50c991913f9e69d
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/http2/__pycache__/probe.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/http2/connection.py b/.venv/lib/python3.13/site-packages/urllib3/http2/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0822391f6f6bd1c1203fd0c212100e7144c3553
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/http2/connection.py
@@ -0,0 +1,356 @@
+from __future__ import annotations
+
+import logging
+import re
+import threading
+import types
+import typing
+
+import h2.config  # type: ignore[import-untyped]
+import h2.connection  # type: ignore[import-untyped]
+import h2.events  # type: ignore[import-untyped]
+
+from .._base_connection import _TYPE_BODY
+from .._collections import HTTPHeaderDict
+from ..connection import HTTPSConnection, _get_default_user_agent
+from ..exceptions import ConnectionError
+from ..response import BaseHTTPResponse
+
+orig_HTTPSConnection = HTTPSConnection
+
+T = typing.TypeVar("T")
+
+log = logging.getLogger(__name__)
+
+RE_IS_LEGAL_HEADER_NAME = re.compile(rb"^[!#$%&'*+\-.^_`|~0-9a-z]+$")
+RE_IS_ILLEGAL_HEADER_VALUE = re.compile(rb"[\0\x00\x0a\x0d\r\n]|^[ \r\n\t]|[ \r\n\t]$")
+
+
+def _is_legal_header_name(name: bytes) -> bool:
+    """
+    "An implementation that validates fields according to the definitions in Sections
+    5.1 and 5.5 of [HTTP] only needs an additional check that field names do not
+    include uppercase characters." (https://httpwg.org/specs/rfc9113.html#n-field-validity)
+
+    `http.client._is_legal_header_name` does not validate the field name according to the
+    HTTP 1.1 spec, so we do that here, in addition to checking for uppercase characters.
+
+    This does not allow for the `:` character in the header name, so should not
+    be used to validate pseudo-headers.
+    """
+    return bool(RE_IS_LEGAL_HEADER_NAME.match(name))
+
+
+def _is_illegal_header_value(value: bytes) -> bool:
+    """
+    "A field value MUST NOT contain the zero value (ASCII NUL, 0x00), line feed
+    (ASCII LF, 0x0a), or carriage return (ASCII CR, 0x0d) at any position. A field
+    value MUST NOT start or end with an ASCII whitespace character (ASCII SP or HTAB,
+    0x20 or 0x09)." (https://httpwg.org/specs/rfc9113.html#n-field-validity)
+    """
+    return bool(RE_IS_ILLEGAL_HEADER_VALUE.search(value))
+
+
+class _LockedObject(typing.Generic[T]):
+    """
+    A wrapper class that hides a specific object behind a lock.
+    The goal here is to provide a simple way to protect access to an object
+    that cannot safely be simultaneously accessed from multiple threads. The
+    intended use of this class is simple: take hold of it with a context
+    manager, which returns the protected object.
+    """
+
+    __slots__ = (
+        "lock",
+        "_obj",
+    )
+
+    def __init__(self, obj: T):
+        self.lock = threading.RLock()
+        self._obj = obj
+
+    def __enter__(self) -> T:
+        self.lock.acquire()
+        return self._obj
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
+        self.lock.release()
+
+
+class HTTP2Connection(HTTPSConnection):
+    def __init__(
+        self, host: str, port: int | None = None, **kwargs: typing.Any
+    ) -> None:
+        self._h2_conn = self._new_h2_conn()
+        self._h2_stream: int | None = None
+        self._headers: list[tuple[bytes, bytes]] = []
+
+        if "proxy" in kwargs or "proxy_config" in kwargs:  # Defensive:
+            raise NotImplementedError("Proxies aren't supported with HTTP/2")
+
+        super().__init__(host, port, **kwargs)
+
+        if self._tunnel_host is not None:
+            raise NotImplementedError("Tunneling isn't supported with HTTP/2")
+
+    def _new_h2_conn(self) -> _LockedObject[h2.connection.H2Connection]:
+        config = h2.config.H2Configuration(client_side=True)
+        return _LockedObject(h2.connection.H2Connection(config=config))
+
+    def connect(self) -> None:
+        super().connect()
+        with self._h2_conn as conn:
+            conn.initiate_connection()
+            if data_to_send := conn.data_to_send():
+                self.sock.sendall(data_to_send)
+
+    def putrequest(  # type: ignore[override]
+        self,
+        method: str,
+        url: str,
+        **kwargs: typing.Any,
+    ) -> None:
+        """putrequest
+        This deviates from the HTTPConnection method signature since we never need to override
+        sending accept-encoding headers or the host header.
+        """
+        if "skip_host" in kwargs:
+            raise NotImplementedError("`skip_host` isn't supported")
+        if "skip_accept_encoding" in kwargs:
+            raise NotImplementedError("`skip_accept_encoding` isn't supported")
+
+        self._request_url = url or "/"
+        self._validate_path(url)  # type: ignore[attr-defined]
+
+        if ":" in self.host:
+            authority = f"[{self.host}]:{self.port or 443}"
+        else:
+            authority = f"{self.host}:{self.port or 443}"
+
+        self._headers.append((b":scheme", b"https"))
+        self._headers.append((b":method", method.encode()))
+        self._headers.append((b":authority", authority.encode()))
+        self._headers.append((b":path", url.encode()))
+
+        with self._h2_conn as conn:
+            self._h2_stream = conn.get_next_available_stream_id()
+
+    def putheader(self, header: str | bytes, *values: str | bytes) -> None:  # type: ignore[override]
+        # TODO SKIPPABLE_HEADERS from urllib3 are ignored.
+        header = header.encode() if isinstance(header, str) else header
+        header = header.lower()  # A lot of upstream code uses capitalized headers.
+        if not _is_legal_header_name(header):
+            raise ValueError(f"Illegal header name {str(header)}")
+
+        for value in values:
+            value = value.encode() if isinstance(value, str) else value
+            if _is_illegal_header_value(value):
+                raise ValueError(f"Illegal header value {str(value)}")
+            self._headers.append((header, value))
+
+    def endheaders(self, message_body: typing.Any = None) -> None:  # type: ignore[override]
+        if self._h2_stream is None:
+            raise ConnectionError("Must call `putrequest` first.")
+
+        with self._h2_conn as conn:
+            conn.send_headers(
+                stream_id=self._h2_stream,
+                headers=self._headers,
+                end_stream=(message_body is None),
+            )
+            if data_to_send := conn.data_to_send():
+                self.sock.sendall(data_to_send)
+        self._headers = []  # Reset headers for the next request.
+
+    def send(self, data: typing.Any) -> None:
+        """Send data to the server.
+        `data` can be: `str`, `bytes`, an iterable, or file-like objects
+        that support a .read() method.
+        """
+        if self._h2_stream is None:
+            raise ConnectionError("Must call `putrequest` first.")
+
+        with self._h2_conn as conn:
+            if data_to_send := conn.data_to_send():
+                self.sock.sendall(data_to_send)
+
+            if hasattr(data, "read"):  # file-like objects
+                while True:
+                    chunk = data.read(self.blocksize)
+                    if not chunk:
+                        break
+                    if isinstance(chunk, str):
+                        chunk = chunk.encode()  # pragma: no cover
+                    conn.send_data(self._h2_stream, chunk, end_stream=False)
+                    if data_to_send := conn.data_to_send():
+                        self.sock.sendall(data_to_send)
+                conn.end_stream(self._h2_stream)
+                return
+
+            if isinstance(data, str):  # str -> bytes
+                data = data.encode()
+
+            try:
+                if isinstance(data, bytes):
+                    conn.send_data(self._h2_stream, data, end_stream=True)
+                    if data_to_send := conn.data_to_send():
+                        self.sock.sendall(data_to_send)
+                else:
+                    for chunk in data:
+                        conn.send_data(self._h2_stream, chunk, end_stream=False)
+                        if data_to_send := conn.data_to_send():
+                            self.sock.sendall(data_to_send)
+                    conn.end_stream(self._h2_stream)
+            except TypeError:
+                raise TypeError(
+                    "`data` should be str, bytes, iterable, or file. got %r"
+                    % type(data)
+                )
+
+    def set_tunnel(
+        self,
+        host: str,
+        port: int | None = None,
+        headers: typing.Mapping[str, str] | None = None,
+        scheme: str = "http",
+    ) -> None:
+        raise NotImplementedError(
+            "HTTP/2 does not support setting up a tunnel through a proxy"
+        )
+
+    def getresponse(  # type: ignore[override]
+        self,
+    ) -> HTTP2Response:
+        status = None
+        data = bytearray()
+        with self._h2_conn as conn:
+            end_stream = False
+            while not end_stream:
+                # TODO: Arbitrary read value.
+                if received_data := self.sock.recv(65535):
+                    events = conn.receive_data(received_data)
+                    for event in events:
+                        if isinstance(event, h2.events.ResponseReceived):
+                            headers = HTTPHeaderDict()
+                            for header, value in event.headers:
+                                if header == b":status":
+                                    status = int(value.decode())
+                                else:
+                                    headers.add(
+                                        header.decode("ascii"), value.decode("ascii")
+                                    )
+
+                        elif isinstance(event, h2.events.DataReceived):
+                            data += event.data
+                            conn.acknowledge_received_data(
+                                event.flow_controlled_length, event.stream_id
+                            )
+
+                        elif isinstance(event, h2.events.StreamEnded):
+                            end_stream = True
+
+                if data_to_send := conn.data_to_send():
+                    self.sock.sendall(data_to_send)
+
+        assert status is not None
+        return HTTP2Response(
+            status=status,
+            headers=headers,
+            request_url=self._request_url,
+            data=bytes(data),
+        )
+
+    def request(  # type: ignore[override]
+        self,
+        method: str,
+        url: str,
+        body: _TYPE_BODY | None = None,
+        headers: typing.Mapping[str, str] | None = None,
+        *,
+        preload_content: bool = True,
+        decode_content: bool = True,
+        enforce_content_length: bool = True,
+        **kwargs: typing.Any,
+    ) -> None:
+        """Send an HTTP/2 request"""
+        if "chunked" in kwargs:
+            # TODO this is often present from upstream.
+            # raise NotImplementedError("`chunked` isn't supported with HTTP/2")
+            pass
+
+        if self.sock is not None:
+            self.sock.settimeout(self.timeout)
+
+        self.putrequest(method, url)
+
+        headers = headers or {}
+        for k, v in headers.items():
+            if k.lower() == "transfer-encoding" and v == "chunked":
+                continue
+            else:
+                self.putheader(k, v)
+
+        if b"user-agent" not in dict(self._headers):
+            self.putheader(b"user-agent", _get_default_user_agent())
+
+        if body:
+            self.endheaders(message_body=body)
+            self.send(body)
+        else:
+            self.endheaders()
+
+    def close(self) -> None:
+        with self._h2_conn as conn:
+            try:
+                conn.close_connection()
+                if data := conn.data_to_send():
+                    self.sock.sendall(data)
+            except Exception:
+                pass
+
+        # Reset all our HTTP/2 connection state.
+        self._h2_conn = self._new_h2_conn()
+        self._h2_stream = None
+        self._headers = []
+
+        super().close()
+
+
+class HTTP2Response(BaseHTTPResponse):
+    # TODO: This is a woefully incomplete response object, but works for non-streaming.
+    def __init__(
+        self,
+        status: int,
+        headers: HTTPHeaderDict,
+        request_url: str,
+        data: bytes,
+        decode_content: bool = False,  # TODO: support decoding
+    ) -> None:
+        super().__init__(
+            status=status,
+            headers=headers,
+            # Following CPython, we map HTTP versions to major * 10 + minor integers
+            version=20,
+            version_string="HTTP/2",
+            # No reason phrase in HTTP/2
+            reason=None,
+            decode_content=decode_content,
+            request_url=request_url,
+        )
+        self._data = data
+        self.length_remaining = 0
+
+    @property
+    def data(self) -> bytes:
+        return self._data
+
+    def get_redirect_location(self) -> None:
+        return None
+
+    def close(self) -> None:
+        pass
diff --git a/.venv/lib/python3.13/site-packages/urllib3/http2/probe.py b/.venv/lib/python3.13/site-packages/urllib3/http2/probe.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ea900764f0885eafaac9454523417d86e33df2d
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/http2/probe.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import threading
+
+
+class _HTTP2ProbeCache:
+    __slots__ = (
+        "_lock",
+        "_cache_locks",
+        "_cache_values",
+    )
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._cache_locks: dict[tuple[str, int], threading.RLock] = {}
+        self._cache_values: dict[tuple[str, int], bool | None] = {}
+
+    def acquire_and_get(self, host: str, port: int) -> bool | None:
+        # By the end of this block we know that
+        # _cache_[values,locks] is available.
+        value = None
+        with self._lock:
+            key = (host, port)
+            try:
+                value = self._cache_values[key]
+                # If it's a known value we return right away.
+                if value is not None:
+                    return value
+            except KeyError:
+                self._cache_locks[key] = threading.RLock()
+                self._cache_values[key] = None
+
+        # If the value is unknown, we acquire the lock to signal
+        # to the requesting thread that the probe is in progress
+        # or that the current thread needs to return their findings.
+        key_lock = self._cache_locks[key]
+        key_lock.acquire()
+        try:
+            # If the by the time we get the lock the value has been
+            # updated we want to return the updated value.
+            value = self._cache_values[key]
+
+        # In case an exception like KeyboardInterrupt is raised here.
+        except BaseException as e:  # Defensive:
+            assert not isinstance(e, KeyError)  # KeyError shouldn't be possible.
+            key_lock.release()
+            raise
+
+        return value
+
+    def set_and_release(
+        self, host: str, port: int, supports_http2: bool | None
+    ) -> None:
+        key = (host, port)
+        key_lock = self._cache_locks[key]
+        with key_lock:  # Uses an RLock, so can be locked again from same thread.
+            if supports_http2 is None and self._cache_values[key] is not None:
+                raise ValueError(
+                    "Cannot reset HTTP/2 support for origin after value has been set."
+                )  # Defensive: not expected in normal usage
+
+        self._cache_values[key] = supports_http2
+        key_lock.release()
+
+    def _values(self) -> dict[tuple[str, int], bool | None]:
+        """This function is for testing purposes only. Gets the current state of the probe cache"""
+        with self._lock:
+            return {k: v for k, v in self._cache_values.items()}
+
+    def _reset(self) -> None:
+        """This function is for testing purposes only. Reset the cache values"""
+        with self._lock:
+            self._cache_locks = {}
+            self._cache_values = {}
+
+
+_HTTP2_PROBE_CACHE = _HTTP2ProbeCache()
+
+set_and_release = _HTTP2_PROBE_CACHE.set_and_release
+acquire_and_get = _HTTP2_PROBE_CACHE.acquire_and_get
+_values = _HTTP2_PROBE_CACHE._values
+_reset = _HTTP2_PROBE_CACHE._reset
+
+__all__ = [
+    "set_and_release",
+    "acquire_and_get",
+]
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__init__.py b/.venv/lib/python3.13/site-packages/urllib3/util/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..534126033c083203649022fa9b753a433f005556
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/__init__.py
@@ -0,0 +1,42 @@
+# For backwards compatibility, provide imports that used to be here.
+from __future__ import annotations
+
+from .connection import is_connection_dropped
+from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers
+from .response import is_fp_closed
+from .retry import Retry
+from .ssl_ import (
+    ALPN_PROTOCOLS,
+    IS_PYOPENSSL,
+    SSLContext,
+    assert_fingerprint,
+    create_urllib3_context,
+    resolve_cert_reqs,
+    resolve_ssl_version,
+    ssl_wrap_socket,
+)
+from .timeout import Timeout
+from .url import Url, parse_url
+from .wait import wait_for_read, wait_for_write
+
+__all__ = (
+    "IS_PYOPENSSL",
+    "SSLContext",
+    "ALPN_PROTOCOLS",
+    "Retry",
+    "Timeout",
+    "Url",
+    "assert_fingerprint",
+    "create_urllib3_context",
+    "is_connection_dropped",
+    "is_fp_closed",
+    "parse_url",
+    "make_headers",
+    "resolve_cert_reqs",
+    "resolve_ssl_version",
+    "ssl_wrap_socket",
+    "wait_for_read",
+    "wait_for_write",
+    "SKIP_HEADER",
+    "SKIPPABLE_HEADERS",
+)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a8d2a208dee607aae3e02d23648f52d7f60273c
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/__init__.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/connection.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/connection.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..031e0a4d19cf3a39d3bcbe3cdf945cff5897fe7e
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/connection.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/proxy.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/proxy.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f5b7fda8e7b98ffeea530c6a2f53ba3ae18892c
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/proxy.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/request.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/request.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..587132c16e4714985e3454d523783216d49a15eb
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/request.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/response.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/response.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a93e4fc792dc904476376b68803ec55a5522999
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/response.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/retry.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/retry.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e1351b8617996077146fe2444b68e2693a1152a
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/retry.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4604e8251dbcdec7934e89f6a55bc1d957c5f14
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_match_hostname.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_match_hostname.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b184b54f4ae0143e7de8b2b22a47a3bb50a63ad5
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssl_match_hostname.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssltransport.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssltransport.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd3de90d06afc5f5b121114f9cf177ab587b7208
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/ssltransport.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/timeout.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/timeout.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f3fd018b595fcf77def97503f6c3f145f32bc9f5
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/timeout.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/url.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/url.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78297b008a7400403d876e8007ac410464885e6d
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/url.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/util.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/util.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dfe8d673fd6e831da746a07ba21b885532001e1
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/util.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/wait.cpython-313.pyc b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/wait.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d1d8765c17173030fe5378bb4f5d5997dda76ec
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/urllib3/util/__pycache__/wait.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/connection.py b/.venv/lib/python3.13/site-packages/urllib3/util/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..f92519ee9124e91e5da7d60ccc3f274312ed3514
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/connection.py
@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import socket
+import typing
+
+from ..exceptions import LocationParseError
+from .timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT
+
+_TYPE_SOCKET_OPTIONS = list[tuple[int, int, typing.Union[int, bytes]]]
+
+if typing.TYPE_CHECKING:
+    from .._base_connection import BaseHTTPConnection
+
+
+def is_connection_dropped(conn: BaseHTTPConnection) -> bool:  # Platform-specific
+    """
+    Returns True if the connection is dropped and should be closed.
+    :param conn: :class:`urllib3.connection.HTTPConnection` object.
+    """
+    return not conn.is_connected
+
+
+# This function is copied from socket.py in the Python 2.7 standard
+# library test suite. Added to its signature is only `socket_options`.
+# One additional modification is that we avoid binding to IPv6 servers
+# discovered in DNS if the system doesn't have IPv6 functionality.
+def create_connection(
+    address: tuple[str, int],
+    timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+    source_address: tuple[str, int] | None = None,
+    socket_options: _TYPE_SOCKET_OPTIONS | None = None,
+) -> socket.socket:
+    """Connect to *address* and return the socket object.
+
+    Convenience function.  Connect to *address* (a 2-tuple ``(host,
+    port)``) and return the socket object.  Passing the optional
+    *timeout* parameter will set the timeout on the socket instance
+    before attempting to connect.  If no *timeout* is supplied, the
+    global default timeout setting returned by :func:`socket.getdefaulttimeout`
+    is used.  If *source_address* is set it must be a tuple of (host, port)
+    for the socket to bind as a source address before making the connection.
+    An host of '' or port 0 tells the OS to use the default.
+    """
+
+    host, port = address
+    if host.startswith("["):
+        host = host.strip("[]")
+    err = None
+
+    # Using the value from allowed_gai_family() in the context of getaddrinfo lets
+    # us select whether to work with IPv4 DNS records, IPv6 records, or both.
+    # The original create_connection function always returns all records.
+    family = allowed_gai_family()
+
+    try:
+        host.encode("idna")
+    except UnicodeError:
+        raise LocationParseError(f"'{host}', label empty or too long") from None
+
+    for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):
+        af, socktype, proto, canonname, sa = res
+        sock = None
+        try:
+            sock = socket.socket(af, socktype, proto)
+
+            # If provided, set socket level options before connecting.
+            _set_socket_options(sock, socket_options)
+
+            if timeout is not _DEFAULT_TIMEOUT:
+                sock.settimeout(timeout)
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sa)
+            # Break explicitly a reference cycle
+            err = None
+            return sock
+
+        except OSError as _:
+            err = _
+            if sock is not None:
+                sock.close()
+
+    if err is not None:
+        try:
+            raise err
+        finally:
+            # Break explicitly a reference cycle
+            err = None
+    else:
+        raise OSError("getaddrinfo returns an empty list")
+
+
+def _set_socket_options(
+    sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None
+) -> None:
+    if options is None:
+        return
+
+    for opt in options:
+        sock.setsockopt(*opt)
+
+
+def allowed_gai_family() -> socket.AddressFamily:
+    """This function is designed to work in the context of
+    getaddrinfo, where family=socket.AF_UNSPEC is the default and
+    will perform a DNS search for both IPv6 and IPv4 records."""
+
+    family = socket.AF_INET
+    if HAS_IPV6:
+        family = socket.AF_UNSPEC
+    return family
+
+
+def _has_ipv6(host: str) -> bool:
+    """Returns True if the system can bind an IPv6 address."""
+    sock = None
+    has_ipv6 = False
+
+    if socket.has_ipv6:
+        # has_ipv6 returns true if cPython was compiled with IPv6 support.
+        # It does not tell us if the system has IPv6 support enabled. To
+        # determine that we must bind to an IPv6 address.
+        # https://github.com/urllib3/urllib3/pull/611
+        # https://bugs.python.org/issue658327
+        try:
+            sock = socket.socket(socket.AF_INET6)
+            sock.bind((host, 0))
+            has_ipv6 = True
+        except Exception:
+            pass
+
+    if sock:
+        sock.close()
+    return has_ipv6
+
+
+HAS_IPV6 = _has_ipv6("::1")
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/proxy.py b/.venv/lib/python3.13/site-packages/urllib3/util/proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..908fc6621d0afbed16bde2c1957a5cf28d3a84d8
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/proxy.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import typing
+
+from .url import Url
+
+if typing.TYPE_CHECKING:
+    from ..connection import ProxyConfig
+
+
+def connection_requires_http_tunnel(
+    proxy_url: Url | None = None,
+    proxy_config: ProxyConfig | None = None,
+    destination_scheme: str | None = None,
+) -> bool:
+    """
+    Returns True if the connection requires an HTTP CONNECT through the proxy.
+
+    :param URL proxy_url:
+        URL of the proxy.
+    :param ProxyConfig proxy_config:
+        Proxy configuration from poolmanager.py
+    :param str destination_scheme:
+        The scheme of the destination. (i.e https, http, etc)
+    """
+    # If we're not using a proxy, no way to use a tunnel.
+    if proxy_url is None:
+        return False
+
+    # HTTP destinations never require tunneling, we always forward.
+    if destination_scheme == "http":
+        return False
+
+    # Support for forwarding with HTTPS proxies and HTTPS destinations.
+    if (
+        proxy_url.scheme == "https"
+        and proxy_config
+        and proxy_config.use_forwarding_for_https
+    ):
+        return False
+
+    # Otherwise always use a tunnel.
+    return True
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/request.py b/.venv/lib/python3.13/site-packages/urllib3/util/request.py
new file mode 100644
index 0000000000000000000000000000000000000000..23605c522b85f940f3af4db2e0561c48b0b0d269
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/request.py
@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import io
+import typing
+from base64 import b64encode
+from enum import Enum
+
+from ..exceptions import UnrewindableBodyError
+from .util import to_bytes
+
+if typing.TYPE_CHECKING:
+    from typing import Final
+
+# Pass as a value within ``headers`` to skip
+# emitting some HTTP headers that are added automatically.
+# The only headers that are supported are ``Accept-Encoding``,
+# ``Host``, and ``User-Agent``.
+SKIP_HEADER = "@@@SKIP_HEADER@@@"
+SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"])
+
+ACCEPT_ENCODING = "gzip,deflate"
+try:
+    try:
+        import brotlicffi as _unused_module_brotli  # type: ignore[import-not-found] # noqa: F401
+    except ImportError:
+        import brotli as _unused_module_brotli  # type: ignore[import-not-found] # noqa: F401
+except ImportError:
+    pass
+else:
+    ACCEPT_ENCODING += ",br"
+
+try:
+    from compression import (  # type: ignore[import-not-found] # noqa: F401
+        zstd as _unused_module_zstd,
+    )
+
+    ACCEPT_ENCODING += ",zstd"
+except ImportError:
+    try:
+        import zstandard as _unused_module_zstd  # noqa: F401
+
+        ACCEPT_ENCODING += ",zstd"
+    except ImportError:
+        pass
+
+
+class _TYPE_FAILEDTELL(Enum):
+    token = 0
+
+
+_FAILEDTELL: Final[_TYPE_FAILEDTELL] = _TYPE_FAILEDTELL.token
+
+_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL]
+
+# When sending a request with these methods we aren't expecting
+# a body so don't need to set an explicit 'Content-Length: 0'
+# The reason we do this in the negative instead of tracking methods
+# which 'should' have a body is because unknown methods should be
+# treated as if they were 'POST' which *does* expect a body.
+_METHODS_NOT_EXPECTING_BODY = {"GET", "HEAD", "DELETE", "TRACE", "OPTIONS", "CONNECT"}
+
+
+def make_headers(
+    keep_alive: bool | None = None,
+    accept_encoding: bool | list[str] | str | None = None,
+    user_agent: str | None = None,
+    basic_auth: str | None = None,
+    proxy_basic_auth: str | None = None,
+    disable_cache: bool | None = None,
+) -> dict[str, str]:
+    """
+    Shortcuts for generating request headers.
+
+    :param keep_alive:
+        If ``True``, adds 'connection: keep-alive' header.
+
+    :param accept_encoding:
+        Can be a boolean, list, or string.
+        ``True`` translates to 'gzip,deflate'.  If the dependencies for
+        Brotli (either the ``brotli`` or ``brotlicffi`` package) and/or Zstandard
+        (the ``zstandard`` package) algorithms are installed, then their encodings are
+        included in the string ('br' and 'zstd', respectively).
+        List will get joined by comma.
+        String will be used as provided.
+
+    :param user_agent:
+        String representing the user-agent you want, such as
+        "python-urllib3/0.6"
+
+    :param basic_auth:
+        Colon-separated username:password string for 'authorization: basic ...'
+        auth header.
+
+    :param proxy_basic_auth:
+        Colon-separated username:password string for 'proxy-authorization: basic ...'
+        auth header.
+
+    :param disable_cache:
+        If ``True``, adds 'cache-control: no-cache' header.
+
+    Example:
+
+    .. code-block:: python
+
+        import urllib3
+
+        print(urllib3.util.make_headers(keep_alive=True, user_agent="Batman/1.0"))
+        # {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
+        print(urllib3.util.make_headers(accept_encoding=True))
+        # {'accept-encoding': 'gzip,deflate'}
+    """
+    headers: dict[str, str] = {}
+    if accept_encoding:
+        if isinstance(accept_encoding, str):
+            pass
+        elif isinstance(accept_encoding, list):
+            accept_encoding = ",".join(accept_encoding)
+        else:
+            accept_encoding = ACCEPT_ENCODING
+        headers["accept-encoding"] = accept_encoding
+
+    if user_agent:
+        headers["user-agent"] = user_agent
+
+    if keep_alive:
+        headers["connection"] = "keep-alive"
+
+    if basic_auth:
+        headers["authorization"] = (
+            f"Basic {b64encode(basic_auth.encode('latin-1')).decode()}"
+        )
+
+    if proxy_basic_auth:
+        headers["proxy-authorization"] = (
+            f"Basic {b64encode(proxy_basic_auth.encode('latin-1')).decode()}"
+        )
+
+    if disable_cache:
+        headers["cache-control"] = "no-cache"
+
+    return headers
+
+
+def set_file_position(
+    body: typing.Any, pos: _TYPE_BODY_POSITION | None
+) -> _TYPE_BODY_POSITION | None:
+    """
+    If a position is provided, move file to that point.
+    Otherwise, we'll attempt to record a position for future use.
+    """
+    if pos is not None:
+        rewind_body(body, pos)
+    elif getattr(body, "tell", None) is not None:
+        try:
+            pos = body.tell()
+        except OSError:
+            # This differentiates from None, allowing us to catch
+            # a failed `tell()` later when trying to rewind the body.
+            pos = _FAILEDTELL
+
+    return pos
+
+
+def rewind_body(body: typing.IO[typing.AnyStr], body_pos: _TYPE_BODY_POSITION) -> None:
+    """
+    Attempt to rewind body to a certain position.
+    Primarily used for request redirects and retries.
+
+    :param body:
+        File-like object that supports seek.
+
+    :param int pos:
+        Position to seek to in file.
+    """
+    body_seek = getattr(body, "seek", None)
+    if body_seek is not None and isinstance(body_pos, int):
+        try:
+            body_seek(body_pos)
+        except OSError as e:
+            raise UnrewindableBodyError(
+                "An error occurred when rewinding request body for redirect/retry."
+            ) from e
+    elif body_pos is _FAILEDTELL:
+        raise UnrewindableBodyError(
+            "Unable to record file position for rewinding "
+            "request body during a redirect/retry."
+        )
+    else:
+        raise ValueError(
+            f"body_pos must be of type integer, instead it was {type(body_pos)}."
+        )
+
+
+class ChunksAndContentLength(typing.NamedTuple):
+    chunks: typing.Iterable[bytes] | None
+    content_length: int | None
+
+
+def body_to_chunks(
+    body: typing.Any | None, method: str, blocksize: int
+) -> ChunksAndContentLength:
+    """Takes the HTTP request method, body, and blocksize and
+    transforms them into an iterable of chunks to pass to
+    socket.sendall() and an optional 'Content-Length' header.
+
+    A 'Content-Length' of 'None' indicates the length of the body
+    can't be determined so should use 'Transfer-Encoding: chunked'
+    for framing instead.
+    """
+
+    chunks: typing.Iterable[bytes] | None
+    content_length: int | None
+
+    # No body, we need to make a recommendation on 'Content-Length'
+    # based on whether that request method is expected to have
+    # a body or not.
+    if body is None:
+        chunks = None
+        if method.upper() not in _METHODS_NOT_EXPECTING_BODY:
+            content_length = 0
+        else:
+            content_length = None
+
+    # Bytes or strings become bytes
+    elif isinstance(body, (str, bytes)):
+        chunks = (to_bytes(body),)
+        content_length = len(chunks[0])
+
+    # File-like object, TODO: use seek() and tell() for length?
+    elif hasattr(body, "read"):
+
+        def chunk_readable() -> typing.Iterable[bytes]:
+            nonlocal body, blocksize
+            encode = isinstance(body, io.TextIOBase)
+            while True:
+                datablock = body.read(blocksize)
+                if not datablock:
+                    break
+                if encode:
+                    datablock = datablock.encode("utf-8")
+                yield datablock
+
+        chunks = chunk_readable()
+        content_length = None
+
+    # Otherwise we need to start checking via duck-typing.
+    else:
+        try:
+            # Check if the body implements the buffer API.
+            mv = memoryview(body)
+        except TypeError:
+            try:
+                # Check if the body is an iterable
+                chunks = iter(body)
+                content_length = None
+            except TypeError:
+                raise TypeError(
+                    f"'body' must be a bytes-like object, file-like "
+                    f"object, or iterable. Instead was {body!r}"
+                ) from None
+        else:
+            # Since it implements the buffer API can be passed directly to socket.sendall()
+            chunks = (body,)
+            content_length = mv.nbytes
+
+    return ChunksAndContentLength(chunks=chunks, content_length=content_length)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/response.py b/.venv/lib/python3.13/site-packages/urllib3/util/response.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f4578696fa2e17a900c6890ec26d65e860b0b72
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/response.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import http.client as httplib
+from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect
+
+from ..exceptions import HeaderParsingError
+
+
+def is_fp_closed(obj: object) -> bool:
+    """
+    Checks whether a given file-like object is closed.
+
+    :param obj:
+        The file-like object to check.
+    """
+
+    try:
+        # Check `isclosed()` first, in case Python3 doesn't set `closed`.
+        # GH Issue #928
+        return obj.isclosed()  # type: ignore[no-any-return, attr-defined]
+    except AttributeError:
+        pass
+
+    try:
+        # Check via the official file-like-object way.
+        return obj.closed  # type: ignore[no-any-return, attr-defined]
+    except AttributeError:
+        pass
+
+    try:
+        # Check if the object is a container for another file-like object that
+        # gets released on exhaustion (e.g. HTTPResponse).
+        return obj.fp is None  # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+
+    raise ValueError("Unable to determine whether fp is closed.")
+
+
+def assert_header_parsing(headers: httplib.HTTPMessage) -> None:
+    """
+    Asserts whether all headers have been successfully parsed.
+    Extracts encountered errors from the result of parsing headers.
+
+    Only works on Python 3.
+
+    :param http.client.HTTPMessage headers: Headers to verify.
+
+    :raises urllib3.exceptions.HeaderParsingError:
+        If parsing errors are found.
+    """
+
+    # This will fail silently if we pass in the wrong kind of parameter.
+    # To make debugging easier add an explicit check.
+    if not isinstance(headers, httplib.HTTPMessage):
+        raise TypeError(f"expected httplib.Message, got {type(headers)}.")
+
+    unparsed_data = None
+
+    # get_payload is actually email.message.Message.get_payload;
+    # we're only interested in the result if it's not a multipart message
+    if not headers.is_multipart():
+        payload = headers.get_payload()
+
+        if isinstance(payload, (bytes, str)):
+            unparsed_data = payload
+
+    # httplib is assuming a response body is available
+    # when parsing headers even when httplib only sends
+    # header data to parse_headers() This results in
+    # defects on multipart responses in particular.
+    # See: https://github.com/urllib3/urllib3/issues/800
+
+    # So we ignore the following defects:
+    # - StartBoundaryNotFoundDefect:
+    #     The claimed start boundary was never found.
+    # - MultipartInvariantViolationDefect:
+    #     A message claimed to be a multipart but no subparts were found.
+    defects = [
+        defect
+        for defect in headers.defects
+        if not isinstance(
+            defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect)
+        )
+    ]
+
+    if defects or unparsed_data:
+        raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)
+
+
+def is_response_to_head(response: httplib.HTTPResponse) -> bool:
+    """
+    Checks whether the request of a response has been a HEAD-request.
+
+    :param http.client.HTTPResponse response:
+        Response to check if the originating request
+        used 'HEAD' as a method.
+    """
+    # FIXME: Can we do this somehow without accessing private httplib _method?
+    method_str = response._method  # type: str  # type: ignore[attr-defined]
+    return method_str.upper() == "HEAD"
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/retry.py b/.venv/lib/python3.13/site-packages/urllib3/util/retry.py
new file mode 100644
index 0000000000000000000000000000000000000000..0456cceba47b16ae6784458cc17eaa528a517ffa
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/retry.py
@@ -0,0 +1,533 @@
+from __future__ import annotations
+
+import email
+import logging
+import random
+import re
+import time
+import typing
+from itertools import takewhile
+from types import TracebackType
+
+from ..exceptions import (
+    ConnectTimeoutError,
+    InvalidHeader,
+    MaxRetryError,
+    ProtocolError,
+    ProxyError,
+    ReadTimeoutError,
+    ResponseError,
+)
+from .util import reraise
+
+if typing.TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from ..connectionpool import ConnectionPool
+    from ..response import BaseHTTPResponse
+
+log = logging.getLogger(__name__)
+
+
+# Data structure for representing the metadata of requests that result in a retry.
+class RequestHistory(typing.NamedTuple):
+    method: str | None
+    url: str | None
+    error: Exception | None
+    status: int | None
+    redirect_location: str | None
+
+
+class Retry:
+    """Retry configuration.
+
+    Each retry attempt will create a new Retry object with updated values, so
+    they can be safely reused.
+
+    Retries can be defined as a default for a pool:
+
+    .. code-block:: python
+
+        retries = Retry(connect=5, read=2, redirect=5)
+        http = PoolManager(retries=retries)
+        response = http.request("GET", "https://example.com/")
+
+    Or per-request (which overrides the default for the pool):
+
+    .. code-block:: python
+
+        response = http.request("GET", "https://example.com/", retries=Retry(10))
+
+    Retries can be disabled by passing ``False``:
+
+    .. code-block:: python
+
+        response = http.request("GET", "https://example.com/", retries=False)
+
+    Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless
+    retries are disabled, in which case the causing exception will be raised.
+
+    :param int total:
+        Total number of retries to allow. Takes precedence over other counts.
+
+        Set to ``None`` to remove this constraint and fall back on other
+        counts.
+
+        Set to ``0`` to fail on the first retry.
+
+        Set to ``False`` to disable and imply ``raise_on_redirect=False``.
+
+    :param int connect:
+        How many connection-related errors to retry on.
+
+        These are errors raised before the request is sent to the remote server,
+        which we assume has not triggered the server to process the request.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param int read:
+        How many times to retry on read errors.
+
+        These errors are raised after the request was sent to the server, so the
+        request may have side-effects.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param int redirect:
+        How many redirects to perform. Limit this to avoid infinite redirect
+        loops.
+
+        A redirect is a HTTP response with a status code 301, 302, 303, 307 or
+        308.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+        Set to ``False`` to disable and imply ``raise_on_redirect=False``.
+
+    :param int status:
+        How many times to retry on bad status codes.
+
+        These are retries made on responses, where status code matches
+        ``status_forcelist``.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+    :param int other:
+        How many times to retry on other errors.
+
+        Other errors are errors that are not connect, read, redirect or status errors.
+        These errors might be raised after the request was sent to the server, so the
+        request might have side-effects.
+
+        Set to ``0`` to fail on the first retry of this type.
+
+        If ``total`` is not set, it's a good idea to set this to 0 to account
+        for unexpected edge cases and avoid infinite retry loops.
+
+    :param Collection allowed_methods:
+        Set of uppercased HTTP method verbs that we should retry on.
+
+        By default, we only retry on methods which are considered to be
+        idempotent (multiple requests with the same parameters end with the
+        same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`.
+
+        Set to a ``None`` value to retry on any verb.
+
+    :param Collection status_forcelist:
+        A set of integer HTTP status codes that we should force a retry on.
+        A retry is initiated if the request method is in ``allowed_methods``
+        and the response status code is in ``status_forcelist``.
+
+        By default, this is disabled with ``None``.
+
+    :param float backoff_factor:
+        A backoff factor to apply between attempts after the second try
+        (most errors are resolved immediately by a second try without a
+        delay). urllib3 will sleep for::
+
+            {backoff factor} * (2 ** ({number of previous retries}))
+
+        seconds. If `backoff_jitter` is non-zero, this sleep is extended by::
+
+            random.uniform(0, {backoff jitter})
+
+        seconds. For example, if the backoff_factor is 0.1, then :func:`Retry.sleep` will
+        sleep for [0.0s, 0.2s, 0.4s, 0.8s, ...] between retries. No backoff will ever
+        be longer than `backoff_max`.
+
+        By default, backoff is disabled (factor set to 0).
+
+    :param bool raise_on_redirect: Whether, if the number of redirects is
+        exhausted, to raise a MaxRetryError, or to return a response with a
+        response code in the 3xx range.
+
+    :param bool raise_on_status: Similar meaning to ``raise_on_redirect``:
+        whether we should raise an exception, or return a response,
+        if status falls in ``status_forcelist`` range and retries have
+        been exhausted.
+
+    :param tuple history: The history of the request encountered during
+        each call to :meth:`~Retry.increment`. The list is in the order
+        the requests occurred. Each list item is of class :class:`RequestHistory`.
+
+    :param bool respect_retry_after_header:
+        Whether to respect Retry-After header on status codes defined as
+        :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.
+
+    :param Collection remove_headers_on_redirect:
+        Sequence of headers to remove from the request when a response
+        indicating a redirect is returned before firing off the redirected
+        request.
+    """
+
+    #: Default methods to be used for ``allowed_methods``
+    DEFAULT_ALLOWED_METHODS = frozenset(
+        ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+    )
+
+    #: Default status codes to be used for ``status_forcelist``
+    RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])
+
+    #: Default headers to be used for ``remove_headers_on_redirect``
+    DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset(
+        ["Cookie", "Authorization", "Proxy-Authorization"]
+    )
+
+    #: Default maximum backoff time.
+    DEFAULT_BACKOFF_MAX = 120
+
+    # Backward compatibility; assigned outside of the class.
+    DEFAULT: typing.ClassVar[Retry]
+
+    def __init__(
+        self,
+        total: bool | int | None = 10,
+        connect: int | None = None,
+        read: int | None = None,
+        redirect: bool | int | None = None,
+        status: int | None = None,
+        other: int | None = None,
+        allowed_methods: typing.Collection[str] | None = DEFAULT_ALLOWED_METHODS,
+        status_forcelist: typing.Collection[int] | None = None,
+        backoff_factor: float = 0,
+        backoff_max: float = DEFAULT_BACKOFF_MAX,
+        raise_on_redirect: bool = True,
+        raise_on_status: bool = True,
+        history: tuple[RequestHistory, ...] | None = None,
+        respect_retry_after_header: bool = True,
+        remove_headers_on_redirect: typing.Collection[
+            str
+        ] = DEFAULT_REMOVE_HEADERS_ON_REDIRECT,
+        backoff_jitter: float = 0.0,
+    ) -> None:
+        self.total = total
+        self.connect = connect
+        self.read = read
+        self.status = status
+        self.other = other
+
+        if redirect is False or total is False:
+            redirect = 0
+            raise_on_redirect = False
+
+        self.redirect = redirect
+        self.status_forcelist = status_forcelist or set()
+        self.allowed_methods = allowed_methods
+        self.backoff_factor = backoff_factor
+        self.backoff_max = backoff_max
+        self.raise_on_redirect = raise_on_redirect
+        self.raise_on_status = raise_on_status
+        self.history = history or ()
+        self.respect_retry_after_header = respect_retry_after_header
+        self.remove_headers_on_redirect = frozenset(
+            h.lower() for h in remove_headers_on_redirect
+        )
+        self.backoff_jitter = backoff_jitter
+
+    def new(self, **kw: typing.Any) -> Self:
+        params = dict(
+            total=self.total,
+            connect=self.connect,
+            read=self.read,
+            redirect=self.redirect,
+            status=self.status,
+            other=self.other,
+            allowed_methods=self.allowed_methods,
+            status_forcelist=self.status_forcelist,
+            backoff_factor=self.backoff_factor,
+            backoff_max=self.backoff_max,
+            raise_on_redirect=self.raise_on_redirect,
+            raise_on_status=self.raise_on_status,
+            history=self.history,
+            remove_headers_on_redirect=self.remove_headers_on_redirect,
+            respect_retry_after_header=self.respect_retry_after_header,
+            backoff_jitter=self.backoff_jitter,
+        )
+
+        params.update(kw)
+        return type(self)(**params)  # type: ignore[arg-type]
+
+    @classmethod
+    def from_int(
+        cls,
+        retries: Retry | bool | int | None,
+        redirect: bool | int | None = True,
+        default: Retry | bool | int | None = None,
+    ) -> Retry:
+        """Backwards-compatibility for the old retries format."""
+        if retries is None:
+            retries = default if default is not None else cls.DEFAULT
+
+        if isinstance(retries, Retry):
+            return retries
+
+        redirect = bool(redirect) and None
+        new_retries = cls(retries, redirect=redirect)
+        log.debug("Converted retries value: %r -> %r", retries, new_retries)
+        return new_retries
+
+    def get_backoff_time(self) -> float:
+        """Formula for computing the current backoff
+
+        :rtype: float
+        """
+        # We want to consider only the last consecutive errors sequence (Ignore redirects).
+        consecutive_errors_len = len(
+            list(
+                takewhile(lambda x: x.redirect_location is None, reversed(self.history))
+            )
+        )
+        if consecutive_errors_len <= 1:
+            return 0
+
+        backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))
+        if self.backoff_jitter != 0.0:
+            backoff_value += random.random() * self.backoff_jitter
+        return float(max(0, min(self.backoff_max, backoff_value)))
+
+    def parse_retry_after(self, retry_after: str) -> float:
+        seconds: float
+        # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4
+        if re.match(r"^\s*[0-9]+\s*$", retry_after):
+            seconds = int(retry_after)
+        else:
+            retry_date_tuple = email.utils.parsedate_tz(retry_after)
+            if retry_date_tuple is None:
+                raise InvalidHeader(f"Invalid Retry-After header: {retry_after}")
+
+            retry_date = email.utils.mktime_tz(retry_date_tuple)
+            seconds = retry_date - time.time()
+
+        seconds = max(seconds, 0)
+
+        return seconds
+
+    def get_retry_after(self, response: BaseHTTPResponse) -> float | None:
+        """Get the value of Retry-After in seconds."""
+
+        retry_after = response.headers.get("Retry-After")
+
+        if retry_after is None:
+            return None
+
+        return self.parse_retry_after(retry_after)
+
+    def sleep_for_retry(self, response: BaseHTTPResponse) -> bool:
+        retry_after = self.get_retry_after(response)
+        if retry_after:
+            time.sleep(retry_after)
+            return True
+
+        return False
+
+    def _sleep_backoff(self) -> None:
+        backoff = self.get_backoff_time()
+        if backoff <= 0:
+            return
+        time.sleep(backoff)
+
+    def sleep(self, response: BaseHTTPResponse | None = None) -> None:
+        """Sleep between retry attempts.
+
+        This method will respect a server's ``Retry-After`` response header
+        and sleep the duration of the time requested. If that is not present, it
+        will use an exponential backoff. By default, the backoff factor is 0 and
+        this method will return immediately.
+        """
+
+        if self.respect_retry_after_header and response:
+            slept = self.sleep_for_retry(response)
+            if slept:
+                return
+
+        self._sleep_backoff()
+
+    def _is_connection_error(self, err: Exception) -> bool:
+        """Errors when we're fairly sure that the server did not receive the
+        request, so it should be safe to retry.
+        """
+        if isinstance(err, ProxyError):
+            err = err.original_error
+        return isinstance(err, ConnectTimeoutError)
+
+    def _is_read_error(self, err: Exception) -> bool:
+        """Errors that occur after the request has been started, so we should
+        assume that the server began processing it.
+        """
+        return isinstance(err, (ReadTimeoutError, ProtocolError))
+
+    def _is_method_retryable(self, method: str) -> bool:
+        """Checks if a given HTTP method should be retried upon, depending if
+        it is included in the allowed_methods
+        """
+        if self.allowed_methods and method.upper() not in self.allowed_methods:
+            return False
+        return True
+
+    def is_retry(
+        self, method: str, status_code: int, has_retry_after: bool = False
+    ) -> bool:
+        """Is this method/status code retryable? (Based on allowlists and control
+        variables such as the number of total retries to allow, whether to
+        respect the Retry-After header, whether this header is present, and
+        whether the returned status code is on the list of status codes to
+        be retried upon on the presence of the aforementioned header)
+        """
+        if not self._is_method_retryable(method):
+            return False
+
+        if self.status_forcelist and status_code in self.status_forcelist:
+            return True
+
+        return bool(
+            self.total
+            and self.respect_retry_after_header
+            and has_retry_after
+            and (status_code in self.RETRY_AFTER_STATUS_CODES)
+        )
+
+    def is_exhausted(self) -> bool:
+        """Are we out of retries?"""
+        retry_counts = [
+            x
+            for x in (
+                self.total,
+                self.connect,
+                self.read,
+                self.redirect,
+                self.status,
+                self.other,
+            )
+            if x
+        ]
+        if not retry_counts:
+            return False
+
+        return min(retry_counts) < 0
+
+    def increment(
+        self,
+        method: str | None = None,
+        url: str | None = None,
+        response: BaseHTTPResponse | None = None,
+        error: Exception | None = None,
+        _pool: ConnectionPool | None = None,
+        _stacktrace: TracebackType | None = None,
+    ) -> Self:
+        """Return a new Retry object with incremented retry counters.
+
+        :param response: A response object, or None, if the server did not
+            return a response.
+        :type response: :class:`~urllib3.response.BaseHTTPResponse`
+        :param Exception error: An error encountered during the request, or
+            None if the response was received successfully.
+
+        :return: A new ``Retry`` object.
+        """
+        if self.total is False and error:
+            # Disabled, indicate to re-raise the error.
+            raise reraise(type(error), error, _stacktrace)
+
+        total = self.total
+        if total is not None:
+            total -= 1
+
+        connect = self.connect
+        read = self.read
+        redirect = self.redirect
+        status_count = self.status
+        other = self.other
+        cause = "unknown"
+        status = None
+        redirect_location = None
+
+        if error and self._is_connection_error(error):
+            # Connect retry?
+            if connect is False:
+                raise reraise(type(error), error, _stacktrace)
+            elif connect is not None:
+                connect -= 1
+
+        elif error and self._is_read_error(error):
+            # Read retry?
+            if read is False or method is None or not self._is_method_retryable(method):
+                raise reraise(type(error), error, _stacktrace)
+            elif read is not None:
+                read -= 1
+
+        elif error:
+            # Other retry?
+            if other is not None:
+                other -= 1
+
+        elif response and response.get_redirect_location():
+            # Redirect retry?
+            if redirect is not None:
+                redirect -= 1
+            cause = "too many redirects"
+            response_redirect_location = response.get_redirect_location()
+            if response_redirect_location:
+                redirect_location = response_redirect_location
+            status = response.status
+
+        else:
+            # Incrementing because of a server error like a 500 in
+            # status_forcelist and the given method is in the allowed_methods
+            cause = ResponseError.GENERIC_ERROR
+            if response and response.status:
+                if status_count is not None:
+                    status_count -= 1
+                cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status)
+                status = response.status
+
+        history = self.history + (
+            RequestHistory(method, url, error, status, redirect_location),
+        )
+
+        new_retry = self.new(
+            total=total,
+            connect=connect,
+            read=read,
+            redirect=redirect,
+            status=status_count,
+            other=other,
+            history=history,
+        )
+
+        if new_retry.is_exhausted():
+            reason = error or ResponseError(cause)
+            raise MaxRetryError(_pool, url, reason) from reason  # type: ignore[arg-type]
+
+        log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)
+
+        return new_retry
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(total={self.total}, connect={self.connect}, "
+            f"read={self.read}, redirect={self.redirect}, status={self.status})"
+        )
+
+
+# For backwards compatibility (equivalent to pre-v1.9):
+Retry.DEFAULT = Retry(3)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/ssl_.py b/.venv/lib/python3.13/site-packages/urllib3/util/ssl_.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2cc1aa7bb5bb934099bfb44c935b8eccc73f4e0
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/ssl_.py
@@ -0,0 +1,524 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+import socket
+import sys
+import typing
+import warnings
+from binascii import unhexlify
+
+from ..exceptions import ProxySchemeUnsupported, SSLError
+from .url import _BRACELESS_IPV6_ADDRZ_RE, _IPV4_RE
+
+SSLContext = None
+SSLTransport = None
+HAS_NEVER_CHECK_COMMON_NAME = False
+IS_PYOPENSSL = False
+ALPN_PROTOCOLS = ["http/1.1"]
+
+_TYPE_VERSION_INFO = tuple[int, int, int, str, int]
+
+# Maps the length of a digest to a possible hash function producing this digest
+HASHFUNC_MAP = {
+    length: getattr(hashlib, algorithm, None)
+    for length, algorithm in ((32, "md5"), (40, "sha1"), (64, "sha256"))
+}
+
+
+def _is_bpo_43522_fixed(
+    implementation_name: str,
+    version_info: _TYPE_VERSION_INFO,
+    pypy_version_info: _TYPE_VERSION_INFO | None,
+) -> bool:
+    """Return True for CPython 3.9.3+ or 3.10+ and PyPy 7.3.8+ where
+    setting SSLContext.hostname_checks_common_name to False works.
+
+    Outside of CPython and PyPy we don't know which implementations work
+    or not so we conservatively use our hostname matching as we know that works
+    on all implementations.
+
+    https://github.com/urllib3/urllib3/issues/2192#issuecomment-821832963
+    https://foss.heptapod.net/pypy/pypy/-/issues/3539
+    """
+    if implementation_name == "pypy":
+        # https://foss.heptapod.net/pypy/pypy/-/issues/3129
+        return pypy_version_info >= (7, 3, 8)  # type: ignore[operator]
+    elif implementation_name == "cpython":
+        major_minor = version_info[:2]
+        micro = version_info[2]
+        return (major_minor == (3, 9) and micro >= 3) or major_minor >= (3, 10)
+    else:  # Defensive:
+        return False
+
+
+def _is_has_never_check_common_name_reliable(
+    openssl_version: str,
+    openssl_version_number: int,
+    implementation_name: str,
+    version_info: _TYPE_VERSION_INFO,
+    pypy_version_info: _TYPE_VERSION_INFO | None,
+) -> bool:
+    # As of May 2023, all released versions of LibreSSL fail to reject certificates with
+    # only common names, see https://github.com/urllib3/urllib3/pull/3024
+    is_openssl = openssl_version.startswith("OpenSSL ")
+    # Before fixing OpenSSL issue #14579, the SSL_new() API was not copying hostflags
+    # like X509_CHECK_FLAG_NEVER_CHECK_SUBJECT, which tripped up CPython.
+    # https://github.com/openssl/openssl/issues/14579
+    # This was released in OpenSSL 1.1.1l+ (>=0x101010cf)
+    is_openssl_issue_14579_fixed = openssl_version_number >= 0x101010CF
+
+    return is_openssl and (
+        is_openssl_issue_14579_fixed
+        or _is_bpo_43522_fixed(implementation_name, version_info, pypy_version_info)
+    )
+
+
+if typing.TYPE_CHECKING:
+    from ssl import VerifyMode
+    from typing import TypedDict
+
+    from .ssltransport import SSLTransport as SSLTransportType
+
+    class _TYPE_PEER_CERT_RET_DICT(TypedDict, total=False):
+        subjectAltName: tuple[tuple[str, str], ...]
+        subject: tuple[tuple[tuple[str, str], ...], ...]
+        serialNumber: str
+
+
+# Mapping from 'ssl.PROTOCOL_TLSX' to 'TLSVersion.X'
+_SSL_VERSION_TO_TLS_VERSION: dict[int, int] = {}
+
+try:  # Do we have ssl at all?
+    import ssl
+    from ssl import (  # type: ignore[assignment]
+        CERT_REQUIRED,
+        HAS_NEVER_CHECK_COMMON_NAME,
+        OP_NO_COMPRESSION,
+        OP_NO_TICKET,
+        OPENSSL_VERSION,
+        OPENSSL_VERSION_NUMBER,
+        PROTOCOL_TLS,
+        PROTOCOL_TLS_CLIENT,
+        VERIFY_X509_STRICT,
+        OP_NO_SSLv2,
+        OP_NO_SSLv3,
+        SSLContext,
+        TLSVersion,
+    )
+
+    PROTOCOL_SSLv23 = PROTOCOL_TLS
+
+    # Needed for Python 3.9 which does not define this
+    VERIFY_X509_PARTIAL_CHAIN = getattr(ssl, "VERIFY_X509_PARTIAL_CHAIN", 0x80000)
+
+    # Setting SSLContext.hostname_checks_common_name = False didn't work before CPython
+    # 3.9.3, and 3.10 (but OK on PyPy) or OpenSSL 1.1.1l+
+    if HAS_NEVER_CHECK_COMMON_NAME and not _is_has_never_check_common_name_reliable(
+        OPENSSL_VERSION,
+        OPENSSL_VERSION_NUMBER,
+        sys.implementation.name,
+        sys.version_info,
+        sys.pypy_version_info if sys.implementation.name == "pypy" else None,  # type: ignore[attr-defined]
+    ):  # Defensive: for Python < 3.9.3
+        HAS_NEVER_CHECK_COMMON_NAME = False
+
+    # Need to be careful here in case old TLS versions get
+    # removed in future 'ssl' module implementations.
+    for attr in ("TLSv1", "TLSv1_1", "TLSv1_2"):
+        try:
+            _SSL_VERSION_TO_TLS_VERSION[getattr(ssl, f"PROTOCOL_{attr}")] = getattr(
+                TLSVersion, attr
+            )
+        except AttributeError:  # Defensive:
+            continue
+
+    from .ssltransport import SSLTransport  # type: ignore[assignment]
+except ImportError:
+    OP_NO_COMPRESSION = 0x20000  # type: ignore[assignment]
+    OP_NO_TICKET = 0x4000  # type: ignore[assignment]
+    OP_NO_SSLv2 = 0x1000000  # type: ignore[assignment]
+    OP_NO_SSLv3 = 0x2000000  # type: ignore[assignment]
+    PROTOCOL_SSLv23 = PROTOCOL_TLS = 2  # type: ignore[assignment]
+    PROTOCOL_TLS_CLIENT = 16  # type: ignore[assignment]
+    VERIFY_X509_PARTIAL_CHAIN = 0x80000
+    VERIFY_X509_STRICT = 0x20  # type: ignore[assignment]
+
+
+_TYPE_PEER_CERT_RET = typing.Union["_TYPE_PEER_CERT_RET_DICT", bytes, None]
+
+
+def assert_fingerprint(cert: bytes | None, fingerprint: str) -> None:
+    """
+    Checks if given fingerprint matches the supplied certificate.
+
+    :param cert:
+        Certificate as bytes object.
+    :param fingerprint:
+        Fingerprint as string of hexdigits, can be interspersed by colons.
+    """
+
+    if cert is None:
+        raise SSLError("No certificate for the peer.")
+
+    fingerprint = fingerprint.replace(":", "").lower()
+    digest_length = len(fingerprint)
+    if digest_length not in HASHFUNC_MAP:
+        raise SSLError(f"Fingerprint of invalid length: {fingerprint}")
+    hashfunc = HASHFUNC_MAP.get(digest_length)
+    if hashfunc is None:
+        raise SSLError(
+            f"Hash function implementation unavailable for fingerprint length: {digest_length}"
+        )
+
+    # We need encode() here for py32; works on py2 and p33.
+    fingerprint_bytes = unhexlify(fingerprint.encode())
+
+    cert_digest = hashfunc(cert).digest()
+
+    if not hmac.compare_digest(cert_digest, fingerprint_bytes):
+        raise SSLError(
+            f'Fingerprints did not match. Expected "{fingerprint}", got "{cert_digest.hex()}"'
+        )
+
+
+def resolve_cert_reqs(candidate: None | int | str) -> VerifyMode:
+    """
+    Resolves the argument to a numeric constant, which can be passed to
+    the wrap_socket function/method from the ssl module.
+    Defaults to :data:`ssl.CERT_REQUIRED`.
+    If given a string it is assumed to be the name of the constant in the
+    :mod:`ssl` module or its abbreviation.
+    (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
+    If it's neither `None` nor a string we assume it is already the numeric
+    constant which can directly be passed to wrap_socket.
+    """
+    if candidate is None:
+        return CERT_REQUIRED
+
+    if isinstance(candidate, str):
+        res = getattr(ssl, candidate, None)
+        if res is None:
+            res = getattr(ssl, "CERT_" + candidate)
+        return res  # type: ignore[no-any-return]
+
+    return candidate  # type: ignore[return-value]
+
+
+def resolve_ssl_version(candidate: None | int | str) -> int:
+    """
+    like resolve_cert_reqs
+    """
+    if candidate is None:
+        return PROTOCOL_TLS
+
+    if isinstance(candidate, str):
+        res = getattr(ssl, candidate, None)
+        if res is None:
+            res = getattr(ssl, "PROTOCOL_" + candidate)
+        return typing.cast(int, res)
+
+    return candidate
+
+
+def create_urllib3_context(
+    ssl_version: int | None = None,
+    cert_reqs: int | None = None,
+    options: int | None = None,
+    ciphers: str | None = None,
+    ssl_minimum_version: int | None = None,
+    ssl_maximum_version: int | None = None,
+    verify_flags: int | None = None,
+) -> ssl.SSLContext:
+    """Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3.
+
+    :param ssl_version:
+        The desired protocol version to use. This will default to
+        PROTOCOL_SSLv23 which will negotiate the highest protocol that both
+        the server and your installation of OpenSSL support.
+
+        This parameter is deprecated instead use 'ssl_minimum_version'.
+    :param ssl_minimum_version:
+        The minimum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.
+    :param ssl_maximum_version:
+        The maximum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.
+        Not recommended to set to anything other than 'ssl.TLSVersion.MAXIMUM_SUPPORTED' which is the
+        default value.
+    :param cert_reqs:
+        Whether to require the certificate verification. This defaults to
+        ``ssl.CERT_REQUIRED``.
+    :param options:
+        Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
+        ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``.
+    :param ciphers:
+        Which cipher suites to allow the server to select. Defaults to either system configured
+        ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers.
+    :param verify_flags:
+        The flags for certificate verification operations. These default to
+        ``ssl.VERIFY_X509_PARTIAL_CHAIN`` and ``ssl.VERIFY_X509_STRICT`` for Python 3.13+.
+    :returns:
+        Constructed SSLContext object with specified options
+    :rtype: SSLContext
+    """
+    if SSLContext is None:
+        raise TypeError("Can't create an SSLContext object without an ssl module")
+
+    # This means 'ssl_version' was specified as an exact value.
+    if ssl_version not in (None, PROTOCOL_TLS, PROTOCOL_TLS_CLIENT):
+        # Disallow setting 'ssl_version' and 'ssl_minimum|maximum_version'
+        # to avoid conflicts.
+        if ssl_minimum_version is not None or ssl_maximum_version is not None:
+            raise ValueError(
+                "Can't specify both 'ssl_version' and either "
+                "'ssl_minimum_version' or 'ssl_maximum_version'"
+            )
+
+        # 'ssl_version' is deprecated and will be removed in the future.
+        else:
+            # Use 'ssl_minimum_version' and 'ssl_maximum_version' instead.
+            ssl_minimum_version = _SSL_VERSION_TO_TLS_VERSION.get(
+                ssl_version, TLSVersion.MINIMUM_SUPPORTED
+            )
+            ssl_maximum_version = _SSL_VERSION_TO_TLS_VERSION.get(
+                ssl_version, TLSVersion.MAXIMUM_SUPPORTED
+            )
+
+            # This warning message is pushing users to use 'ssl_minimum_version'
+            # instead of both min/max. Best practice is to only set the minimum version and
+            # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED'
+            warnings.warn(
+                "'ssl_version' option is deprecated and will be "
+                "removed in urllib3 v2.6.0. Instead use 'ssl_minimum_version'",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+
+    # PROTOCOL_TLS is deprecated in Python 3.10 so we always use PROTOCOL_TLS_CLIENT
+    context = SSLContext(PROTOCOL_TLS_CLIENT)
+
+    if ssl_minimum_version is not None:
+        context.minimum_version = ssl_minimum_version
+    else:  # Python <3.10 defaults to 'MINIMUM_SUPPORTED' so explicitly set TLSv1.2 here
+        context.minimum_version = TLSVersion.TLSv1_2
+
+    if ssl_maximum_version is not None:
+        context.maximum_version = ssl_maximum_version
+
+    # Unless we're given ciphers defer to either system ciphers in
+    # the case of OpenSSL 1.1.1+ or use our own secure default ciphers.
+    if ciphers:
+        context.set_ciphers(ciphers)
+
+    # Setting the default here, as we may have no ssl module on import
+    cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs
+
+    if options is None:
+        options = 0
+        # SSLv2 is easily broken and is considered harmful and dangerous
+        options |= OP_NO_SSLv2
+        # SSLv3 has several problems and is now dangerous
+        options |= OP_NO_SSLv3
+        # Disable compression to prevent CRIME attacks for OpenSSL 1.0+
+        # (issue #309)
+        options |= OP_NO_COMPRESSION
+        # TLSv1.2 only. Unless set explicitly, do not request tickets.
+        # This may save some bandwidth on wire, and although the ticket is encrypted,
+        # there is a risk associated with it being on wire,
+        # if the server is not rotating its ticketing keys properly.
+        options |= OP_NO_TICKET
+
+    context.options |= options
+
+    if verify_flags is None:
+        verify_flags = 0
+        # In Python 3.13+ ssl.create_default_context() sets VERIFY_X509_PARTIAL_CHAIN
+        # and VERIFY_X509_STRICT so we do the same
+        if sys.version_info >= (3, 13):
+            verify_flags |= VERIFY_X509_PARTIAL_CHAIN
+            verify_flags |= VERIFY_X509_STRICT
+
+    context.verify_flags |= verify_flags
+
+    # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is
+    # necessary for conditional client cert authentication with TLS 1.3.
+    # The attribute is None for OpenSSL <= 1.1.0 or does not exist when using
+    # an SSLContext created by pyOpenSSL.
+    if getattr(context, "post_handshake_auth", None) is not None:
+        context.post_handshake_auth = True
+
+    # The order of the below lines setting verify_mode and check_hostname
+    # matter due to safe-guards SSLContext has to prevent an SSLContext with
+    # check_hostname=True, verify_mode=NONE/OPTIONAL.
+    # We always set 'check_hostname=False' for pyOpenSSL so we rely on our own
+    # 'ssl.match_hostname()' implementation.
+    if cert_reqs == ssl.CERT_REQUIRED and not IS_PYOPENSSL:
+        context.verify_mode = cert_reqs
+        context.check_hostname = True
+    else:
+        context.check_hostname = False
+        context.verify_mode = cert_reqs
+
+    try:
+        context.hostname_checks_common_name = False
+    except AttributeError:  # Defensive: for CPython < 3.9.3; for PyPy < 7.3.8
+        pass
+
+    sslkeylogfile = os.environ.get("SSLKEYLOGFILE")
+    if sslkeylogfile:
+        context.keylog_filename = sslkeylogfile
+
+    return context
+
+
+@typing.overload
+def ssl_wrap_socket(
+    sock: socket.socket,
+    keyfile: str | None = ...,
+    certfile: str | None = ...,
+    cert_reqs: int | None = ...,
+    ca_certs: str | None = ...,
+    server_hostname: str | None = ...,
+    ssl_version: int | None = ...,
+    ciphers: str | None = ...,
+    ssl_context: ssl.SSLContext | None = ...,
+    ca_cert_dir: str | None = ...,
+    key_password: str | None = ...,
+    ca_cert_data: None | str | bytes = ...,
+    tls_in_tls: typing.Literal[False] = ...,
+) -> ssl.SSLSocket: ...
+
+
+@typing.overload
+def ssl_wrap_socket(
+    sock: socket.socket,
+    keyfile: str | None = ...,
+    certfile: str | None = ...,
+    cert_reqs: int | None = ...,
+    ca_certs: str | None = ...,
+    server_hostname: str | None = ...,
+    ssl_version: int | None = ...,
+    ciphers: str | None = ...,
+    ssl_context: ssl.SSLContext | None = ...,
+    ca_cert_dir: str | None = ...,
+    key_password: str | None = ...,
+    ca_cert_data: None | str | bytes = ...,
+    tls_in_tls: bool = ...,
+) -> ssl.SSLSocket | SSLTransportType: ...
+
+
+def ssl_wrap_socket(
+    sock: socket.socket,
+    keyfile: str | None = None,
+    certfile: str | None = None,
+    cert_reqs: int | None = None,
+    ca_certs: str | None = None,
+    server_hostname: str | None = None,
+    ssl_version: int | None = None,
+    ciphers: str | None = None,
+    ssl_context: ssl.SSLContext | None = None,
+    ca_cert_dir: str | None = None,
+    key_password: str | None = None,
+    ca_cert_data: None | str | bytes = None,
+    tls_in_tls: bool = False,
+) -> ssl.SSLSocket | SSLTransportType:
+    """
+    All arguments except for server_hostname, ssl_context, tls_in_tls, ca_cert_data and
+    ca_cert_dir have the same meaning as they do when using
+    :func:`ssl.create_default_context`, :meth:`ssl.SSLContext.load_cert_chain`,
+    :meth:`ssl.SSLContext.set_ciphers` and :meth:`ssl.SSLContext.wrap_socket`.
+
+    :param server_hostname:
+        When SNI is supported, the expected hostname of the certificate
+    :param ssl_context:
+        A pre-made :class:`SSLContext` object. If none is provided, one will
+        be created using :func:`create_urllib3_context`.
+    :param ciphers:
+        A string of ciphers we wish the client to support.
+    :param ca_cert_dir:
+        A directory containing CA certificates in multiple separate files, as
+        supported by OpenSSL's -CApath flag or the capath argument to
+        SSLContext.load_verify_locations().
+    :param key_password:
+        Optional password if the keyfile is encrypted.
+    :param ca_cert_data:
+        Optional string containing CA certificates in PEM format suitable for
+        passing as the cadata parameter to SSLContext.load_verify_locations()
+    :param tls_in_tls:
+        Use SSLTransport to wrap the existing socket.
+    """
+    context = ssl_context
+    if context is None:
+        # Note: This branch of code and all the variables in it are only used in tests.
+        # We should consider deprecating and removing this code.
+        context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers)
+
+    if ca_certs or ca_cert_dir or ca_cert_data:
+        try:
+            context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data)
+        except OSError as e:
+            raise SSLError(e) from e
+
+    elif ssl_context is None and hasattr(context, "load_default_certs"):
+        # try to load OS default certs; works well on Windows.
+        context.load_default_certs()
+
+    # Attempt to detect if we get the goofy behavior of the
+    # keyfile being encrypted and OpenSSL asking for the
+    # passphrase via the terminal and instead error out.
+    if keyfile and key_password is None and _is_key_file_encrypted(keyfile):
+        raise SSLError("Client private key is encrypted, password is required")
+
+    if certfile:
+        if key_password is None:
+            context.load_cert_chain(certfile, keyfile)
+        else:
+            context.load_cert_chain(certfile, keyfile, key_password)
+
+    context.set_alpn_protocols(ALPN_PROTOCOLS)
+
+    ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls, server_hostname)
+    return ssl_sock
+
+
+def is_ipaddress(hostname: str | bytes) -> bool:
+    """Detects whether the hostname given is an IPv4 or IPv6 address.
+    Also detects IPv6 addresses with Zone IDs.
+
+    :param str hostname: Hostname to examine.
+    :return: True if the hostname is an IP address, False otherwise.
+    """
+    if isinstance(hostname, bytes):
+        # IDN A-label bytes are ASCII compatible.
+        hostname = hostname.decode("ascii")
+    return bool(_IPV4_RE.match(hostname) or _BRACELESS_IPV6_ADDRZ_RE.match(hostname))
+
+
+def _is_key_file_encrypted(key_file: str) -> bool:
+    """Detects if a key file is encrypted or not."""
+    with open(key_file) as f:
+        for line in f:
+            # Look for Proc-Type: 4,ENCRYPTED
+            if "ENCRYPTED" in line:
+                return True
+
+    return False
+
+
+def _ssl_wrap_socket_impl(
+    sock: socket.socket,
+    ssl_context: ssl.SSLContext,
+    tls_in_tls: bool,
+    server_hostname: str | None = None,
+) -> ssl.SSLSocket | SSLTransportType:
+    if tls_in_tls:
+        if not SSLTransport:
+            # Import error, ssl is not available.
+            raise ProxySchemeUnsupported(
+                "TLS in TLS requires support for the 'ssl' module"
+            )
+
+        SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context)
+        return SSLTransport(sock, ssl_context, server_hostname)
+
+    return ssl_context.wrap_socket(sock, server_hostname=server_hostname)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/ssl_match_hostname.py b/.venv/lib/python3.13/site-packages/urllib3/util/ssl_match_hostname.py
new file mode 100644
index 0000000000000000000000000000000000000000..25d91000419ea4a860f511ebe669fe171b79254c
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/ssl_match_hostname.py
@@ -0,0 +1,159 @@
+"""The match_hostname() function from Python 3.5, essential when using SSL."""
+
+# Note: This file is under the PSF license as the code comes from the python
+# stdlib.   http://docs.python.org/3/license.html
+# It is modified to remove commonName support.
+
+from __future__ import annotations
+
+import ipaddress
+import re
+import typing
+from ipaddress import IPv4Address, IPv6Address
+
+if typing.TYPE_CHECKING:
+    from .ssl_ import _TYPE_PEER_CERT_RET_DICT
+
+__version__ = "3.5.0.1"
+
+
+class CertificateError(ValueError):
+    pass
+
+
+def _dnsname_match(
+    dn: typing.Any, hostname: str, max_wildcards: int = 1
+) -> typing.Match[str] | None | bool:
+    """Matching according to RFC 6125, section 6.4.3
+
+    http://tools.ietf.org/html/rfc6125#section-6.4.3
+    """
+    pats = []
+    if not dn:
+        return False
+
+    # Ported from python3-syntax:
+    # leftmost, *remainder = dn.split(r'.')
+    parts = dn.split(r".")
+    leftmost = parts[0]
+    remainder = parts[1:]
+
+    wildcards = leftmost.count("*")
+    if wildcards > max_wildcards:
+        # Issue #17980: avoid denials of service by refusing more
+        # than one wildcard per fragment.  A survey of established
+        # policy among SSL implementations showed it to be a
+        # reasonable choice.
+        raise CertificateError(
+            "too many wildcards in certificate DNS name: " + repr(dn)
+        )
+
+    # speed up common case w/o wildcards
+    if not wildcards:
+        return bool(dn.lower() == hostname.lower())
+
+    # RFC 6125, section 6.4.3, subitem 1.
+    # The client SHOULD NOT attempt to match a presented identifier in which
+    # the wildcard character comprises a label other than the left-most label.
+    if leftmost == "*":
+        # When '*' is a fragment by itself, it matches a non-empty dotless
+        # fragment.
+        pats.append("[^.]+")
+    elif leftmost.startswith("xn--") or hostname.startswith("xn--"):
+        # RFC 6125, section 6.4.3, subitem 3.
+        # The client SHOULD NOT attempt to match a presented identifier
+        # where the wildcard character is embedded within an A-label or
+        # U-label of an internationalized domain name.
+        pats.append(re.escape(leftmost))
+    else:
+        # Otherwise, '*' matches any dotless string, e.g. www*
+        pats.append(re.escape(leftmost).replace(r"\*", "[^.]*"))
+
+    # add the remaining fragments, ignore any wildcards
+    for frag in remainder:
+        pats.append(re.escape(frag))
+
+    pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE)
+    return pat.match(hostname)
+
+
+def _ipaddress_match(ipname: str, host_ip: IPv4Address | IPv6Address) -> bool:
+    """Exact matching of IP addresses.
+
+    RFC 9110 section 4.3.5: "A reference identity of IP-ID contains the decoded
+    bytes of the IP address. An IP version 4 address is 4 octets, and an IP
+    version 6 address is 16 octets. [...] A reference identity of type IP-ID
+    matches if the address is identical to an iPAddress value of the
+    subjectAltName extension of the certificate."
+    """
+    # OpenSSL may add a trailing newline to a subjectAltName's IP address
+    # Divergence from upstream: ipaddress can't handle byte str
+    ip = ipaddress.ip_address(ipname.rstrip())
+    return bool(ip.packed == host_ip.packed)
+
+
+def match_hostname(
+    cert: _TYPE_PEER_CERT_RET_DICT | None,
+    hostname: str,
+    hostname_checks_common_name: bool = False,
+) -> None:
+    """Verify that *cert* (in decoded format as returned by
+    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+    rules are followed, but IP addresses are not accepted for *hostname*.
+
+    CertificateError is raised on failure. On success, the function
+    returns nothing.
+    """
+    if not cert:
+        raise ValueError(
+            "empty or no certificate, match_hostname needs a "
+            "SSL socket or SSL context with either "
+            "CERT_OPTIONAL or CERT_REQUIRED"
+        )
+    try:
+        # Divergence from upstream: ipaddress can't handle byte str
+        #
+        # The ipaddress module shipped with Python < 3.9 does not support
+        # scoped IPv6 addresses so we unconditionally strip the Zone IDs for
+        # now. Once we drop support for Python 3.9 we can remove this branch.
+        if "%" in hostname:
+            host_ip = ipaddress.ip_address(hostname[: hostname.rfind("%")])
+        else:
+            host_ip = ipaddress.ip_address(hostname)
+
+    except ValueError:
+        # Not an IP address (common case)
+        host_ip = None
+    dnsnames = []
+    san: tuple[tuple[str, str], ...] = cert.get("subjectAltName", ())
+    key: str
+    value: str
+    for key, value in san:
+        if key == "DNS":
+            if host_ip is None and _dnsname_match(value, hostname):
+                return
+            dnsnames.append(value)
+        elif key == "IP Address":
+            if host_ip is not None and _ipaddress_match(value, host_ip):
+                return
+            dnsnames.append(value)
+
+    # We only check 'commonName' if it's enabled and we're not verifying
+    # an IP address. IP addresses aren't valid within 'commonName'.
+    if hostname_checks_common_name and host_ip is None and not dnsnames:
+        for sub in cert.get("subject", ()):
+            for key, value in sub:
+                if key == "commonName":
+                    if _dnsname_match(value, hostname):
+                        return
+                    dnsnames.append(value)  # Defensive: for Python < 3.9.3
+
+    if len(dnsnames) > 1:
+        raise CertificateError(
+            "hostname %r "
+            "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames)))
+        )
+    elif len(dnsnames) == 1:
+        raise CertificateError(f"hostname {hostname!r} doesn't match {dnsnames[0]!r}")
+    else:
+        raise CertificateError("no appropriate subjectAltName fields were found")
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/ssltransport.py b/.venv/lib/python3.13/site-packages/urllib3/util/ssltransport.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d59bc3bce2489c3a0aa5bcb83b737dcf33c033b
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/ssltransport.py
@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import io
+import socket
+import ssl
+import typing
+
+from ..exceptions import ProxySchemeUnsupported
+
+if typing.TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from .ssl_ import _TYPE_PEER_CERT_RET, _TYPE_PEER_CERT_RET_DICT
+
+
+_WriteBuffer = typing.Union[bytearray, memoryview]
+_ReturnValue = typing.TypeVar("_ReturnValue")
+
+SSL_BLOCKSIZE = 16384
+
+
+class SSLTransport:
+    """
+    The SSLTransport wraps an existing socket and establishes an SSL connection.
+
+    Contrary to Python's implementation of SSLSocket, it allows you to chain
+    multiple TLS connections together. It's particularly useful if you need to
+    implement TLS within TLS.
+
+    The class supports most of the socket API operations.
+    """
+
+    @staticmethod
+    def _validate_ssl_context_for_tls_in_tls(ssl_context: ssl.SSLContext) -> None:
+        """
+        Raises a ProxySchemeUnsupported if the provided ssl_context can't be used
+        for TLS in TLS.
+
+        The only requirement is that the ssl_context provides the 'wrap_bio'
+        methods.
+        """
+
+        if not hasattr(ssl_context, "wrap_bio"):
+            raise ProxySchemeUnsupported(
+                "TLS in TLS requires SSLContext.wrap_bio() which isn't "
+                "available on non-native SSLContext"
+            )
+
+    def __init__(
+        self,
+        socket: socket.socket,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        suppress_ragged_eofs: bool = True,
+    ) -> None:
+        """
+        Create an SSLTransport around socket using the provided ssl_context.
+        """
+        self.incoming = ssl.MemoryBIO()
+        self.outgoing = ssl.MemoryBIO()
+
+        self.suppress_ragged_eofs = suppress_ragged_eofs
+        self.socket = socket
+
+        self.sslobj = ssl_context.wrap_bio(
+            self.incoming, self.outgoing, server_hostname=server_hostname
+        )
+
+        # Perform initial handshake.
+        self._ssl_io_loop(self.sslobj.do_handshake)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_: typing.Any) -> None:
+        self.close()
+
+    def fileno(self) -> int:
+        return self.socket.fileno()
+
+    def read(self, len: int = 1024, buffer: typing.Any | None = None) -> int | bytes:
+        return self._wrap_ssl_read(len, buffer)
+
+    def recv(self, buflen: int = 1024, flags: int = 0) -> int | bytes:
+        if flags != 0:
+            raise ValueError("non-zero flags not allowed in calls to recv")
+        return self._wrap_ssl_read(buflen)
+
+    def recv_into(
+        self,
+        buffer: _WriteBuffer,
+        nbytes: int | None = None,
+        flags: int = 0,
+    ) -> None | int | bytes:
+        if flags != 0:
+            raise ValueError("non-zero flags not allowed in calls to recv_into")
+        if nbytes is None:
+            nbytes = len(buffer)
+        return self.read(nbytes, buffer)
+
+    def sendall(self, data: bytes, flags: int = 0) -> None:
+        if flags != 0:
+            raise ValueError("non-zero flags not allowed in calls to sendall")
+        count = 0
+        with memoryview(data) as view, view.cast("B") as byte_view:
+            amount = len(byte_view)
+            while count < amount:
+                v = self.send(byte_view[count:])
+                count += v
+
+    def send(self, data: bytes, flags: int = 0) -> int:
+        if flags != 0:
+            raise ValueError("non-zero flags not allowed in calls to send")
+        return self._ssl_io_loop(self.sslobj.write, data)
+
+    def makefile(
+        self,
+        mode: str,
+        buffering: int | None = None,
+        *,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> typing.BinaryIO | typing.TextIO | socket.SocketIO:
+        """
+        Python's httpclient uses makefile and buffered io when reading HTTP
+        messages and we need to support it.
+
+        This is unfortunately a copy and paste of socket.py makefile with small
+        changes to point to the socket directly.
+        """
+        if not set(mode) <= {"r", "w", "b"}:
+            raise ValueError(f"invalid mode {mode!r} (only r, w, b allowed)")
+
+        writing = "w" in mode
+        reading = "r" in mode or not writing
+        assert reading or writing
+        binary = "b" in mode
+        rawmode = ""
+        if reading:
+            rawmode += "r"
+        if writing:
+            rawmode += "w"
+        raw = socket.SocketIO(self, rawmode)  # type: ignore[arg-type]
+        self.socket._io_refs += 1  # type: ignore[attr-defined]
+        if buffering is None:
+            buffering = -1
+        if buffering < 0:
+            buffering = io.DEFAULT_BUFFER_SIZE
+        if buffering == 0:
+            if not binary:
+                raise ValueError("unbuffered streams must be binary")
+            return raw
+        buffer: typing.BinaryIO
+        if reading and writing:
+            buffer = io.BufferedRWPair(raw, raw, buffering)  # type: ignore[assignment]
+        elif reading:
+            buffer = io.BufferedReader(raw, buffering)
+        else:
+            assert writing
+            buffer = io.BufferedWriter(raw, buffering)
+        if binary:
+            return buffer
+        text = io.TextIOWrapper(buffer, encoding, errors, newline)
+        text.mode = mode  # type: ignore[misc]
+        return text
+
+    def unwrap(self) -> None:
+        self._ssl_io_loop(self.sslobj.unwrap)
+
+    def close(self) -> None:
+        self.socket.close()
+
+    @typing.overload
+    def getpeercert(
+        self, binary_form: typing.Literal[False] = ...
+    ) -> _TYPE_PEER_CERT_RET_DICT | None: ...
+
+    @typing.overload
+    def getpeercert(self, binary_form: typing.Literal[True]) -> bytes | None: ...
+
+    def getpeercert(self, binary_form: bool = False) -> _TYPE_PEER_CERT_RET:
+        return self.sslobj.getpeercert(binary_form)  # type: ignore[return-value]
+
+    def version(self) -> str | None:
+        return self.sslobj.version()
+
+    def cipher(self) -> tuple[str, str, int] | None:
+        return self.sslobj.cipher()
+
+    def selected_alpn_protocol(self) -> str | None:
+        return self.sslobj.selected_alpn_protocol()
+
+    def shared_ciphers(self) -> list[tuple[str, str, int]] | None:
+        return self.sslobj.shared_ciphers()
+
+    def compression(self) -> str | None:
+        return self.sslobj.compression()
+
+    def settimeout(self, value: float | None) -> None:
+        self.socket.settimeout(value)
+
+    def gettimeout(self) -> float | None:
+        return self.socket.gettimeout()
+
+    def _decref_socketios(self) -> None:
+        self.socket._decref_socketios()  # type: ignore[attr-defined]
+
+    def _wrap_ssl_read(self, len: int, buffer: bytearray | None = None) -> int | bytes:
+        try:
+            return self._ssl_io_loop(self.sslobj.read, len, buffer)
+        except ssl.SSLError as e:
+            if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs:
+                return 0  # eof, return 0.
+            else:
+                raise
+
+    # func is sslobj.do_handshake or sslobj.unwrap
+    @typing.overload
+    def _ssl_io_loop(self, func: typing.Callable[[], None]) -> None: ...
+
+    # func is sslobj.write, arg1 is data
+    @typing.overload
+    def _ssl_io_loop(self, func: typing.Callable[[bytes], int], arg1: bytes) -> int: ...
+
+    # func is sslobj.read, arg1 is len, arg2 is buffer
+    @typing.overload
+    def _ssl_io_loop(
+        self,
+        func: typing.Callable[[int, bytearray | None], bytes],
+        arg1: int,
+        arg2: bytearray | None,
+    ) -> bytes: ...
+
+    def _ssl_io_loop(
+        self,
+        func: typing.Callable[..., _ReturnValue],
+        arg1: None | bytes | int = None,
+        arg2: bytearray | None = None,
+    ) -> _ReturnValue:
+        """Performs an I/O loop between incoming/outgoing and the socket."""
+        should_loop = True
+        ret = None
+
+        while should_loop:
+            errno = None
+            try:
+                if arg1 is None and arg2 is None:
+                    ret = func()
+                elif arg2 is None:
+                    ret = func(arg1)
+                else:
+                    ret = func(arg1, arg2)
+            except ssl.SSLError as e:
+                if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE):
+                    # WANT_READ, and WANT_WRITE are expected, others are not.
+                    raise e
+                errno = e.errno
+
+            buf = self.outgoing.read()
+            self.socket.sendall(buf)
+
+            if errno is None:
+                should_loop = False
+            elif errno == ssl.SSL_ERROR_WANT_READ:
+                buf = self.socket.recv(SSL_BLOCKSIZE)
+                if buf:
+                    self.incoming.write(buf)
+                else:
+                    self.incoming.write_eof()
+        return typing.cast(_ReturnValue, ret)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/timeout.py b/.venv/lib/python3.13/site-packages/urllib3/util/timeout.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bb1be11d9cb06900dd82ecebd06aa6a7c5de916
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/timeout.py
@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import time
+import typing
+from enum import Enum
+from socket import getdefaulttimeout
+
+from ..exceptions import TimeoutStateError
+
+if typing.TYPE_CHECKING:
+    from typing import Final
+
+
+class _TYPE_DEFAULT(Enum):
+    # This value should never be passed to socket.settimeout() so for safety we use a -1.
+    # socket.settimout() raises a ValueError for negative values.
+    token = -1
+
+
+_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token
+
+_TYPE_TIMEOUT = typing.Optional[typing.Union[float, _TYPE_DEFAULT]]
+
+
+class Timeout:
+    """Timeout configuration.
+
+    Timeouts can be defined as a default for a pool:
+
+    .. code-block:: python
+
+        import urllib3
+
+        timeout = urllib3.util.Timeout(connect=2.0, read=7.0)
+
+        http = urllib3.PoolManager(timeout=timeout)
+
+        resp = http.request("GET", "https://example.com/")
+
+        print(resp.status)
+
+    Or per-request (which overrides the default for the pool):
+
+    .. code-block:: python
+
+       response = http.request("GET", "https://example.com/", timeout=Timeout(10))
+
+    Timeouts can be disabled by setting all the parameters to ``None``:
+
+    .. code-block:: python
+
+       no_timeout = Timeout(connect=None, read=None)
+       response = http.request("GET", "https://example.com/", timeout=no_timeout)
+
+
+    :param total:
+        This combines the connect and read timeouts into one; the read timeout
+        will be set to the time leftover from the connect attempt. In the
+        event that both a connect timeout and a total are specified, or a read
+        timeout and a total are specified, the shorter timeout will be applied.
+
+        Defaults to None.
+
+    :type total: int, float, or None
+
+    :param connect:
+        The maximum amount of time (in seconds) to wait for a connection
+        attempt to a server to succeed. Omitting the parameter will default the
+        connect timeout to the system default, probably `the global default
+        timeout in socket.py
+        `_.
+        None will set an infinite timeout for connection attempts.
+
+    :type connect: int, float, or None
+
+    :param read:
+        The maximum amount of time (in seconds) to wait between consecutive
+        read operations for a response from the server. Omitting the parameter
+        will default the read timeout to the system default, probably `the
+        global default timeout in socket.py
+        `_.
+        None will set an infinite timeout.
+
+    :type read: int, float, or None
+
+    .. note::
+
+        Many factors can affect the total amount of time for urllib3 to return
+        an HTTP response.
+
+        For example, Python's DNS resolver does not obey the timeout specified
+        on the socket. Other factors that can affect total request time include
+        high CPU load, high swap, the program running at a low priority level,
+        or other behaviors.
+
+        In addition, the read and total timeouts only measure the time between
+        read operations on the socket connecting the client and the server,
+        not the total amount of time for the request to return a complete
+        response. For most requests, the timeout is raised because the server
+        has not sent the first byte in the specified time. This is not always
+        the case; if a server streams one byte every fifteen seconds, a timeout
+        of 20 seconds will not trigger, even though the request will take
+        several minutes to complete.
+    """
+
+    #: A sentinel object representing the default timeout value
+    DEFAULT_TIMEOUT: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT
+
+    def __init__(
+        self,
+        total: _TYPE_TIMEOUT = None,
+        connect: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+        read: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
+    ) -> None:
+        self._connect = self._validate_timeout(connect, "connect")
+        self._read = self._validate_timeout(read, "read")
+        self.total = self._validate_timeout(total, "total")
+        self._start_connect: float | None = None
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(connect={self._connect!r}, read={self._read!r}, total={self.total!r})"
+
+    # __str__ provided for backwards compatibility
+    __str__ = __repr__
+
+    @staticmethod
+    def resolve_default_timeout(timeout: _TYPE_TIMEOUT) -> float | None:
+        return getdefaulttimeout() if timeout is _DEFAULT_TIMEOUT else timeout
+
+    @classmethod
+    def _validate_timeout(cls, value: _TYPE_TIMEOUT, name: str) -> _TYPE_TIMEOUT:
+        """Check that a timeout attribute is valid.
+
+        :param value: The timeout value to validate
+        :param name: The name of the timeout attribute to validate. This is
+            used to specify in error messages.
+        :return: The validated and casted version of the given value.
+        :raises ValueError: If it is a numeric value less than or equal to
+            zero, or the type is not an integer, float, or None.
+        """
+        if value is None or value is _DEFAULT_TIMEOUT:
+            return value
+
+        if isinstance(value, bool):
+            raise ValueError(
+                "Timeout cannot be a boolean value. It must "
+                "be an int, float or None."
+            )
+        try:
+            float(value)
+        except (TypeError, ValueError):
+            raise ValueError(
+                "Timeout value %s was %s, but it must be an "
+                "int, float or None." % (name, value)
+            ) from None
+
+        try:
+            if value <= 0:
+                raise ValueError(
+                    "Attempted to set %s timeout to %s, but the "
+                    "timeout cannot be set to a value less "
+                    "than or equal to 0." % (name, value)
+                )
+        except TypeError:
+            raise ValueError(
+                "Timeout value %s was %s, but it must be an "
+                "int, float or None." % (name, value)
+            ) from None
+
+        return value
+
+    @classmethod
+    def from_float(cls, timeout: _TYPE_TIMEOUT) -> Timeout:
+        """Create a new Timeout from a legacy timeout value.
+
+        The timeout value used by httplib.py sets the same timeout on the
+        connect(), and recv() socket requests. This creates a :class:`Timeout`
+        object that sets the individual timeouts to the ``timeout`` value
+        passed to this function.
+
+        :param timeout: The legacy timeout value.
+        :type timeout: integer, float, :attr:`urllib3.util.Timeout.DEFAULT_TIMEOUT`, or None
+        :return: Timeout object
+        :rtype: :class:`Timeout`
+        """
+        return Timeout(read=timeout, connect=timeout)
+
+    def clone(self) -> Timeout:
+        """Create a copy of the timeout object
+
+        Timeout properties are stored per-pool but each request needs a fresh
+        Timeout object to ensure each one has its own start/stop configured.
+
+        :return: a copy of the timeout object
+        :rtype: :class:`Timeout`
+        """
+        # We can't use copy.deepcopy because that will also create a new object
+        # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to
+        # detect the user default.
+        return Timeout(connect=self._connect, read=self._read, total=self.total)
+
+    def start_connect(self) -> float:
+        """Start the timeout clock, used during a connect() attempt
+
+        :raises urllib3.exceptions.TimeoutStateError: if you attempt
+            to start a timer that has been started already.
+        """
+        if self._start_connect is not None:
+            raise TimeoutStateError("Timeout timer has already been started.")
+        self._start_connect = time.monotonic()
+        return self._start_connect
+
+    def get_connect_duration(self) -> float:
+        """Gets the time elapsed since the call to :meth:`start_connect`.
+
+        :return: Elapsed time in seconds.
+        :rtype: float
+        :raises urllib3.exceptions.TimeoutStateError: if you attempt
+            to get duration for a timer that hasn't been started.
+        """
+        if self._start_connect is None:
+            raise TimeoutStateError(
+                "Can't get connect duration for timer that has not started."
+            )
+        return time.monotonic() - self._start_connect
+
+    @property
+    def connect_timeout(self) -> _TYPE_TIMEOUT:
+        """Get the value to use when setting a connection timeout.
+
+        This will be a positive float or integer, the value None
+        (never timeout), or the default system timeout.
+
+        :return: Connect timeout.
+        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
+        """
+        if self.total is None:
+            return self._connect
+
+        if self._connect is None or self._connect is _DEFAULT_TIMEOUT:
+            return self.total
+
+        return min(self._connect, self.total)  # type: ignore[type-var]
+
+    @property
+    def read_timeout(self) -> float | None:
+        """Get the value for the read timeout.
+
+        This assumes some time has elapsed in the connection timeout and
+        computes the read timeout appropriately.
+
+        If self.total is set, the read timeout is dependent on the amount of
+        time taken by the connect timeout. If the connection time has not been
+        established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
+        raised.
+
+        :return: Value to use for the read timeout.
+        :rtype: int, float or None
+        :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
+            has not yet been called on this object.
+        """
+        if (
+            self.total is not None
+            and self.total is not _DEFAULT_TIMEOUT
+            and self._read is not None
+            and self._read is not _DEFAULT_TIMEOUT
+        ):
+            # In case the connect timeout has not yet been established.
+            if self._start_connect is None:
+                return self._read
+            return max(0, min(self.total - self.get_connect_duration(), self._read))
+        elif self.total is not None and self.total is not _DEFAULT_TIMEOUT:
+            return max(0, self.total - self.get_connect_duration())
+        else:
+            return self.resolve_default_timeout(self._read)
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/url.py b/.venv/lib/python3.13/site-packages/urllib3/util/url.py
new file mode 100644
index 0000000000000000000000000000000000000000..db057f17be610174f30928748b5004dcbf6c501c
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/url.py
@@ -0,0 +1,469 @@
+from __future__ import annotations
+
+import re
+import typing
+
+from ..exceptions import LocationParseError
+from .util import to_str
+
+# We only want to normalize urls with an HTTP(S) scheme.
+# urllib3 infers URLs without a scheme (None) to be http.
+_NORMALIZABLE_SCHEMES = ("http", "https", None)
+
+# Almost all of these patterns were derived from the
+# 'rfc3986' module: https://github.com/python-hyper/rfc3986
+_PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}")
+_SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)")
+_URI_RE = re.compile(
+    r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?"
+    r"(?://([^\\/?#]*))?"
+    r"([^?#]*)"
+    r"(?:\?([^#]*))?"
+    r"(?:#(.*))?$",
+    re.UNICODE | re.DOTALL,
+)
+
+_IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}"
+_HEX_PAT = "[0-9A-Fa-f]{1,4}"
+_LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=_HEX_PAT, ipv4=_IPV4_PAT)
+_subs = {"hex": _HEX_PAT, "ls32": _LS32_PAT}
+_variations = [
+    #                            6( h16 ":" ) ls32
+    "(?:%(hex)s:){6}%(ls32)s",
+    #                       "::" 5( h16 ":" ) ls32
+    "::(?:%(hex)s:){5}%(ls32)s",
+    # [               h16 ] "::" 4( h16 ":" ) ls32
+    "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s",
+    # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+    "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s",
+    # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+    "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s",
+    # [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+    "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s",
+    # [ *4( h16 ":" ) h16 ] "::"              ls32
+    "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s",
+    # [ *5( h16 ":" ) h16 ] "::"              h16
+    "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s",
+    # [ *6( h16 ":" ) h16 ] "::"
+    "(?:(?:%(hex)s:){0,6}%(hex)s)?::",
+]
+
+_UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._\-~"
+_IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")"
+_ZONE_ID_PAT = "(?:%25|%)(?:[" + _UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+"
+_IPV6_ADDRZ_PAT = r"\[" + _IPV6_PAT + r"(?:" + _ZONE_ID_PAT + r")?\]"
+_REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*"
+_TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$")
+
+_IPV4_RE = re.compile("^" + _IPV4_PAT + "$")
+_IPV6_RE = re.compile("^" + _IPV6_PAT + "$")
+_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT + "$")
+_BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT[2:-2] + "$")
+_ZONE_ID_RE = re.compile("(" + _ZONE_ID_PAT + r")\]$")
+
+_HOST_PORT_PAT = ("^(%s|%s|%s)(?::0*?(|0|[1-9][0-9]{0,4}))?$") % (
+    _REG_NAME_PAT,
+    _IPV4_PAT,
+    _IPV6_ADDRZ_PAT,
+)
+_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL)
+
+_UNRESERVED_CHARS = set(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~"
+)
+_SUB_DELIM_CHARS = set("!$&'()*+,;=")
+_USERINFO_CHARS = _UNRESERVED_CHARS | _SUB_DELIM_CHARS | {":"}
+_PATH_CHARS = _USERINFO_CHARS | {"@", "/"}
+_QUERY_CHARS = _FRAGMENT_CHARS = _PATH_CHARS | {"?"}
+
+
+class Url(
+    typing.NamedTuple(
+        "Url",
+        [
+            ("scheme", typing.Optional[str]),
+            ("auth", typing.Optional[str]),
+            ("host", typing.Optional[str]),
+            ("port", typing.Optional[int]),
+            ("path", typing.Optional[str]),
+            ("query", typing.Optional[str]),
+            ("fragment", typing.Optional[str]),
+        ],
+    )
+):
+    """
+    Data structure for representing an HTTP URL. Used as a return value for
+    :func:`parse_url`. Both the scheme and host are normalized as they are
+    both case-insensitive according to RFC 3986.
+    """
+
+    def __new__(  # type: ignore[no-untyped-def]
+        cls,
+        scheme: str | None = None,
+        auth: str | None = None,
+        host: str | None = None,
+        port: int | None = None,
+        path: str | None = None,
+        query: str | None = None,
+        fragment: str | None = None,
+    ):
+        if path and not path.startswith("/"):
+            path = "/" + path
+        if scheme is not None:
+            scheme = scheme.lower()
+        return super().__new__(cls, scheme, auth, host, port, path, query, fragment)
+
+    @property
+    def hostname(self) -> str | None:
+        """For backwards-compatibility with urlparse. We're nice like that."""
+        return self.host
+
+    @property
+    def request_uri(self) -> str:
+        """Absolute path including the query string."""
+        uri = self.path or "/"
+
+        if self.query is not None:
+            uri += "?" + self.query
+
+        return uri
+
+    @property
+    def authority(self) -> str | None:
+        """
+        Authority component as defined in RFC 3986 3.2.
+        This includes userinfo (auth), host and port.
+
+        i.e.
+            userinfo@host:port
+        """
+        userinfo = self.auth
+        netloc = self.netloc
+        if netloc is None or userinfo is None:
+            return netloc
+        else:
+            return f"{userinfo}@{netloc}"
+
+    @property
+    def netloc(self) -> str | None:
+        """
+        Network location including host and port.
+
+        If you need the equivalent of urllib.parse's ``netloc``,
+        use the ``authority`` property instead.
+        """
+        if self.host is None:
+            return None
+        if self.port:
+            return f"{self.host}:{self.port}"
+        return self.host
+
+    @property
+    def url(self) -> str:
+        """
+        Convert self into a url
+
+        This function should more or less round-trip with :func:`.parse_url`. The
+        returned url may not be exactly the same as the url inputted to
+        :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
+        with a blank port will have : removed).
+
+        Example:
+
+        .. code-block:: python
+
+            import urllib3
+
+            U = urllib3.util.parse_url("https://google.com/mail/")
+
+            print(U.url)
+            # "https://google.com/mail/"
+
+            print( urllib3.util.Url("https", "username:password",
+                                    "host.com", 80, "/path", "query", "fragment"
+                                    ).url
+                )
+            # "https://username:password@host.com:80/path?query#fragment"
+        """
+        scheme, auth, host, port, path, query, fragment = self
+        url = ""
+
+        # We use "is not None" we want things to happen with empty strings (or 0 port)
+        if scheme is not None:
+            url += scheme + "://"
+        if auth is not None:
+            url += auth + "@"
+        if host is not None:
+            url += host
+        if port is not None:
+            url += ":" + str(port)
+        if path is not None:
+            url += path
+        if query is not None:
+            url += "?" + query
+        if fragment is not None:
+            url += "#" + fragment
+
+        return url
+
+    def __str__(self) -> str:
+        return self.url
+
+
+@typing.overload
+def _encode_invalid_chars(
+    component: str, allowed_chars: typing.Container[str]
+) -> str:  # Abstract
+    ...
+
+
+@typing.overload
+def _encode_invalid_chars(
+    component: None, allowed_chars: typing.Container[str]
+) -> None:  # Abstract
+    ...
+
+
+def _encode_invalid_chars(
+    component: str | None, allowed_chars: typing.Container[str]
+) -> str | None:
+    """Percent-encodes a URI component without reapplying
+    onto an already percent-encoded component.
+    """
+    if component is None:
+        return component
+
+    component = to_str(component)
+
+    # Normalize existing percent-encoded bytes.
+    # Try to see if the component we're encoding is already percent-encoded
+    # so we can skip all '%' characters but still encode all others.
+    component, percent_encodings = _PERCENT_RE.subn(
+        lambda match: match.group(0).upper(), component
+    )
+
+    uri_bytes = component.encode("utf-8", "surrogatepass")
+    is_percent_encoded = percent_encodings == uri_bytes.count(b"%")
+    encoded_component = bytearray()
+
+    for i in range(0, len(uri_bytes)):
+        # Will return a single character bytestring
+        byte = uri_bytes[i : i + 1]
+        byte_ord = ord(byte)
+        if (is_percent_encoded and byte == b"%") or (
+            byte_ord < 128 and byte.decode() in allowed_chars
+        ):
+            encoded_component += byte
+            continue
+        encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper()))
+
+    return encoded_component.decode()
+
+
+def _remove_path_dot_segments(path: str) -> str:
+    # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code
+    segments = path.split("/")  # Turn the path into a list of segments
+    output = []  # Initialize the variable to use to store output
+
+    for segment in segments:
+        # '.' is the current directory, so ignore it, it is superfluous
+        if segment == ".":
+            continue
+        # Anything other than '..', should be appended to the output
+        if segment != "..":
+            output.append(segment)
+        # In this case segment == '..', if we can, we should pop the last
+        # element
+        elif output:
+            output.pop()
+
+    # If the path starts with '/' and the output is empty or the first string
+    # is non-empty
+    if path.startswith("/") and (not output or output[0]):
+        output.insert(0, "")
+
+    # If the path starts with '/.' or '/..' ensure we add one more empty
+    # string to add a trailing '/'
+    if path.endswith(("/.", "/..")):
+        output.append("")
+
+    return "/".join(output)
+
+
+@typing.overload
+def _normalize_host(host: None, scheme: str | None) -> None: ...
+
+
+@typing.overload
+def _normalize_host(host: str, scheme: str | None) -> str: ...
+
+
+def _normalize_host(host: str | None, scheme: str | None) -> str | None:
+    if host:
+        if scheme in _NORMALIZABLE_SCHEMES:
+            is_ipv6 = _IPV6_ADDRZ_RE.match(host)
+            if is_ipv6:
+                # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as
+                # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID
+                # separator as necessary to return a valid RFC 4007 scoped IP.
+                match = _ZONE_ID_RE.search(host)
+                if match:
+                    start, end = match.span(1)
+                    zone_id = host[start:end]
+
+                    if zone_id.startswith("%25") and zone_id != "%25":
+                        zone_id = zone_id[3:]
+                    else:
+                        zone_id = zone_id[1:]
+                    zone_id = _encode_invalid_chars(zone_id, _UNRESERVED_CHARS)
+                    return f"{host[:start].lower()}%{zone_id}{host[end:]}"
+                else:
+                    return host.lower()
+            elif not _IPV4_RE.match(host):
+                return to_str(
+                    b".".join([_idna_encode(label) for label in host.split(".")]),
+                    "ascii",
+                )
+    return host
+
+
+def _idna_encode(name: str) -> bytes:
+    if not name.isascii():
+        try:
+            import idna
+        except ImportError:
+            raise LocationParseError(
+                "Unable to parse URL without the 'idna' module"
+            ) from None
+
+        try:
+            return idna.encode(name.lower(), strict=True, std3_rules=True)
+        except idna.IDNAError:
+            raise LocationParseError(
+                f"Name '{name}' is not a valid IDNA label"
+            ) from None
+
+    return name.lower().encode("ascii")
+
+
+def _encode_target(target: str) -> str:
+    """Percent-encodes a request target so that there are no invalid characters
+
+    Pre-condition for this function is that 'target' must start with '/'.
+    If that is the case then _TARGET_RE will always produce a match.
+    """
+    match = _TARGET_RE.match(target)
+    if not match:  # Defensive:
+        raise LocationParseError(f"{target!r} is not a valid request URI")
+
+    path, query = match.groups()
+    encoded_target = _encode_invalid_chars(path, _PATH_CHARS)
+    if query is not None:
+        query = _encode_invalid_chars(query, _QUERY_CHARS)
+        encoded_target += "?" + query
+    return encoded_target
+
+
+def parse_url(url: str) -> Url:
+    """
+    Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
+    performed to parse incomplete urls. Fields not provided will be None.
+    This parser is RFC 3986 and RFC 6874 compliant.
+
+    The parser logic and helper functions are based heavily on
+    work done in the ``rfc3986`` module.
+
+    :param str url: URL to parse into a :class:`.Url` namedtuple.
+
+    Partly backwards-compatible with :mod:`urllib.parse`.
+
+    Example:
+
+    .. code-block:: python
+
+        import urllib3
+
+        print( urllib3.util.parse_url('http://google.com/mail/'))
+        # Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
+
+        print( urllib3.util.parse_url('google.com:80'))
+        # Url(scheme=None, host='google.com', port=80, path=None, ...)
+
+        print( urllib3.util.parse_url('/foo?bar'))
+        # Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
+    """
+    if not url:
+        # Empty
+        return Url()
+
+    source_url = url
+    if not _SCHEME_RE.search(url):
+        url = "//" + url
+
+    scheme: str | None
+    authority: str | None
+    auth: str | None
+    host: str | None
+    port: str | None
+    port_int: int | None
+    path: str | None
+    query: str | None
+    fragment: str | None
+
+    try:
+        scheme, authority, path, query, fragment = _URI_RE.match(url).groups()  # type: ignore[union-attr]
+        normalize_uri = scheme is None or scheme.lower() in _NORMALIZABLE_SCHEMES
+
+        if scheme:
+            scheme = scheme.lower()
+
+        if authority:
+            auth, _, host_port = authority.rpartition("@")
+            auth = auth or None
+            host, port = _HOST_PORT_RE.match(host_port).groups()  # type: ignore[union-attr]
+            if auth and normalize_uri:
+                auth = _encode_invalid_chars(auth, _USERINFO_CHARS)
+            if port == "":
+                port = None
+        else:
+            auth, host, port = None, None, None
+
+        if port is not None:
+            port_int = int(port)
+            if not (0 <= port_int <= 65535):
+                raise LocationParseError(url)
+        else:
+            port_int = None
+
+        host = _normalize_host(host, scheme)
+
+        if normalize_uri and path:
+            path = _remove_path_dot_segments(path)
+            path = _encode_invalid_chars(path, _PATH_CHARS)
+        if normalize_uri and query:
+            query = _encode_invalid_chars(query, _QUERY_CHARS)
+        if normalize_uri and fragment:
+            fragment = _encode_invalid_chars(fragment, _FRAGMENT_CHARS)
+
+    except (ValueError, AttributeError) as e:
+        raise LocationParseError(source_url) from e
+
+    # For the sake of backwards compatibility we put empty
+    # string values for path if there are any defined values
+    # beyond the path in the URL.
+    # TODO: Remove this when we break backwards compatibility.
+    if not path:
+        if query is not None or fragment is not None:
+            path = ""
+        else:
+            path = None
+
+    return Url(
+        scheme=scheme,
+        auth=auth,
+        host=host,
+        port=port_int,
+        path=path,
+        query=query,
+        fragment=fragment,
+    )
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/util.py b/.venv/lib/python3.13/site-packages/urllib3/util/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..35c77e4025842f548565334a3c04cba90f9283d6
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/util.py
@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import typing
+from types import TracebackType
+
+
+def to_bytes(
+    x: str | bytes, encoding: str | None = None, errors: str | None = None
+) -> bytes:
+    if isinstance(x, bytes):
+        return x
+    elif not isinstance(x, str):
+        raise TypeError(f"not expecting type {type(x).__name__}")
+    if encoding or errors:
+        return x.encode(encoding or "utf-8", errors=errors or "strict")
+    return x.encode()
+
+
+def to_str(
+    x: str | bytes, encoding: str | None = None, errors: str | None = None
+) -> str:
+    if isinstance(x, str):
+        return x
+    elif not isinstance(x, bytes):
+        raise TypeError(f"not expecting type {type(x).__name__}")
+    if encoding or errors:
+        return x.decode(encoding or "utf-8", errors=errors or "strict")
+    return x.decode()
+
+
+def reraise(
+    tp: type[BaseException] | None,
+    value: BaseException,
+    tb: TracebackType | None = None,
+) -> typing.NoReturn:
+    try:
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+    finally:
+        value = None  # type: ignore[assignment]
+        tb = None
diff --git a/.venv/lib/python3.13/site-packages/urllib3/util/wait.py b/.venv/lib/python3.13/site-packages/urllib3/util/wait.py
new file mode 100644
index 0000000000000000000000000000000000000000..aeca0c7ad5b232eeb1ad9c43d315bd1d74eaed9a
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/urllib3/util/wait.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import select
+import socket
+from functools import partial
+
+__all__ = ["wait_for_read", "wait_for_write"]
+
+
+# How should we wait on sockets?
+#
+# There are two types of APIs you can use for waiting on sockets: the fancy
+# modern stateful APIs like epoll/kqueue, and the older stateless APIs like
+# select/poll. The stateful APIs are more efficient when you have a lots of
+# sockets to keep track of, because you can set them up once and then use them
+# lots of times. But we only ever want to wait on a single socket at a time
+# and don't want to keep track of state, so the stateless APIs are actually
+# more efficient. So we want to use select() or poll().
+#
+# Now, how do we choose between select() and poll()? On traditional Unixes,
+# select() has a strange calling convention that makes it slow, or fail
+# altogether, for high-numbered file descriptors. The point of poll() is to fix
+# that, so on Unixes, we prefer poll().
+#
+# On Windows, there is no poll() (or at least Python doesn't provide a wrapper
+# for it), but that's OK, because on Windows, select() doesn't have this
+# strange calling convention; plain select() works fine.
+#
+# So: on Windows we use select(), and everywhere else we use poll(). We also
+# fall back to select() in case poll() is somehow broken or missing.
+
+
+def select_wait_for_socket(
+    sock: socket.socket,
+    read: bool = False,
+    write: bool = False,
+    timeout: float | None = None,
+) -> bool:
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    rcheck = []
+    wcheck = []
+    if read:
+        rcheck.append(sock)
+    if write:
+        wcheck.append(sock)
+    # When doing a non-blocking connect, most systems signal success by
+    # marking the socket writable. Windows, though, signals success by marked
+    # it as "exceptional". We paper over the difference by checking the write
+    # sockets for both conditions. (The stdlib selectors module does the same
+    # thing.)
+    fn = partial(select.select, rcheck, wcheck, wcheck)
+    rready, wready, xready = fn(timeout)
+    return bool(rready or wready or xready)
+
+
+def poll_wait_for_socket(
+    sock: socket.socket,
+    read: bool = False,
+    write: bool = False,
+    timeout: float | None = None,
+) -> bool:
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    mask = 0
+    if read:
+        mask |= select.POLLIN
+    if write:
+        mask |= select.POLLOUT
+    poll_obj = select.poll()
+    poll_obj.register(sock, mask)
+
+    # For some reason, poll() takes timeout in milliseconds
+    def do_poll(t: float | None) -> list[tuple[int, int]]:
+        if t is not None:
+            t *= 1000
+        return poll_obj.poll(t)
+
+    return bool(do_poll(timeout))
+
+
+def _have_working_poll() -> bool:
+    # Apparently some systems have a select.poll that fails as soon as you try
+    # to use it, either due to strange configuration or broken monkeypatching
+    # from libraries like eventlet/greenlet.
+    try:
+        poll_obj = select.poll()
+        poll_obj.poll(0)
+    except (AttributeError, OSError):
+        return False
+    else:
+        return True
+
+
+def wait_for_socket(
+    sock: socket.socket,
+    read: bool = False,
+    write: bool = False,
+    timeout: float | None = None,
+) -> bool:
+    # We delay choosing which implementation to use until the first time we're
+    # called. We could do it at import time, but then we might make the wrong
+    # decision if someone goes wild with monkeypatching select.poll after
+    # we're imported.
+    global wait_for_socket
+    if _have_working_poll():
+        wait_for_socket = poll_wait_for_socket
+    elif hasattr(select, "select"):
+        wait_for_socket = select_wait_for_socket
+    return wait_for_socket(sock, read, write, timeout)
+
+
+def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool:
+    """Waits for reading to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, read=True, timeout=timeout)
+
+
+def wait_for_write(sock: socket.socket, timeout: float | None = None) -> bool:
+    """Waits for writing to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, write=True, timeout=timeout)
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/__init__.py b/.venv/lib/python3.13/site-packages/wcwidth/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d686b30e1b6c1932f7ba3427e88f0c69dec44541
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/__init__.py
@@ -0,0 +1,29 @@
+"""
+Wcwidth module.
+
+https://github.com/jquast/wcwidth
+"""
+# re-export all functions & definitions, even private ones, from top-level
+# module path, to allow for 'from wcwidth import _private_func'.  Of course,
+# user beware that any _private function may disappear or change signature at
+# any future version.
+
+# local
+from .wcwidth import ZERO_WIDTH  # noqa
+from .wcwidth import (WIDE_EASTASIAN,
+                      VS16_NARROW_TO_WIDE,
+                      wcwidth,
+                      wcswidth,
+                      _bisearch,
+                      list_versions,
+                      _wcmatch_version,
+                      _wcversion_value)
+
+# The __all__ attribute defines the items exported from statement,
+# 'from wcwidth import *', but also to say, "This is the public API".
+__all__ = ('wcwidth', 'wcswidth', 'list_versions')
+
+# We also used pkg_resources to load unicode version tables from version.json,
+# generated by bin/update-tables.py, but some environments are unable to
+# import pkg_resources for one reason or another, yikes!
+__version__ = '0.2.13'
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/table_vs16.py b/.venv/lib/python3.13/site-packages/wcwidth/table_vs16.py
new file mode 100644
index 0000000000000000000000000000000000000000..3249262d981b5ab2bc21dd87f110cd1e73d9c67b
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/table_vs16.py
@@ -0,0 +1,125 @@
+"""
+Exports VS16_NARROW_TO_WIDE table keyed by supporting unicode version level.
+
+This code generated by wcwidth/bin/update-tables.py on 2023-11-07 16:43:49 UTC.
+"""
+VS16_NARROW_TO_WIDE = {
+    '9.0.0': (
+        # Source: 9.0.0
+        # Date: 2023-02-01, 02:22:54 GMT
+        #
+        (0x00023, 0x00023,),  # Number Sign
+        (0x0002a, 0x0002a,),  # Asterisk
+        (0x00030, 0x00039,),  # Digit Zero              ..Digit Nine
+        (0x000a9, 0x000a9,),  # Copyright Sign
+        (0x000ae, 0x000ae,),  # Registered Sign
+        (0x0203c, 0x0203c,),  # Double Exclamation Mark
+        (0x02049, 0x02049,),  # Exclamation Question Mark
+        (0x02122, 0x02122,),  # Trade Mark Sign
+        (0x02139, 0x02139,),  # Information Source
+        (0x02194, 0x02199,),  # Left Right Arrow        ..South West Arrow
+        (0x021a9, 0x021aa,),  # Leftwards Arrow With Hoo..Rightwards Arrow With Ho
+        (0x02328, 0x02328,),  # Keyboard
+        (0x023cf, 0x023cf,),  # Eject Symbol
+        (0x023ed, 0x023ef,),  # Black Right-pointing Dou..Black Right-pointing Tri
+        (0x023f1, 0x023f2,),  # Stopwatch               ..Timer Clock
+        (0x023f8, 0x023fa,),  # Double Vertical Bar     ..Black Circle For Record
+        (0x024c2, 0x024c2,),  # Circled Latin Capital Letter M
+        (0x025aa, 0x025ab,),  # Black Small Square      ..White Small Square
+        (0x025b6, 0x025b6,),  # Black Right-pointing Triangle
+        (0x025c0, 0x025c0,),  # Black Left-pointing Triangle
+        (0x025fb, 0x025fc,),  # White Medium Square     ..Black Medium Square
+        (0x02600, 0x02604,),  # Black Sun With Rays     ..Comet
+        (0x0260e, 0x0260e,),  # Black Telephone
+        (0x02611, 0x02611,),  # Ballot Box With Check
+        (0x02618, 0x02618,),  # Shamrock
+        (0x0261d, 0x0261d,),  # White Up Pointing Index
+        (0x02620, 0x02620,),  # Skull And Crossbones
+        (0x02622, 0x02623,),  # Radioactive Sign        ..Biohazard Sign
+        (0x02626, 0x02626,),  # Orthodox Cross
+        (0x0262a, 0x0262a,),  # Star And Crescent
+        (0x0262e, 0x0262f,),  # Peace Symbol            ..Yin Yang
+        (0x02638, 0x0263a,),  # Wheel Of Dharma         ..White Smiling Face
+        (0x02640, 0x02640,),  # Female Sign
+        (0x02642, 0x02642,),  # Male Sign
+        (0x0265f, 0x02660,),  # Black Chess Pawn        ..Black Spade Suit
+        (0x02663, 0x02663,),  # Black Club Suit
+        (0x02665, 0x02666,),  # Black Heart Suit        ..Black Diamond Suit
+        (0x02668, 0x02668,),  # Hot Springs
+        (0x0267b, 0x0267b,),  # Black Universal Recycling Symbol
+        (0x0267e, 0x0267e,),  # Permanent Paper Sign
+        (0x02692, 0x02692,),  # Hammer And Pick
+        (0x02694, 0x02697,),  # Crossed Swords          ..Alembic
+        (0x02699, 0x02699,),  # Gear
+        (0x0269b, 0x0269c,),  # Atom Symbol             ..Fleur-de-lis
+        (0x026a0, 0x026a0,),  # Warning Sign
+        (0x026a7, 0x026a7,),  # Male With Stroke And Male And Female Sign
+        (0x026b0, 0x026b1,),  # Coffin                  ..Funeral Urn
+        (0x026c8, 0x026c8,),  # Thunder Cloud And Rain
+        (0x026cf, 0x026cf,),  # Pick
+        (0x026d1, 0x026d1,),  # Helmet With White Cross
+        (0x026d3, 0x026d3,),  # Chains
+        (0x026e9, 0x026e9,),  # Shinto Shrine
+        (0x026f0, 0x026f1,),  # Mountain                ..Umbrella On Ground
+        (0x026f4, 0x026f4,),  # Ferry
+        (0x026f7, 0x026f9,),  # Skier                   ..Person With Ball
+        (0x02702, 0x02702,),  # Black Scissors
+        (0x02708, 0x02709,),  # Airplane                ..Envelope
+        (0x0270c, 0x0270d,),  # Victory Hand            ..Writing Hand
+        (0x0270f, 0x0270f,),  # Pencil
+        (0x02712, 0x02712,),  # Black Nib
+        (0x02714, 0x02714,),  # Heavy Check Mark
+        (0x02716, 0x02716,),  # Heavy Multiplication X
+        (0x0271d, 0x0271d,),  # Latin Cross
+        (0x02721, 0x02721,),  # Star Of David
+        (0x02733, 0x02734,),  # Eight Spoked Asterisk   ..Eight Pointed Black Star
+        (0x02744, 0x02744,),  # Snowflake
+        (0x02747, 0x02747,),  # Sparkle
+        (0x02763, 0x02764,),  # Heavy Heart Exclamation ..Heavy Black Heart
+        (0x027a1, 0x027a1,),  # Black Rightwards Arrow
+        (0x02934, 0x02935,),  # Arrow Pointing Rightward..Arrow Pointing Rightward
+        (0x02b05, 0x02b07,),  # Leftwards Black Arrow   ..Downwards Black Arrow
+        (0x1f170, 0x1f171,),  # Negative Squared Latin C..Negative Squared Latin C
+        (0x1f17e, 0x1f17f,),  # Negative Squared Latin C..Negative Squared Latin C
+        (0x1f321, 0x1f321,),  # Thermometer
+        (0x1f324, 0x1f32c,),  # White Sun With Small Clo..Wind Blowing Face
+        (0x1f336, 0x1f336,),  # Hot Pepper
+        (0x1f37d, 0x1f37d,),  # Fork And Knife With Plate
+        (0x1f396, 0x1f397,),  # Military Medal          ..Reminder Ribbon
+        (0x1f399, 0x1f39b,),  # Studio Microphone       ..Control Knobs
+        (0x1f39e, 0x1f39f,),  # Film Frames             ..Admission Tickets
+        (0x1f3cb, 0x1f3ce,),  # Weight Lifter           ..Racing Car
+        (0x1f3d4, 0x1f3df,),  # Snow Capped Mountain    ..Stadium
+        (0x1f3f3, 0x1f3f3,),  # Waving White Flag
+        (0x1f3f5, 0x1f3f5,),  # Rosette
+        (0x1f3f7, 0x1f3f7,),  # Label
+        (0x1f43f, 0x1f43f,),  # Chipmunk
+        (0x1f441, 0x1f441,),  # Eye
+        (0x1f4fd, 0x1f4fd,),  # Film Projector
+        (0x1f549, 0x1f54a,),  # Om Symbol               ..Dove Of Peace
+        (0x1f56f, 0x1f570,),  # Candle                  ..Mantelpiece Clock
+        (0x1f573, 0x1f579,),  # Hole                    ..Joystick
+        (0x1f587, 0x1f587,),  # Linked Paperclips
+        (0x1f58a, 0x1f58d,),  # Lower Left Ballpoint Pen..Lower Left Crayon
+        (0x1f590, 0x1f590,),  # Raised Hand With Fingers Splayed
+        (0x1f5a5, 0x1f5a5,),  # Desktop Computer
+        (0x1f5a8, 0x1f5a8,),  # Printer
+        (0x1f5b1, 0x1f5b2,),  # Three Button Mouse      ..Trackball
+        (0x1f5bc, 0x1f5bc,),  # Frame With Picture
+        (0x1f5c2, 0x1f5c4,),  # Card Index Dividers     ..File Cabinet
+        (0x1f5d1, 0x1f5d3,),  # Wastebasket             ..Spiral Calendar Pad
+        (0x1f5dc, 0x1f5de,),  # Compression             ..Rolled-up Newspaper
+        (0x1f5e1, 0x1f5e1,),  # Dagger Knife
+        (0x1f5e3, 0x1f5e3,),  # Speaking Head In Silhouette
+        (0x1f5e8, 0x1f5e8,),  # Left Speech Bubble
+        (0x1f5ef, 0x1f5ef,),  # Right Anger Bubble
+        (0x1f5f3, 0x1f5f3,),  # Ballot Box With Ballot
+        (0x1f5fa, 0x1f5fa,),  # World Map
+        (0x1f6cb, 0x1f6cb,),  # Couch And Lamp
+        (0x1f6cd, 0x1f6cf,),  # Shopping Bags           ..Bed
+        (0x1f6e0, 0x1f6e5,),  # Hammer And Wrench       ..Motor Boat
+        (0x1f6e9, 0x1f6e9,),  # Small Airplane
+        (0x1f6f0, 0x1f6f0,),  # Satellite
+        (0x1f6f3, 0x1f6f3,),  # Passenger Ship
+    ),
+}
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/table_wide.py b/.venv/lib/python3.13/site-packages/wcwidth/table_wide.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd6dfdd82a032d60ede24530b3d83108f76a6c90
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/table_wide.py
@@ -0,0 +1,1493 @@
+"""
+Exports WIDE_EASTASIAN table keyed by supporting unicode version level.
+
+This code generated by wcwidth/bin/update-tables.py on 2024-01-06 01:39:49 UTC.
+"""
+WIDE_EASTASIAN = {
+    '4.1.0': (
+        # Source: EastAsianWidth-4.1.0.txt
+        # Date: 2005-03-17, 15:21:00 PST [KW]
+        #
+        (0x01100, 0x01159,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Yeorinhi
+        (0x0115f, 0x0115f,),  # Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312c,),  # Bopomofo Letter B       ..Bopomofo Letter Gn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031b7,),  # Ideographic Annotation L..Bopomofo Final Letter H
+        (0x031c0, 0x031cf,),  # Cjk Stroke T            ..Cjk Stroke N
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03243,),  # Parenthesized Ideograph ..Parenthesized Ideograph
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04db5,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x09fbb,),  # Cjk Unified Ideograph-4e..Cjk Unified Ideograph-9f
+        (0x0a000, 0x0a48c,),  # Yi Syllable It          ..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0fa2d,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa30, 0x0fa6a,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa70, 0x0fad9,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '5.0.0': (
+        # Source: EastAsianWidth-5.0.0.txt
+        # Date: 2006-02-15, 14:39:00 PST [KW]
+        #
+        (0x01100, 0x01159,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Yeorinhi
+        (0x0115f, 0x0115f,),  # Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312c,),  # Bopomofo Letter B       ..Bopomofo Letter Gn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031b7,),  # Ideographic Annotation L..Bopomofo Final Letter H
+        (0x031c0, 0x031cf,),  # Cjk Stroke T            ..Cjk Stroke N
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03243,),  # Parenthesized Ideograph ..Parenthesized Ideograph
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04db5,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x09fbb,),  # Cjk Unified Ideograph-4e..Cjk Unified Ideograph-9f
+        (0x0a000, 0x0a48c,),  # Yi Syllable It          ..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0fa2d,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa30, 0x0fa6a,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa70, 0x0fad9,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '5.1.0': (
+        # Source: EastAsianWidth-5.1.0.txt
+        # Date: 2008-03-20, 17:42:00 PDT [KW]
+        #
+        (0x01100, 0x01159,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Yeorinhi
+        (0x0115f, 0x0115f,),  # Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031b7,),  # Ideographic Annotation L..Bopomofo Final Letter H
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03243,),  # Parenthesized Ideograph ..Parenthesized Ideograph
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04db5,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x09fc3,),  # Cjk Unified Ideograph-4e..Cjk Unified Ideograph-9f
+        (0x0a000, 0x0a48c,),  # Yi Syllable It          ..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0fa2d,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa30, 0x0fa6a,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fa70, 0x0fad9,),  # Cjk Compatibility Ideogr..Cjk Compatibility Ideogr
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '5.2.0': (
+        # Source: EastAsianWidth-5.2.0.txt
+        # Date: 2009-06-09, 17:47:00 PDT [KW]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031b7,),  # Ideographic Annotation L..Bopomofo Final Letter H
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1f200, 0x1f200,),  # Square Hiragana Hoka
+        (0x1f210, 0x1f231,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '6.0.0': (
+        # Source: EastAsianWidth-6.0.0.txt
+        # Date: 2010-08-17, 12:17:00 PDT [KW]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '6.1.0': (
+        # Source: EastAsianWidth-6.1.0.txt
+        # Date: 2011-09-19, 18:46:00 GMT [KW]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '6.2.0': (
+        # Source: EastAsianWidth-6.2.0.txt
+        # Date: 2012-05-15, 18:30:00 GMT [KW]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '6.3.0': (
+        # Source: EastAsianWidth-6.3.0.txt
+        # Date: 2013-02-05, 20:09:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '7.0.0': (
+        # Source: EastAsianWidth-7.0.0.txt
+        # Date: 2014-02-28, 23:15:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '8.0.0': (
+        # Source: EastAsianWidth-8.0.0.txt
+        # Date: 2015-02-10, 21:00:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23a,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '9.0.0': (
+        # Source: EastAsianWidth-9.0.0.txt
+        # Date: 2016-05-27, 17:00:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312d,),  # Bopomofo Letter B       ..Bopomofo Letter Ih
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe0,),  # Tangut Iteration Mark
+        (0x17000, 0x187ec,),  # (nil)
+        (0x18800, 0x18af2,),  # Tangut Component-001    ..Tangut Component-755
+        (0x1b000, 0x1b001,),  # Katakana Letter Archaic ..Hiragana Letter Archaic
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6f6,),  # Scooter                 ..Canoe
+        (0x1f910, 0x1f91e,),  # Zipper-mouth Face       ..Hand With Index And Midd
+        (0x1f920, 0x1f927,),  # Face With Cowboy Hat    ..Sneezing Face
+        (0x1f930, 0x1f930,),  # Pregnant Woman
+        (0x1f933, 0x1f93e,),  # Selfie                  ..Handball
+        (0x1f940, 0x1f94b,),  # Wilted Flower           ..Martial Arts Uniform
+        (0x1f950, 0x1f95e,),  # Croissant               ..Pancakes
+        (0x1f980, 0x1f991,),  # Crab                    ..Squid
+        (0x1f9c0, 0x1f9c0,),  # Cheese Wedge
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '10.0.0': (
+        # Source: EastAsianWidth-10.0.0.txt
+        # Date: 2017-03-08, 02:00:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312e,),  # Bopomofo Letter B       ..Bopomofo Letter O With D
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe1,),  # Tangut Iteration Mark   ..Nushu Iteration Mark
+        (0x17000, 0x187ec,),  # (nil)
+        (0x18800, 0x18af2,),  # Tangut Component-001    ..Tangut Component-755
+        (0x1b000, 0x1b11e,),  # Katakana Letter Archaic ..Hentaigana Letter N-mu-m
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6f8,),  # Scooter                 ..Flying Saucer
+        (0x1f910, 0x1f93e,),  # Zipper-mouth Face       ..Handball
+        (0x1f940, 0x1f94c,),  # Wilted Flower           ..Curling Stone
+        (0x1f950, 0x1f96b,),  # Croissant               ..Canned Food
+        (0x1f980, 0x1f997,),  # Crab                    ..Cricket
+        (0x1f9c0, 0x1f9c0,),  # Cheese Wedge
+        (0x1f9d0, 0x1f9e6,),  # Face With Monocle       ..Socks
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '11.0.0': (
+        # Source: EastAsianWidth-11.0.0.txt
+        # Date: 2018-05-14, 09:41:59 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe1,),  # Tangut Iteration Mark   ..Nushu Iteration Mark
+        (0x17000, 0x187f1,),  # (nil)
+        (0x18800, 0x18af2,),  # Tangut Component-001    ..Tangut Component-755
+        (0x1b000, 0x1b11e,),  # Katakana Letter Archaic ..Hentaigana Letter N-mu-m
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6f9,),  # Scooter                 ..Skateboard
+        (0x1f910, 0x1f93e,),  # Zipper-mouth Face       ..Handball
+        (0x1f940, 0x1f970,),  # Wilted Flower           ..Smiling Face With Smilin
+        (0x1f973, 0x1f976,),  # Face With Party Horn And..Freezing Face
+        (0x1f97a, 0x1f97a,),  # Face With Pleading Eyes
+        (0x1f97c, 0x1f9a2,),  # Lab Coat                ..Swan
+        (0x1f9b0, 0x1f9b9,),  # Emoji Component Red Hair..Supervillain
+        (0x1f9c0, 0x1f9c2,),  # Cheese Wedge            ..Salt Shaker
+        (0x1f9d0, 0x1f9ff,),  # Face With Monocle       ..Nazar Amulet
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '12.0.0': (
+        # Source: EastAsianWidth-12.0.0.txt
+        # Date: 2019-01-21, 14:12:58 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x032fe,),  # Partnership Sign        ..Circled Katakana Wo
+        (0x03300, 0x04dbf,),  # Square Apaato           ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18af2,),  # Tangut Component-001    ..Tangut Component-755
+        (0x1b000, 0x1b11e,),  # Katakana Letter Archaic ..Hentaigana Letter N-mu-m
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d5,),  # Hindu Temple
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fa,),  # Scooter                 ..Auto Rickshaw
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f90d, 0x1f971,),  # White Heart             ..Yawning Face
+        (0x1f973, 0x1f976,),  # Face With Party Horn And..Freezing Face
+        (0x1f97a, 0x1f9a2,),  # Face With Pleading Eyes ..Swan
+        (0x1f9a5, 0x1f9aa,),  # Sloth                   ..Oyster
+        (0x1f9ae, 0x1f9ca,),  # Guide Dog               ..Ice Cube
+        (0x1f9cd, 0x1f9ff,),  # Standing Person         ..Nazar Amulet
+        (0x1fa70, 0x1fa73,),  # Ballet Shoes            ..Shorts
+        (0x1fa78, 0x1fa7a,),  # Drop Of Blood           ..Stethoscope
+        (0x1fa80, 0x1fa82,),  # Yo-yo                   ..Parachute
+        (0x1fa90, 0x1fa95,),  # Ringed Planet           ..Banjo
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '12.1.0': (
+        # Source: EastAsianWidth-12.1.0.txt
+        # Date: 2019-03-31, 22:01:58 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031ba,),  # Ideographic Annotation L..Bopomofo Letter Zy
+        (0x031c0, 0x031e3,),  # Cjk Stroke T            ..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x04dbf,),  # Partnership Sign        ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18af2,),  # Tangut Component-001    ..Tangut Component-755
+        (0x1b000, 0x1b11e,),  # Katakana Letter Archaic ..Hentaigana Letter N-mu-m
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d5,),  # Hindu Temple
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fa,),  # Scooter                 ..Auto Rickshaw
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f90d, 0x1f971,),  # White Heart             ..Yawning Face
+        (0x1f973, 0x1f976,),  # Face With Party Horn And..Freezing Face
+        (0x1f97a, 0x1f9a2,),  # Face With Pleading Eyes ..Swan
+        (0x1f9a5, 0x1f9aa,),  # Sloth                   ..Oyster
+        (0x1f9ae, 0x1f9ca,),  # Guide Dog               ..Ice Cube
+        (0x1f9cd, 0x1f9ff,),  # Standing Person         ..Nazar Amulet
+        (0x1fa70, 0x1fa73,),  # Ballet Shoes            ..Shorts
+        (0x1fa78, 0x1fa7a,),  # Drop Of Blood           ..Stethoscope
+        (0x1fa80, 0x1fa82,),  # Yo-yo                   ..Parachute
+        (0x1fa90, 0x1fa95,),  # Ringed Planet           ..Banjo
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '13.0.0': (
+        # Source: EastAsianWidth-13.0.0.txt
+        # Date: 2029-01-21, 18:14:00 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031e3,),  # Ideographic Annotation L..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x04dbf,),  # Partnership Sign        ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18cd5,),  # Tangut Component-001    ..Khitan Small Script Char
+        (0x18d00, 0x18d08,),  # (nil)
+        (0x1b000, 0x1b11e,),  # Katakana Letter Archaic ..Hentaigana Letter N-mu-m
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d7,),  # Hindu Temple            ..Elevator
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fc,),  # Scooter                 ..Roller Skate
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f90c, 0x1f93a,),  # Pinched Fingers         ..Fencer
+        (0x1f93c, 0x1f945,),  # Wrestlers               ..Goal Net
+        (0x1f947, 0x1f978,),  # First Place Medal       ..Disguised Face
+        (0x1f97a, 0x1f9cb,),  # Face With Pleading Eyes ..Bubble Tea
+        (0x1f9cd, 0x1f9ff,),  # Standing Person         ..Nazar Amulet
+        (0x1fa70, 0x1fa74,),  # Ballet Shoes            ..Thong Sandal
+        (0x1fa78, 0x1fa7a,),  # Drop Of Blood           ..Stethoscope
+        (0x1fa80, 0x1fa86,),  # Yo-yo                   ..Nesting Dolls
+        (0x1fa90, 0x1faa8,),  # Ringed Planet           ..Rock
+        (0x1fab0, 0x1fab6,),  # Fly                     ..Feather
+        (0x1fac0, 0x1fac2,),  # Anatomical Heart        ..People Hugging
+        (0x1fad0, 0x1fad6,),  # Blueberries             ..Teapot
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '14.0.0': (
+        # Source: EastAsianWidth-14.0.0.txt
+        # Date: 2021-07-06, 09:58:53 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031e3,),  # Ideographic Annotation L..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x04dbf,),  # Partnership Sign        ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18cd5,),  # Tangut Component-001    ..Khitan Small Script Char
+        (0x18d00, 0x18d08,),  # (nil)
+        (0x1aff0, 0x1aff3,),  # Katakana Letter Minnan T..Katakana Letter Minnan T
+        (0x1aff5, 0x1affb,),  # Katakana Letter Minnan T..Katakana Letter Minnan N
+        (0x1affd, 0x1affe,),  # Katakana Letter Minnan N..Katakana Letter Minnan N
+        (0x1b000, 0x1b122,),  # Katakana Letter Archaic ..Katakana Letter Archaic
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d7,),  # Hindu Temple            ..Elevator
+        (0x1f6dd, 0x1f6df,),  # Playground Slide        ..Ring Buoy
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fc,),  # Scooter                 ..Roller Skate
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f7f0, 0x1f7f0,),  # Heavy Equals Sign
+        (0x1f90c, 0x1f93a,),  # Pinched Fingers         ..Fencer
+        (0x1f93c, 0x1f945,),  # Wrestlers               ..Goal Net
+        (0x1f947, 0x1f9ff,),  # First Place Medal       ..Nazar Amulet
+        (0x1fa70, 0x1fa74,),  # Ballet Shoes            ..Thong Sandal
+        (0x1fa78, 0x1fa7c,),  # Drop Of Blood           ..Crutch
+        (0x1fa80, 0x1fa86,),  # Yo-yo                   ..Nesting Dolls
+        (0x1fa90, 0x1faac,),  # Ringed Planet           ..Hamsa
+        (0x1fab0, 0x1faba,),  # Fly                     ..Nest With Eggs
+        (0x1fac0, 0x1fac5,),  # Anatomical Heart        ..Person With Crown
+        (0x1fad0, 0x1fad9,),  # Blueberries             ..Jar
+        (0x1fae0, 0x1fae7,),  # Melting Face            ..Bubbles
+        (0x1faf0, 0x1faf6,),  # Hand With Index Finger A..Heart Hands
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '15.0.0': (
+        # Source: EastAsianWidth-15.0.0.txt
+        # Date: 2022-05-24, 17:40:20 GMT [KW, LI]
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x02ffb,),  # Ideographic Description ..Ideographic Description
+        (0x03000, 0x03029,),  # Ideographic Space       ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031e3,),  # Ideographic Annotation L..Cjk Stroke Q
+        (0x031f0, 0x0321e,),  # Katakana Letter Small Ku..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x04dbf,),  # Partnership Sign        ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18cd5,),  # Tangut Component-001    ..Khitan Small Script Char
+        (0x18d00, 0x18d08,),  # (nil)
+        (0x1aff0, 0x1aff3,),  # Katakana Letter Minnan T..Katakana Letter Minnan T
+        (0x1aff5, 0x1affb,),  # Katakana Letter Minnan T..Katakana Letter Minnan N
+        (0x1affd, 0x1affe,),  # Katakana Letter Minnan N..Katakana Letter Minnan N
+        (0x1b000, 0x1b122,),  # Katakana Letter Archaic ..Katakana Letter Archaic
+        (0x1b132, 0x1b132,),  # Hiragana Letter Small Ko
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b155, 0x1b155,),  # Katakana Letter Small Ko
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d7,),  # Hindu Temple            ..Elevator
+        (0x1f6dc, 0x1f6df,),  # Wireless                ..Ring Buoy
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fc,),  # Scooter                 ..Roller Skate
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f7f0, 0x1f7f0,),  # Heavy Equals Sign
+        (0x1f90c, 0x1f93a,),  # Pinched Fingers         ..Fencer
+        (0x1f93c, 0x1f945,),  # Wrestlers               ..Goal Net
+        (0x1f947, 0x1f9ff,),  # First Place Medal       ..Nazar Amulet
+        (0x1fa70, 0x1fa7c,),  # Ballet Shoes            ..Crutch
+        (0x1fa80, 0x1fa88,),  # Yo-yo                   ..Flute
+        (0x1fa90, 0x1fabd,),  # Ringed Planet           ..Wing
+        (0x1fabf, 0x1fac5,),  # Goose                   ..Person With Crown
+        (0x1face, 0x1fadb,),  # Moose                   ..Pea Pod
+        (0x1fae0, 0x1fae8,),  # Melting Face            ..Shaking Face
+        (0x1faf0, 0x1faf8,),  # Hand With Index Finger A..Rightwards Pushing Hand
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+    '15.1.0': (
+        # Source: EastAsianWidth-15.1.0.txt
+        # Date: 2023-07-28, 23:34:08 GMT
+        #
+        (0x01100, 0x0115f,),  # Hangul Choseong Kiyeok  ..Hangul Choseong Filler
+        (0x0231a, 0x0231b,),  # Watch                   ..Hourglass
+        (0x02329, 0x0232a,),  # Left-pointing Angle Brac..Right-pointing Angle Bra
+        (0x023e9, 0x023ec,),  # Black Right-pointing Dou..Black Down-pointing Doub
+        (0x023f0, 0x023f0,),  # Alarm Clock
+        (0x023f3, 0x023f3,),  # Hourglass With Flowing Sand
+        (0x025fd, 0x025fe,),  # White Medium Small Squar..Black Medium Small Squar
+        (0x02614, 0x02615,),  # Umbrella With Rain Drops..Hot Beverage
+        (0x02648, 0x02653,),  # Aries                   ..Pisces
+        (0x0267f, 0x0267f,),  # Wheelchair Symbol
+        (0x02693, 0x02693,),  # Anchor
+        (0x026a1, 0x026a1,),  # High Voltage Sign
+        (0x026aa, 0x026ab,),  # Medium White Circle     ..Medium Black Circle
+        (0x026bd, 0x026be,),  # Soccer Ball             ..Baseball
+        (0x026c4, 0x026c5,),  # Snowman Without Snow    ..Sun Behind Cloud
+        (0x026ce, 0x026ce,),  # Ophiuchus
+        (0x026d4, 0x026d4,),  # No Entry
+        (0x026ea, 0x026ea,),  # Church
+        (0x026f2, 0x026f3,),  # Fountain                ..Flag In Hole
+        (0x026f5, 0x026f5,),  # Sailboat
+        (0x026fa, 0x026fa,),  # Tent
+        (0x026fd, 0x026fd,),  # Fuel Pump
+        (0x02705, 0x02705,),  # White Heavy Check Mark
+        (0x0270a, 0x0270b,),  # Raised Fist             ..Raised Hand
+        (0x02728, 0x02728,),  # Sparkles
+        (0x0274c, 0x0274c,),  # Cross Mark
+        (0x0274e, 0x0274e,),  # Negative Squared Cross Mark
+        (0x02753, 0x02755,),  # Black Question Mark Orna..White Exclamation Mark O
+        (0x02757, 0x02757,),  # Heavy Exclamation Mark Symbol
+        (0x02795, 0x02797,),  # Heavy Plus Sign         ..Heavy Division Sign
+        (0x027b0, 0x027b0,),  # Curly Loop
+        (0x027bf, 0x027bf,),  # Double Curly Loop
+        (0x02b1b, 0x02b1c,),  # Black Large Square      ..White Large Square
+        (0x02b50, 0x02b50,),  # White Medium Star
+        (0x02b55, 0x02b55,),  # Heavy Large Circle
+        (0x02e80, 0x02e99,),  # Cjk Radical Repeat      ..Cjk Radical Rap
+        (0x02e9b, 0x02ef3,),  # Cjk Radical Choke       ..Cjk Radical C-simplified
+        (0x02f00, 0x02fd5,),  # Kangxi Radical One      ..Kangxi Radical Flute
+        (0x02ff0, 0x03029,),  # Ideographic Description ..Hangzhou Numeral Nine
+        (0x03030, 0x0303e,),  # Wavy Dash               ..Ideographic Variation In
+        (0x03041, 0x03096,),  # Hiragana Letter Small A ..Hiragana Letter Small Ke
+        (0x0309b, 0x030ff,),  # Katakana-hiragana Voiced..Katakana Digraph Koto
+        (0x03105, 0x0312f,),  # Bopomofo Letter B       ..Bopomofo Letter Nn
+        (0x03131, 0x0318e,),  # Hangul Letter Kiyeok    ..Hangul Letter Araeae
+        (0x03190, 0x031e3,),  # Ideographic Annotation L..Cjk Stroke Q
+        (0x031ef, 0x0321e,),  # (nil)                   ..Parenthesized Korean Cha
+        (0x03220, 0x03247,),  # Parenthesized Ideograph ..Circled Ideograph Koto
+        (0x03250, 0x04dbf,),  # Partnership Sign        ..Cjk Unified Ideograph-4d
+        (0x04e00, 0x0a48c,),  # Cjk Unified Ideograph-4e..Yi Syllable Yyr
+        (0x0a490, 0x0a4c6,),  # Yi Radical Qot          ..Yi Radical Ke
+        (0x0a960, 0x0a97c,),  # Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo
+        (0x0ac00, 0x0d7a3,),  # Hangul Syllable Ga      ..Hangul Syllable Hih
+        (0x0f900, 0x0faff,),  # Cjk Compatibility Ideogr..(nil)
+        (0x0fe10, 0x0fe19,),  # Presentation Form For Ve..Presentation Form For Ve
+        (0x0fe30, 0x0fe52,),  # Presentation Form For Ve..Small Full Stop
+        (0x0fe54, 0x0fe66,),  # Small Semicolon         ..Small Equals Sign
+        (0x0fe68, 0x0fe6b,),  # Small Reverse Solidus   ..Small Commercial At
+        (0x0ff01, 0x0ff60,),  # Fullwidth Exclamation Ma..Fullwidth Right White Pa
+        (0x0ffe0, 0x0ffe6,),  # Fullwidth Cent Sign     ..Fullwidth Won Sign
+        (0x16fe0, 0x16fe3,),  # Tangut Iteration Mark   ..Old Chinese Iteration Ma
+        (0x17000, 0x187f7,),  # (nil)
+        (0x18800, 0x18cd5,),  # Tangut Component-001    ..Khitan Small Script Char
+        (0x18d00, 0x18d08,),  # (nil)
+        (0x1aff0, 0x1aff3,),  # Katakana Letter Minnan T..Katakana Letter Minnan T
+        (0x1aff5, 0x1affb,),  # Katakana Letter Minnan T..Katakana Letter Minnan N
+        (0x1affd, 0x1affe,),  # Katakana Letter Minnan N..Katakana Letter Minnan N
+        (0x1b000, 0x1b122,),  # Katakana Letter Archaic ..Katakana Letter Archaic
+        (0x1b132, 0x1b132,),  # Hiragana Letter Small Ko
+        (0x1b150, 0x1b152,),  # Hiragana Letter Small Wi..Hiragana Letter Small Wo
+        (0x1b155, 0x1b155,),  # Katakana Letter Small Ko
+        (0x1b164, 0x1b167,),  # Katakana Letter Small Wi..Katakana Letter Small N
+        (0x1b170, 0x1b2fb,),  # Nushu Character-1b170   ..Nushu Character-1b2fb
+        (0x1f004, 0x1f004,),  # Mahjong Tile Red Dragon
+        (0x1f0cf, 0x1f0cf,),  # Playing Card Black Joker
+        (0x1f18e, 0x1f18e,),  # Negative Squared Ab
+        (0x1f191, 0x1f19a,),  # Squared Cl              ..Squared Vs
+        (0x1f200, 0x1f202,),  # Square Hiragana Hoka    ..Squared Katakana Sa
+        (0x1f210, 0x1f23b,),  # Squared Cjk Unified Ideo..Squared Cjk Unified Ideo
+        (0x1f240, 0x1f248,),  # Tortoise Shell Bracketed..Tortoise Shell Bracketed
+        (0x1f250, 0x1f251,),  # Circled Ideograph Advant..Circled Ideograph Accept
+        (0x1f260, 0x1f265,),  # Rounded Symbol For Fu   ..Rounded Symbol For Cai
+        (0x1f300, 0x1f320,),  # Cyclone                 ..Shooting Star
+        (0x1f32d, 0x1f335,),  # Hot Dog                 ..Cactus
+        (0x1f337, 0x1f37c,),  # Tulip                   ..Baby Bottle
+        (0x1f37e, 0x1f393,),  # Bottle With Popping Cork..Graduation Cap
+        (0x1f3a0, 0x1f3ca,),  # Carousel Horse          ..Swimmer
+        (0x1f3cf, 0x1f3d3,),  # Cricket Bat And Ball    ..Table Tennis Paddle And
+        (0x1f3e0, 0x1f3f0,),  # House Building          ..European Castle
+        (0x1f3f4, 0x1f3f4,),  # Waving Black Flag
+        (0x1f3f8, 0x1f3fa,),  # Badminton Racquet And Sh..Amphora
+        (0x1f400, 0x1f43e,),  # Rat                     ..Paw Prints
+        (0x1f440, 0x1f440,),  # Eyes
+        (0x1f442, 0x1f4fc,),  # Ear                     ..Videocassette
+        (0x1f4ff, 0x1f53d,),  # Prayer Beads            ..Down-pointing Small Red
+        (0x1f54b, 0x1f54e,),  # Kaaba                   ..Menorah With Nine Branch
+        (0x1f550, 0x1f567,),  # Clock Face One Oclock   ..Clock Face Twelve-thirty
+        (0x1f57a, 0x1f57a,),  # Man Dancing
+        (0x1f595, 0x1f596,),  # Reversed Hand With Middl..Raised Hand With Part Be
+        (0x1f5a4, 0x1f5a4,),  # Black Heart
+        (0x1f5fb, 0x1f64f,),  # Mount Fuji              ..Person With Folded Hands
+        (0x1f680, 0x1f6c5,),  # Rocket                  ..Left Luggage
+        (0x1f6cc, 0x1f6cc,),  # Sleeping Accommodation
+        (0x1f6d0, 0x1f6d2,),  # Place Of Worship        ..Shopping Trolley
+        (0x1f6d5, 0x1f6d7,),  # Hindu Temple            ..Elevator
+        (0x1f6dc, 0x1f6df,),  # Wireless                ..Ring Buoy
+        (0x1f6eb, 0x1f6ec,),  # Airplane Departure      ..Airplane Arriving
+        (0x1f6f4, 0x1f6fc,),  # Scooter                 ..Roller Skate
+        (0x1f7e0, 0x1f7eb,),  # Large Orange Circle     ..Large Brown Square
+        (0x1f7f0, 0x1f7f0,),  # Heavy Equals Sign
+        (0x1f90c, 0x1f93a,),  # Pinched Fingers         ..Fencer
+        (0x1f93c, 0x1f945,),  # Wrestlers               ..Goal Net
+        (0x1f947, 0x1f9ff,),  # First Place Medal       ..Nazar Amulet
+        (0x1fa70, 0x1fa7c,),  # Ballet Shoes            ..Crutch
+        (0x1fa80, 0x1fa88,),  # Yo-yo                   ..Flute
+        (0x1fa90, 0x1fabd,),  # Ringed Planet           ..Wing
+        (0x1fabf, 0x1fac5,),  # Goose                   ..Person With Crown
+        (0x1face, 0x1fadb,),  # Moose                   ..Pea Pod
+        (0x1fae0, 0x1fae8,),  # Melting Face            ..Shaking Face
+        (0x1faf0, 0x1faf8,),  # Hand With Index Finger A..Rightwards Pushing Hand
+        (0x20000, 0x2fffd,),  # Cjk Unified Ideograph-20..(nil)
+        (0x30000, 0x3fffd,),  # Cjk Unified Ideograph-30..(nil)
+    ),
+}
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/table_zero.py b/.venv/lib/python3.13/site-packages/wcwidth/table_zero.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd422915605df8a364d74893f0e0465b326f3d0a
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/table_zero.py
@@ -0,0 +1,4843 @@
+"""
+Exports ZERO_WIDTH table keyed by supporting unicode version level.
+
+This code generated by wcwidth/bin/update-tables.py on 2024-01-04 07:14:52 UTC.
+"""
+ZERO_WIDTH = {
+    '4.1.0': (
+        # Source: DerivedGeneralCategory-4.1.0.txt
+        # Date: 2005-02-26, 02:35:50 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00486,),  # Combining Cyrillic Titlo..Combining Cyrillic Psili
+        (0x00488, 0x00489,),  # Combining Cyrillic Hundr..Combining Cyrillic Milli
+        (0x00591, 0x005b9,),  # Hebrew Accent Etnahta   ..Hebrew Point Holam
+        (0x005bb, 0x005bd,),  # Hebrew Point Qubuts     ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00603,),  # Arabic Number Sign      ..Arabic Sign Safha
+        (0x00610, 0x00615,),  # Arabic Sign Sallallahou ..Arabic Small High Tah
+        (0x0064b, 0x0065e,),  # Arabic Fathatan         ..Arabic Fatha With Two Do
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006e4,),  # Arabic Small High Ligatu..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x00901, 0x00903,),  # Devanagari Sign Candrabi..Devanagari Sign Visarga
+        (0x0093c, 0x0093c,),  # Devanagari Sign Nukta
+        (0x0093e, 0x0094d,),  # Devanagari Vowel Sign Aa..Devanagari Sign Virama
+        (0x00951, 0x00954,),  # Devanagari Stress Sign U..Devanagari Acute Accent
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b43,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d43,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f90, 0x00f97,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102c, 0x01032,),  # Myanmar Vowel Sign Aa   ..Myanmar Vowel Sign Ai
+        (0x01036, 0x01039,),  # Myanmar Sign Anusvara   ..Myanmar Sign Virama
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135f, 0x0135f,),  # Ethiopic Combining Gemination Mark
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01dc0, 0x01dc3,),  # Combining Dotted Grave A..Combining Suspension Mar
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02063,),  # Word Joiner             ..Invisible Separator
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020eb,),  # Combining Left Harpoon A..Combining Long Double So
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe23,),  # Combining Ligature Left ..Combining Double Tilde R
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '5.0.0': (
+        # Source: DerivedGeneralCategory-5.0.0.txt
+        # Date: 2006-02-27, 23:41:27 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00486,),  # Combining Cyrillic Titlo..Combining Cyrillic Psili
+        (0x00488, 0x00489,),  # Combining Cyrillic Hundr..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00603,),  # Arabic Number Sign      ..Arabic Sign Safha
+        (0x00610, 0x00615,),  # Arabic Sign Sallallahou ..Arabic Small High Tah
+        (0x0064b, 0x0065e,),  # Arabic Fathatan         ..Arabic Fatha With Two Do
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006e4,),  # Arabic Small High Ligatu..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00901, 0x00903,),  # Devanagari Sign Candrabi..Devanagari Sign Visarga
+        (0x0093c, 0x0093c,),  # Devanagari Sign Nukta
+        (0x0093e, 0x0094d,),  # Devanagari Vowel Sign Aa..Devanagari Sign Virama
+        (0x00951, 0x00954,),  # Devanagari Stress Sign U..Devanagari Acute Accent
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b43,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d43,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f90, 0x00f97,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102c, 0x01032,),  # Myanmar Vowel Sign Aa   ..Myanmar Vowel Sign Ai
+        (0x01036, 0x01039,),  # Myanmar Sign Anusvara   ..Myanmar Sign Virama
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135f, 0x0135f,),  # Ethiopic Combining Gemination Mark
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01dc0, 0x01dca,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfe, 0x01dff,),  # Combining Left Arrowhead..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02063,),  # Word Joiner             ..Invisible Separator
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020ef,),  # Combining Left Harpoon A..Combining Right Arrow Be
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe23,),  # Combining Ligature Left ..Combining Double Tilde R
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '5.1.0': (
+        # Source: DerivedGeneralCategory-5.1.0.txt
+        # Date: 2008-03-20, 17:54:57 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00603,),  # Arabic Number Sign      ..Arabic Sign Safha
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0064b, 0x0065e,),  # Arabic Fathatan         ..Arabic Fatha With Two Do
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006e4,),  # Arabic Small High Ligatu..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00901, 0x00903,),  # Devanagari Sign Candrabi..Devanagari Sign Visarga
+        (0x0093c, 0x0093c,),  # Devanagari Sign Nukta
+        (0x0093e, 0x0094d,),  # Devanagari Vowel Sign Aa..Devanagari Sign Virama
+        (0x00951, 0x00954,),  # Devanagari Stress Sign U..Devanagari Acute Accent
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f90, 0x00f97,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135f, 0x0135f,),  # Ethiopic Combining Gemination Mark
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01baa,),  # Sundanese Consonant Sign..Sundanese Sign Pamaaeh
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfe, 0x01dff,),  # Combining Left Arrowhead..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a67c, 0x0a67d,),  # Combining Cyrillic Kavyk..Combining Cyrillic Payer
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '5.2.0': (
+        # Source: DerivedGeneralCategory-5.2.0.txt
+        # Date: 2009-08-22, 04:58:21 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00603,),  # Arabic Number Sign      ..Arabic Sign Safha
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0064b, 0x0065e,),  # Arabic Fathatan         ..Arabic Fatha With Two Do
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006e4,),  # Arabic Small High Ligatu..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00900, 0x00903,),  # Devanagari Sign Inverted..Devanagari Sign Visarga
+        (0x0093c, 0x0093c,),  # Devanagari Sign Nukta
+        (0x0093e, 0x0094e,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Pr
+        (0x00951, 0x00955,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Ca
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f90, 0x00f97,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135f, 0x0135f,),  # Ethiopic Combining Gemination Mark
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01baa,),  # Sundanese Consonant Sign..Sundanese Sign Pamaaeh
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf2,),  # Vedic Sign Ardhavisarga
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfd, 0x01dff,),  # Combining Almost Equal T..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a67c, 0x0a67d,),  # Combining Cyrillic Kavyk..Combining Cyrillic Payer
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7b,),  # Myanmar Sign Pao Karen Tone
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x11080, 0x11082,),  # Kaithi Sign Candrabindu ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '6.0.0': (
+        # Source: DerivedGeneralCategory-6.0.0.txt
+        # Date: 2010-08-19, 00:48:09 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00603,),  # Arabic Number Sign      ..Arabic Sign Safha
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x00900, 0x00903,),  # Devanagari Sign Inverted..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01baa,),  # Sundanese Consonant Sign..Sundanese Sign Pamaaeh
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf2,),  # Vedic Sign Ardhavisarga
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a67c, 0x0a67d,),  # Combining Cyrillic Kavyk..Combining Cyrillic Payer
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7b,),  # Myanmar Sign Pao Karen Tone
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11080, 0x11082,),  # Kaithi Sign Candrabindu ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '6.1.0': (
+        # Source: DerivedGeneralCategory-6.1.0.txt
+        # Date: 2011-11-27, 05:10:22 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00604,),  # Arabic Number Sign      ..Arabic Sign Samvat
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008e4, 0x008fe,),  # Arabic Curly Fatha      ..Arabic Damma With Dot
+        (0x00900, 0x00903,),  # Devanagari Sign Inverted..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69f, 0x0a69f,),  # Combining Cyrillic Letter Iotified E
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7b,),  # Myanmar Sign Pao Karen Tone
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11080, 0x11082,),  # Kaithi Sign Candrabindu ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '6.2.0': (
+        # Source: DerivedGeneralCategory-6.2.0.txt
+        # Date: 2012-05-20, 00:42:34 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00604,),  # Arabic Number Sign      ..Arabic Sign Samvat
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008e4, 0x008fe,),  # Arabic Curly Fatha      ..Arabic Damma With Dot
+        (0x00900, 0x00903,),  # Devanagari Sign Inverted..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180d,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x0206a, 0x0206f,),  # Inhibit Symmetric Swappi..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69f, 0x0a69f,),  # Combining Cyrillic Letter Iotified E
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7b,),  # Myanmar Sign Pao Karen Tone
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11080, 0x11082,),  # Kaithi Sign Candrabindu ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '6.3.0': (
+        # Source: DerivedGeneralCategory-6.3.0.txt
+        # Date: 2013-07-05, 14:08:45 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00604,),  # Arabic Number Sign      ..Arabic Sign Samvat
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008e4, 0x008fe,),  # Arabic Curly Fatha      ..Arabic Damma With Dot
+        (0x00900, 0x00903,),  # Devanagari Sign Inverted..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c01, 0x00c03,),  # Telugu Sign Candrabindu ..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c82, 0x00c83,),  # Kannada Sign Anusvara   ..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d02, 0x00d03,),  # Malayalam Sign Anusvara ..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01dc0, 0x01de6,),  # Combining Dotted Grave A..Combining Latin Small Le
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69f, 0x0a69f,),  # Combining Cyrillic Letter Iotified E
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7b,),  # Myanmar Sign Pao Karen Tone
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe26,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11080, 0x11082,),  # Kaithi Sign Candrabindu ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '7.0.0': (
+        # Source: DerivedGeneralCategory-7.0.0.txt
+        # Date: 2014-02-07, 18:42:12 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008e4, 0x00903,),  # Arabic Curly Fatha      ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c03,),  # Telugu Sign Combining Ca..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d01, 0x00d03,),  # Malayalam Sign Candrabin..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x019b0, 0x019c0,),  # New Tai Lue Vowel Sign V..New Tai Lue Vowel Sign I
+        (0x019c8, 0x019c9,),  # New Tai Lue Tone Mark-1 ..New Tai Lue Tone Mark-2
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01cf8, 0x01cf9,),  # Vedic Tone Ring Above   ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df5,),  # Combining Dotted Grave A..Combining Up Tack Above
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69f, 0x0a69f,),  # Combining Cyrillic Letter Iotified E
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2d,),  # Combining Ligature Left ..Combining Conjoining Mac
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11301, 0x11303,),  # Grantha Sign Candrabindu..Grantha Sign Visarga
+        (0x1133c, 0x1133c,),  # Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '8.0.0': (
+        # Source: DerivedGeneralCategory-8.0.0.txt
+        # Date: 2015-02-13, 13:47:11 GMT [MD]
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008e3, 0x00903,),  # Arabic Turned Damma Belo..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c03,),  # Telugu Sign Combining Ca..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d01, 0x00d03,),  # Malayalam Sign Candrabin..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01cf8, 0x01cf9,),  # Vedic Tone Ring Above   ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df5,),  # Combining Dotted Grave A..Combining Up Tack Above
+        (0x01dfc, 0x01dff,),  # Combining Double Inverte..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c4,),  # Saurashtra Consonant Sig..Saurashtra Sign Virama
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111ca, 0x111cc,),  # Sharada Sign Nukta      ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133c, 0x1133c,),  # Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '9.0.0': (
+        # Source: DerivedGeneralCategory-9.0.0.txt
+        # Date: 2016-06-01, 10:34:26 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d4, 0x00903,),  # Arabic Small High Word A..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c03,),  # Telugu Sign Combining Ca..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d01, 0x00d03,),  # Malayalam Sign Candrabin..Malayalam Sign Visarga
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01cf8, 0x01cf9,),  # Vedic Tone Ring Above   ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df5,),  # Combining Dotted Grave A..Combining Up Tack Above
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111ca, 0x111cc,),  # Sharada Sign Nukta      ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133c, 0x1133c,),  # Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '10.0.0': (
+        # Source: DerivedGeneralCategory-10.0.0.txt
+        # Date: 2017-03-08, 08:41:49 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d4, 0x00903,),  # Arabic Small High Word A..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c03,),  # Telugu Sign Combining Ca..Telugu Sign Visarga
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df9,),  # Combining Dotted Grave A..Combining Wide Inverted
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111ca, 0x111cc,),  # Sharada Sign Nukta      ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133c, 0x1133c,),  # Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '11.0.0': (
+        # Source: DerivedGeneralCategory-11.0.0.txt
+        # Date: 2018-02-21, 05:34:04 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d3, 0x00903,),  # Arabic Small Low Waw    ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00eb9,),  # Lao Vowel Sign I        ..Lao Vowel Sign Uu
+        (0x00ebb, 0x00ebc,),  # Lao Vowel Sign Mai Kon  ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf2, 0x01cf4,),  # Vedic Sign Ardhavisarga ..Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df9,),  # Combining Dotted Grave A..Combining Wide Inverted
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f51, 0x16f7e,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ng
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '12.0.0': (
+        # Source: DerivedGeneralCategory-12.0.0.txt
+        # Date: 2019-01-22, 08:18:28 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d3, 0x00903,),  # Arabic Small Low Waw    ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df9,),  # Combining Dotted Grave A..Combining Wide Inverted
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x13430, 0x13438,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph End
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '12.1.0': (
+        # Source: DerivedGeneralCategory-12.1.0.txt
+        # Date: 2019-03-10, 10:53:08 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d3, 0x00903,),  # Arabic Small Low Waw    ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b56, 0x00b57,),  # Oriya Ai Length Mark    ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d82, 0x00d83,),  # Sinhala Sign Anusvaraya ..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01abe,),  # Combining Doubled Circum..Combining Parentheses Ov
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df9,),  # Combining Dotted Grave A..Combining Wide Inverted
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x13430, 0x13438,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph End
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '13.0.0': (
+        # Source: DerivedGeneralCategory-13.0.0.txt
+        # Date: 2019-10-21, 14:30:32 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x008d3, 0x00903,),  # Arabic Small Low Waw    ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b55, 0x00b57,),  # Oriya Sign Overline     ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d81, 0x00d83,),  # Sinhala Sign Candrabindu..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01714,),  # Tagalog Vowel Sign I    ..Tagalog Sign Virama
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180e,),  # Mongolian Free Variation..Mongolian Vowel Separato
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01ac0,),  # Combining Doubled Circum..Combining Latin Small Le
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01df9,),  # Combining Dotted Grave A..Combining Wide Inverted
+        (0x01dfb, 0x01dff,),  # Combining Deletion Mark ..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a82c, 0x0a82c,),  # Syloti Nagri Sign Alternate Hasanta
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10eab, 0x10eac,),  # Yezidi Combining Hamza M..Yezidi Combining Madda M
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x111ce, 0x111cf,),  # Sharada Vowel Sign Prish..Sharada Sign Inverted Ca
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x11930, 0x11935,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign E
+        (0x11937, 0x11938,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign O
+        (0x1193b, 0x1193e,),  # Dives Akuru Sign Anusvar..Dives Akuru Virama
+        (0x11940, 0x11940,),  # Dives Akuru Medial Ya
+        (0x11942, 0x11943,),  # Dives Akuru Medial Ra   ..Dives Akuru Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x13430, 0x13438,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph End
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x16fe4, 0x16fe4,),  # Khitan Small Script Filler
+        (0x16ff0, 0x16ff1,),  # Vietnamese Alternate Rea..Vietnamese Alternate Rea
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '14.0.0': (
+        # Source: DerivedGeneralCategory-14.0.0.txt
+        # Date: 2021-07-10, 00:35:08 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x00890, 0x00891,),  # Arabic Pound Mark Above ..Arabic Piastre Mark Abov
+        (0x00898, 0x0089f,),  # Arabic Small High Word A..Arabic Half Madda Over M
+        (0x008ca, 0x00903,),  # Arabic Small High Farsi ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b55, 0x00b57,),  # Oriya Sign Overline     ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3c, 0x00c3c,),  # Telugu Sign Nukta
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d81, 0x00d83,),  # Sinhala Sign Candrabindu..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ecd,),  # Lao Tone Mai Ek         ..Lao Niggahita
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01715,),  # Tagalog Vowel Sign I    ..Tagalog Sign Pamudpod
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180f,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01ace,),  # Combining Doubled Circum..Combining Latin Small Le
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01dff,),  # Combining Dotted Grave A..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a82c, 0x0a82c,),  # Syloti Nagri Sign Alternate Hasanta
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10eab, 0x10eac,),  # Yezidi Combining Hamza M..Yezidi Combining Madda M
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x10f82, 0x10f85,),  # Old Uyghur Combining Dot..Old Uyghur Combining Two
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11070, 0x11070,),  # Brahmi Sign Old Tamil Virama
+        (0x11073, 0x11074,),  # Brahmi Vowel Sign Old Ta..Brahmi Vowel Sign Old Ta
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110c2, 0x110c2,),  # Kaithi Vowel Sign Vocalic R
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x111ce, 0x111cf,),  # Sharada Vowel Sign Prish..Sharada Sign Inverted Ca
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x11930, 0x11935,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign E
+        (0x11937, 0x11938,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign O
+        (0x1193b, 0x1193e,),  # Dives Akuru Sign Anusvar..Dives Akuru Virama
+        (0x11940, 0x11940,),  # Dives Akuru Medial Ya
+        (0x11942, 0x11943,),  # Dives Akuru Medial Ra   ..Dives Akuru Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x13430, 0x13438,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph End
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x16fe4, 0x16fe4,),  # Khitan Small Script Filler
+        (0x16ff0, 0x16ff1,),  # Vietnamese Alternate Rea..Vietnamese Alternate Rea
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1cf00, 0x1cf2d,),  # Znamenny Combining Mark ..Znamenny Combining Mark
+        (0x1cf30, 0x1cf46,),  # Znamenny Combining Tonal..Znamenny Priznak Modifie
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ae, 0x1e2ae,),  # Toto Sign Rising Tone
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '15.0.0': (
+        # Source: DerivedGeneralCategory-15.0.0.txt
+        # Date: 2022-04-26, 23:14:35 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x00890, 0x00891,),  # Arabic Pound Mark Above ..Arabic Piastre Mark Abov
+        (0x00898, 0x0089f,),  # Arabic Small High Word A..Arabic Half Madda Over M
+        (0x008ca, 0x00903,),  # Arabic Small High Farsi ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b55, 0x00b57,),  # Oriya Sign Overline     ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3c, 0x00c3c,),  # Telugu Sign Nukta
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00cf3, 0x00cf3,),  # Kannada Sign Combining Anusvara Above Right
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d81, 0x00d83,),  # Sinhala Sign Candrabindu..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ece,),  # Lao Tone Mai Ek         ..Lao Yamakkan
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01715,),  # Tagalog Vowel Sign I    ..Tagalog Sign Pamudpod
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180f,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01ace,),  # Combining Doubled Circum..Combining Latin Small Le
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01dff,),  # Combining Dotted Grave A..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a82c, 0x0a82c,),  # Syloti Nagri Sign Alternate Hasanta
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10eab, 0x10eac,),  # Yezidi Combining Hamza M..Yezidi Combining Madda M
+        (0x10efd, 0x10eff,),  # Arabic Small Low Word Sa..Arabic Small Low Word Ma
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x10f82, 0x10f85,),  # Old Uyghur Combining Dot..Old Uyghur Combining Two
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11070, 0x11070,),  # Brahmi Sign Old Tamil Virama
+        (0x11073, 0x11074,),  # Brahmi Vowel Sign Old Ta..Brahmi Vowel Sign Old Ta
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110c2, 0x110c2,),  # Kaithi Vowel Sign Vocalic R
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x111ce, 0x111cf,),  # Sharada Vowel Sign Prish..Sharada Sign Inverted Ca
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x11241, 0x11241,),  # Khojki Vowel Sign Vocalic R
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x11930, 0x11935,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign E
+        (0x11937, 0x11938,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign O
+        (0x1193b, 0x1193e,),  # Dives Akuru Sign Anusvar..Dives Akuru Virama
+        (0x11940, 0x11940,),  # Dives Akuru Medial Ya
+        (0x11942, 0x11943,),  # Dives Akuru Medial Ra   ..Dives Akuru Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x11f00, 0x11f01,),  # Kawi Sign Candrabindu   ..Kawi Sign Anusvara
+        (0x11f03, 0x11f03,),  # Kawi Sign Visarga
+        (0x11f34, 0x11f3a,),  # Kawi Vowel Sign Aa      ..Kawi Vowel Sign Vocalic
+        (0x11f3e, 0x11f42,),  # Kawi Vowel Sign E       ..Kawi Conjoiner
+        (0x13430, 0x13440,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph Mirr
+        (0x13447, 0x13455,),  # Egyptian Hieroglyph Modi..Egyptian Hieroglyph Modi
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x16fe4, 0x16fe4,),  # Khitan Small Script Filler
+        (0x16ff0, 0x16ff1,),  # Vietnamese Alternate Rea..Vietnamese Alternate Rea
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1cf00, 0x1cf2d,),  # Znamenny Combining Mark ..Znamenny Combining Mark
+        (0x1cf30, 0x1cf46,),  # Znamenny Combining Tonal..Znamenny Priznak Modifie
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e08f, 0x1e08f,),  # Combining Cyrillic Small Letter Byelorussian-ukr
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ae, 0x1e2ae,),  # Toto Sign Rising Tone
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e4ec, 0x1e4ef,),  # Nag Mundari Sign Muhor  ..Nag Mundari Sign Sutuh
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+    '15.1.0': (
+        # Source: DerivedGeneralCategory-15.1.0.txt
+        # Date: 2023-07-28, 23:34:02 GMT
+        #
+        (0x00000, 0x00000,),  # (nil)
+        (0x000ad, 0x000ad,),  # Soft Hyphen
+        (0x00300, 0x0036f,),  # Combining Grave Accent  ..Combining Latin Small Le
+        (0x00483, 0x00489,),  # Combining Cyrillic Titlo..Combining Cyrillic Milli
+        (0x00591, 0x005bd,),  # Hebrew Accent Etnahta   ..Hebrew Point Meteg
+        (0x005bf, 0x005bf,),  # Hebrew Point Rafe
+        (0x005c1, 0x005c2,),  # Hebrew Point Shin Dot   ..Hebrew Point Sin Dot
+        (0x005c4, 0x005c5,),  # Hebrew Mark Upper Dot   ..Hebrew Mark Lower Dot
+        (0x005c7, 0x005c7,),  # Hebrew Point Qamats Qatan
+        (0x00600, 0x00605,),  # Arabic Number Sign      ..Arabic Number Mark Above
+        (0x00610, 0x0061a,),  # Arabic Sign Sallallahou ..Arabic Small Kasra
+        (0x0061c, 0x0061c,),  # Arabic Letter Mark
+        (0x0064b, 0x0065f,),  # Arabic Fathatan         ..Arabic Wavy Hamza Below
+        (0x00670, 0x00670,),  # Arabic Letter Superscript Alef
+        (0x006d6, 0x006dd,),  # Arabic Small High Ligatu..Arabic End Of Ayah
+        (0x006df, 0x006e4,),  # Arabic Small High Rounde..Arabic Small High Madda
+        (0x006e7, 0x006e8,),  # Arabic Small High Yeh   ..Arabic Small High Noon
+        (0x006ea, 0x006ed,),  # Arabic Empty Centre Low ..Arabic Small Low Meem
+        (0x0070f, 0x0070f,),  # Syriac Abbreviation Mark
+        (0x00711, 0x00711,),  # Syriac Letter Superscript Alaph
+        (0x00730, 0x0074a,),  # Syriac Pthaha Above     ..Syriac Barrekh
+        (0x007a6, 0x007b0,),  # Thaana Abafili          ..Thaana Sukun
+        (0x007eb, 0x007f3,),  # Nko Combining Short High..Nko Combining Double Dot
+        (0x007fd, 0x007fd,),  # Nko Dantayalan
+        (0x00816, 0x00819,),  # Samaritan Mark In       ..Samaritan Mark Dagesh
+        (0x0081b, 0x00823,),  # Samaritan Mark Epentheti..Samaritan Vowel Sign A
+        (0x00825, 0x00827,),  # Samaritan Vowel Sign Sho..Samaritan Vowel Sign U
+        (0x00829, 0x0082d,),  # Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa
+        (0x00859, 0x0085b,),  # Mandaic Affrication Mark..Mandaic Gemination Mark
+        (0x00890, 0x00891,),  # Arabic Pound Mark Above ..Arabic Piastre Mark Abov
+        (0x00898, 0x0089f,),  # Arabic Small High Word A..Arabic Half Madda Over M
+        (0x008ca, 0x00903,),  # Arabic Small High Farsi ..Devanagari Sign Visarga
+        (0x0093a, 0x0093c,),  # Devanagari Vowel Sign Oe..Devanagari Sign Nukta
+        (0x0093e, 0x0094f,),  # Devanagari Vowel Sign Aa..Devanagari Vowel Sign Aw
+        (0x00951, 0x00957,),  # Devanagari Stress Sign U..Devanagari Vowel Sign Uu
+        (0x00962, 0x00963,),  # Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo
+        (0x00981, 0x00983,),  # Bengali Sign Candrabindu..Bengali Sign Visarga
+        (0x009bc, 0x009bc,),  # Bengali Sign Nukta
+        (0x009be, 0x009c4,),  # Bengali Vowel Sign Aa   ..Bengali Vowel Sign Vocal
+        (0x009c7, 0x009c8,),  # Bengali Vowel Sign E    ..Bengali Vowel Sign Ai
+        (0x009cb, 0x009cd,),  # Bengali Vowel Sign O    ..Bengali Sign Virama
+        (0x009d7, 0x009d7,),  # Bengali Au Length Mark
+        (0x009e2, 0x009e3,),  # Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal
+        (0x009fe, 0x009fe,),  # Bengali Sandhi Mark
+        (0x00a01, 0x00a03,),  # Gurmukhi Sign Adak Bindi..Gurmukhi Sign Visarga
+        (0x00a3c, 0x00a3c,),  # Gurmukhi Sign Nukta
+        (0x00a3e, 0x00a42,),  # Gurmukhi Vowel Sign Aa  ..Gurmukhi Vowel Sign Uu
+        (0x00a47, 0x00a48,),  # Gurmukhi Vowel Sign Ee  ..Gurmukhi Vowel Sign Ai
+        (0x00a4b, 0x00a4d,),  # Gurmukhi Vowel Sign Oo  ..Gurmukhi Sign Virama
+        (0x00a51, 0x00a51,),  # Gurmukhi Sign Udaat
+        (0x00a70, 0x00a71,),  # Gurmukhi Tippi          ..Gurmukhi Addak
+        (0x00a75, 0x00a75,),  # Gurmukhi Sign Yakash
+        (0x00a81, 0x00a83,),  # Gujarati Sign Candrabind..Gujarati Sign Visarga
+        (0x00abc, 0x00abc,),  # Gujarati Sign Nukta
+        (0x00abe, 0x00ac5,),  # Gujarati Vowel Sign Aa  ..Gujarati Vowel Sign Cand
+        (0x00ac7, 0x00ac9,),  # Gujarati Vowel Sign E   ..Gujarati Vowel Sign Cand
+        (0x00acb, 0x00acd,),  # Gujarati Vowel Sign O   ..Gujarati Sign Virama
+        (0x00ae2, 0x00ae3,),  # Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca
+        (0x00afa, 0x00aff,),  # Gujarati Sign Sukun     ..Gujarati Sign Two-circle
+        (0x00b01, 0x00b03,),  # Oriya Sign Candrabindu  ..Oriya Sign Visarga
+        (0x00b3c, 0x00b3c,),  # Oriya Sign Nukta
+        (0x00b3e, 0x00b44,),  # Oriya Vowel Sign Aa     ..Oriya Vowel Sign Vocalic
+        (0x00b47, 0x00b48,),  # Oriya Vowel Sign E      ..Oriya Vowel Sign Ai
+        (0x00b4b, 0x00b4d,),  # Oriya Vowel Sign O      ..Oriya Sign Virama
+        (0x00b55, 0x00b57,),  # Oriya Sign Overline     ..Oriya Au Length Mark
+        (0x00b62, 0x00b63,),  # Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic
+        (0x00b82, 0x00b82,),  # Tamil Sign Anusvara
+        (0x00bbe, 0x00bc2,),  # Tamil Vowel Sign Aa     ..Tamil Vowel Sign Uu
+        (0x00bc6, 0x00bc8,),  # Tamil Vowel Sign E      ..Tamil Vowel Sign Ai
+        (0x00bca, 0x00bcd,),  # Tamil Vowel Sign O      ..Tamil Sign Virama
+        (0x00bd7, 0x00bd7,),  # Tamil Au Length Mark
+        (0x00c00, 0x00c04,),  # Telugu Sign Combining Ca..Telugu Sign Combining An
+        (0x00c3c, 0x00c3c,),  # Telugu Sign Nukta
+        (0x00c3e, 0x00c44,),  # Telugu Vowel Sign Aa    ..Telugu Vowel Sign Vocali
+        (0x00c46, 0x00c48,),  # Telugu Vowel Sign E     ..Telugu Vowel Sign Ai
+        (0x00c4a, 0x00c4d,),  # Telugu Vowel Sign O     ..Telugu Sign Virama
+        (0x00c55, 0x00c56,),  # Telugu Length Mark      ..Telugu Ai Length Mark
+        (0x00c62, 0x00c63,),  # Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali
+        (0x00c81, 0x00c83,),  # Kannada Sign Candrabindu..Kannada Sign Visarga
+        (0x00cbc, 0x00cbc,),  # Kannada Sign Nukta
+        (0x00cbe, 0x00cc4,),  # Kannada Vowel Sign Aa   ..Kannada Vowel Sign Vocal
+        (0x00cc6, 0x00cc8,),  # Kannada Vowel Sign E    ..Kannada Vowel Sign Ai
+        (0x00cca, 0x00ccd,),  # Kannada Vowel Sign O    ..Kannada Sign Virama
+        (0x00cd5, 0x00cd6,),  # Kannada Length Mark     ..Kannada Ai Length Mark
+        (0x00ce2, 0x00ce3,),  # Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal
+        (0x00cf3, 0x00cf3,),  # Kannada Sign Combining Anusvara Above Right
+        (0x00d00, 0x00d03,),  # Malayalam Sign Combining..Malayalam Sign Visarga
+        (0x00d3b, 0x00d3c,),  # Malayalam Sign Vertical ..Malayalam Sign Circular
+        (0x00d3e, 0x00d44,),  # Malayalam Vowel Sign Aa ..Malayalam Vowel Sign Voc
+        (0x00d46, 0x00d48,),  # Malayalam Vowel Sign E  ..Malayalam Vowel Sign Ai
+        (0x00d4a, 0x00d4d,),  # Malayalam Vowel Sign O  ..Malayalam Sign Virama
+        (0x00d57, 0x00d57,),  # Malayalam Au Length Mark
+        (0x00d62, 0x00d63,),  # Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc
+        (0x00d81, 0x00d83,),  # Sinhala Sign Candrabindu..Sinhala Sign Visargaya
+        (0x00dca, 0x00dca,),  # Sinhala Sign Al-lakuna
+        (0x00dcf, 0x00dd4,),  # Sinhala Vowel Sign Aela-..Sinhala Vowel Sign Ketti
+        (0x00dd6, 0x00dd6,),  # Sinhala Vowel Sign Diga Paa-pilla
+        (0x00dd8, 0x00ddf,),  # Sinhala Vowel Sign Gaett..Sinhala Vowel Sign Gayan
+        (0x00df2, 0x00df3,),  # Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga
+        (0x00e31, 0x00e31,),  # Thai Character Mai Han-akat
+        (0x00e34, 0x00e3a,),  # Thai Character Sara I   ..Thai Character Phinthu
+        (0x00e47, 0x00e4e,),  # Thai Character Maitaikhu..Thai Character Yamakkan
+        (0x00eb1, 0x00eb1,),  # Lao Vowel Sign Mai Kan
+        (0x00eb4, 0x00ebc,),  # Lao Vowel Sign I        ..Lao Semivowel Sign Lo
+        (0x00ec8, 0x00ece,),  # Lao Tone Mai Ek         ..Lao Yamakkan
+        (0x00f18, 0x00f19,),  # Tibetan Astrological Sig..Tibetan Astrological Sig
+        (0x00f35, 0x00f35,),  # Tibetan Mark Ngas Bzung Nyi Zla
+        (0x00f37, 0x00f37,),  # Tibetan Mark Ngas Bzung Sgor Rtags
+        (0x00f39, 0x00f39,),  # Tibetan Mark Tsa -phru
+        (0x00f3e, 0x00f3f,),  # Tibetan Sign Yar Tshes  ..Tibetan Sign Mar Tshes
+        (0x00f71, 0x00f84,),  # Tibetan Vowel Sign Aa   ..Tibetan Mark Halanta
+        (0x00f86, 0x00f87,),  # Tibetan Sign Lci Rtags  ..Tibetan Sign Yang Rtags
+        (0x00f8d, 0x00f97,),  # Tibetan Subjoined Sign L..Tibetan Subjoined Letter
+        (0x00f99, 0x00fbc,),  # Tibetan Subjoined Letter..Tibetan Subjoined Letter
+        (0x00fc6, 0x00fc6,),  # Tibetan Symbol Padma Gdan
+        (0x0102b, 0x0103e,),  # Myanmar Vowel Sign Tall ..Myanmar Consonant Sign M
+        (0x01056, 0x01059,),  # Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal
+        (0x0105e, 0x01060,),  # Myanmar Consonant Sign M..Myanmar Consonant Sign M
+        (0x01062, 0x01064,),  # Myanmar Vowel Sign Sgaw ..Myanmar Tone Mark Sgaw K
+        (0x01067, 0x0106d,),  # Myanmar Vowel Sign Weste..Myanmar Sign Western Pwo
+        (0x01071, 0x01074,),  # Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah
+        (0x01082, 0x0108d,),  # Myanmar Consonant Sign S..Myanmar Sign Shan Counci
+        (0x0108f, 0x0108f,),  # Myanmar Sign Rumai Palaung Tone-5
+        (0x0109a, 0x0109d,),  # Myanmar Sign Khamti Tone..Myanmar Vowel Sign Aiton
+        (0x01160, 0x011ff,),  # Hangul Jungseong Filler ..Hangul Jongseong Ssangni
+        (0x0135d, 0x0135f,),  # Ethiopic Combining Gemin..Ethiopic Combining Gemin
+        (0x01712, 0x01715,),  # Tagalog Vowel Sign I    ..Tagalog Sign Pamudpod
+        (0x01732, 0x01734,),  # Hanunoo Vowel Sign I    ..Hanunoo Sign Pamudpod
+        (0x01752, 0x01753,),  # Buhid Vowel Sign I      ..Buhid Vowel Sign U
+        (0x01772, 0x01773,),  # Tagbanwa Vowel Sign I   ..Tagbanwa Vowel Sign U
+        (0x017b4, 0x017d3,),  # Khmer Vowel Inherent Aq ..Khmer Sign Bathamasat
+        (0x017dd, 0x017dd,),  # Khmer Sign Atthacan
+        (0x0180b, 0x0180f,),  # Mongolian Free Variation..Mongolian Free Variation
+        (0x01885, 0x01886,),  # Mongolian Letter Ali Gal..Mongolian Letter Ali Gal
+        (0x018a9, 0x018a9,),  # Mongolian Letter Ali Gali Dagalga
+        (0x01920, 0x0192b,),  # Limbu Vowel Sign A      ..Limbu Subjoined Letter W
+        (0x01930, 0x0193b,),  # Limbu Small Letter Ka   ..Limbu Sign Sa-i
+        (0x01a17, 0x01a1b,),  # Buginese Vowel Sign I   ..Buginese Vowel Sign Ae
+        (0x01a55, 0x01a5e,),  # Tai Tham Consonant Sign ..Tai Tham Consonant Sign
+        (0x01a60, 0x01a7c,),  # Tai Tham Sign Sakot     ..Tai Tham Sign Khuen-lue
+        (0x01a7f, 0x01a7f,),  # Tai Tham Combining Cryptogrammic Dot
+        (0x01ab0, 0x01ace,),  # Combining Doubled Circum..Combining Latin Small Le
+        (0x01b00, 0x01b04,),  # Balinese Sign Ulu Ricem ..Balinese Sign Bisah
+        (0x01b34, 0x01b44,),  # Balinese Sign Rerekan   ..Balinese Adeg Adeg
+        (0x01b6b, 0x01b73,),  # Balinese Musical Symbol ..Balinese Musical Symbol
+        (0x01b80, 0x01b82,),  # Sundanese Sign Panyecek ..Sundanese Sign Pangwisad
+        (0x01ba1, 0x01bad,),  # Sundanese Consonant Sign..Sundanese Consonant Sign
+        (0x01be6, 0x01bf3,),  # Batak Sign Tompi        ..Batak Panongonan
+        (0x01c24, 0x01c37,),  # Lepcha Subjoined Letter ..Lepcha Sign Nukta
+        (0x01cd0, 0x01cd2,),  # Vedic Tone Karshana     ..Vedic Tone Prenkha
+        (0x01cd4, 0x01ce8,),  # Vedic Sign Yajurvedic Mi..Vedic Sign Visarga Anuda
+        (0x01ced, 0x01ced,),  # Vedic Sign Tiryak
+        (0x01cf4, 0x01cf4,),  # Vedic Tone Candra Above
+        (0x01cf7, 0x01cf9,),  # Vedic Sign Atikrama     ..Vedic Tone Double Ring A
+        (0x01dc0, 0x01dff,),  # Combining Dotted Grave A..Combining Right Arrowhea
+        (0x0200b, 0x0200f,),  # Zero Width Space        ..Right-to-left Mark
+        (0x02028, 0x0202e,),  # Line Separator          ..Right-to-left Override
+        (0x02060, 0x02064,),  # Word Joiner             ..Invisible Plus
+        (0x02066, 0x0206f,),  # Left-to-right Isolate   ..Nominal Digit Shapes
+        (0x020d0, 0x020f0,),  # Combining Left Harpoon A..Combining Asterisk Above
+        (0x02cef, 0x02cf1,),  # Coptic Combining Ni Abov..Coptic Combining Spiritu
+        (0x02d7f, 0x02d7f,),  # Tifinagh Consonant Joiner
+        (0x02de0, 0x02dff,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0302a, 0x0302f,),  # Ideographic Level Tone M..Hangul Double Dot Tone M
+        (0x03099, 0x0309a,),  # Combining Katakana-hirag..Combining Katakana-hirag
+        (0x0a66f, 0x0a672,),  # Combining Cyrillic Vzmet..Combining Cyrillic Thous
+        (0x0a674, 0x0a67d,),  # Combining Cyrillic Lette..Combining Cyrillic Payer
+        (0x0a69e, 0x0a69f,),  # Combining Cyrillic Lette..Combining Cyrillic Lette
+        (0x0a6f0, 0x0a6f1,),  # Bamum Combining Mark Koq..Bamum Combining Mark Tuk
+        (0x0a802, 0x0a802,),  # Syloti Nagri Sign Dvisvara
+        (0x0a806, 0x0a806,),  # Syloti Nagri Sign Hasanta
+        (0x0a80b, 0x0a80b,),  # Syloti Nagri Sign Anusvara
+        (0x0a823, 0x0a827,),  # Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign
+        (0x0a82c, 0x0a82c,),  # Syloti Nagri Sign Alternate Hasanta
+        (0x0a880, 0x0a881,),  # Saurashtra Sign Anusvara..Saurashtra Sign Visarga
+        (0x0a8b4, 0x0a8c5,),  # Saurashtra Consonant Sig..Saurashtra Sign Candrabi
+        (0x0a8e0, 0x0a8f1,),  # Combining Devanagari Dig..Combining Devanagari Sig
+        (0x0a8ff, 0x0a8ff,),  # Devanagari Vowel Sign Ay
+        (0x0a926, 0x0a92d,),  # Kayah Li Vowel Ue       ..Kayah Li Tone Calya Plop
+        (0x0a947, 0x0a953,),  # Rejang Vowel Sign I     ..Rejang Virama
+        (0x0a980, 0x0a983,),  # Javanese Sign Panyangga ..Javanese Sign Wignyan
+        (0x0a9b3, 0x0a9c0,),  # Javanese Sign Cecak Telu..Javanese Pangkon
+        (0x0a9e5, 0x0a9e5,),  # Myanmar Sign Shan Saw
+        (0x0aa29, 0x0aa36,),  # Cham Vowel Sign Aa      ..Cham Consonant Sign Wa
+        (0x0aa43, 0x0aa43,),  # Cham Consonant Sign Final Ng
+        (0x0aa4c, 0x0aa4d,),  # Cham Consonant Sign Fina..Cham Consonant Sign Fina
+        (0x0aa7b, 0x0aa7d,),  # Myanmar Sign Pao Karen T..Myanmar Sign Tai Laing T
+        (0x0aab0, 0x0aab0,),  # Tai Viet Mai Kang
+        (0x0aab2, 0x0aab4,),  # Tai Viet Vowel I        ..Tai Viet Vowel U
+        (0x0aab7, 0x0aab8,),  # Tai Viet Mai Khit       ..Tai Viet Vowel Ia
+        (0x0aabe, 0x0aabf,),  # Tai Viet Vowel Am       ..Tai Viet Tone Mai Ek
+        (0x0aac1, 0x0aac1,),  # Tai Viet Tone Mai Tho
+        (0x0aaeb, 0x0aaef,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0aaf5, 0x0aaf6,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Virama
+        (0x0abe3, 0x0abea,),  # Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign
+        (0x0abec, 0x0abed,),  # Meetei Mayek Lum Iyek   ..Meetei Mayek Apun Iyek
+        (0x0d7b0, 0x0d7ff,),  # Hangul Jungseong O-yeo  ..(nil)
+        (0x0fb1e, 0x0fb1e,),  # Hebrew Point Judeo-spanish Varika
+        (0x0fe00, 0x0fe0f,),  # Variation Selector-1    ..Variation Selector-16
+        (0x0fe20, 0x0fe2f,),  # Combining Ligature Left ..Combining Cyrillic Titlo
+        (0x0feff, 0x0feff,),  # Zero Width No-break Space
+        (0x0fff9, 0x0fffb,),  # Interlinear Annotation A..Interlinear Annotation T
+        (0x101fd, 0x101fd,),  # Phaistos Disc Sign Combining Oblique Stroke
+        (0x102e0, 0x102e0,),  # Coptic Epact Thousands Mark
+        (0x10376, 0x1037a,),  # Combining Old Permic Let..Combining Old Permic Let
+        (0x10a01, 0x10a03,),  # Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo
+        (0x10a05, 0x10a06,),  # Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O
+        (0x10a0c, 0x10a0f,),  # Kharoshthi Vowel Length ..Kharoshthi Sign Visarga
+        (0x10a38, 0x10a3a,),  # Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo
+        (0x10a3f, 0x10a3f,),  # Kharoshthi Virama
+        (0x10ae5, 0x10ae6,),  # Manichaean Abbreviation ..Manichaean Abbreviation
+        (0x10d24, 0x10d27,),  # Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas
+        (0x10eab, 0x10eac,),  # Yezidi Combining Hamza M..Yezidi Combining Madda M
+        (0x10efd, 0x10eff,),  # Arabic Small Low Word Sa..Arabic Small Low Word Ma
+        (0x10f46, 0x10f50,),  # Sogdian Combining Dot Be..Sogdian Combining Stroke
+        (0x10f82, 0x10f85,),  # Old Uyghur Combining Dot..Old Uyghur Combining Two
+        (0x11000, 0x11002,),  # Brahmi Sign Candrabindu ..Brahmi Sign Visarga
+        (0x11038, 0x11046,),  # Brahmi Vowel Sign Aa    ..Brahmi Virama
+        (0x11070, 0x11070,),  # Brahmi Sign Old Tamil Virama
+        (0x11073, 0x11074,),  # Brahmi Vowel Sign Old Ta..Brahmi Vowel Sign Old Ta
+        (0x1107f, 0x11082,),  # Brahmi Number Joiner    ..Kaithi Sign Visarga
+        (0x110b0, 0x110ba,),  # Kaithi Vowel Sign Aa    ..Kaithi Sign Nukta
+        (0x110bd, 0x110bd,),  # Kaithi Number Sign
+        (0x110c2, 0x110c2,),  # Kaithi Vowel Sign Vocalic R
+        (0x110cd, 0x110cd,),  # Kaithi Number Sign Above
+        (0x11100, 0x11102,),  # Chakma Sign Candrabindu ..Chakma Sign Visarga
+        (0x11127, 0x11134,),  # Chakma Vowel Sign A     ..Chakma Maayyaa
+        (0x11145, 0x11146,),  # Chakma Vowel Sign Aa    ..Chakma Vowel Sign Ei
+        (0x11173, 0x11173,),  # Mahajani Sign Nukta
+        (0x11180, 0x11182,),  # Sharada Sign Candrabindu..Sharada Sign Visarga
+        (0x111b3, 0x111c0,),  # Sharada Vowel Sign Aa   ..Sharada Sign Virama
+        (0x111c9, 0x111cc,),  # Sharada Sandhi Mark     ..Sharada Extra Short Vowe
+        (0x111ce, 0x111cf,),  # Sharada Vowel Sign Prish..Sharada Sign Inverted Ca
+        (0x1122c, 0x11237,),  # Khojki Vowel Sign Aa    ..Khojki Sign Shadda
+        (0x1123e, 0x1123e,),  # Khojki Sign Sukun
+        (0x11241, 0x11241,),  # Khojki Vowel Sign Vocalic R
+        (0x112df, 0x112ea,),  # Khudawadi Sign Anusvara ..Khudawadi Sign Virama
+        (0x11300, 0x11303,),  # Grantha Sign Combining A..Grantha Sign Visarga
+        (0x1133b, 0x1133c,),  # Combining Bindu Below   ..Grantha Sign Nukta
+        (0x1133e, 0x11344,),  # Grantha Vowel Sign Aa   ..Grantha Vowel Sign Vocal
+        (0x11347, 0x11348,),  # Grantha Vowel Sign Ee   ..Grantha Vowel Sign Ai
+        (0x1134b, 0x1134d,),  # Grantha Vowel Sign Oo   ..Grantha Sign Virama
+        (0x11357, 0x11357,),  # Grantha Au Length Mark
+        (0x11362, 0x11363,),  # Grantha Vowel Sign Vocal..Grantha Vowel Sign Vocal
+        (0x11366, 0x1136c,),  # Combining Grantha Digit ..Combining Grantha Digit
+        (0x11370, 0x11374,),  # Combining Grantha Letter..Combining Grantha Letter
+        (0x11435, 0x11446,),  # Newa Vowel Sign Aa      ..Newa Sign Nukta
+        (0x1145e, 0x1145e,),  # Newa Sandhi Mark
+        (0x114b0, 0x114c3,),  # Tirhuta Vowel Sign Aa   ..Tirhuta Sign Nukta
+        (0x115af, 0x115b5,),  # Siddham Vowel Sign Aa   ..Siddham Vowel Sign Vocal
+        (0x115b8, 0x115c0,),  # Siddham Vowel Sign E    ..Siddham Sign Nukta
+        (0x115dc, 0x115dd,),  # Siddham Vowel Sign Alter..Siddham Vowel Sign Alter
+        (0x11630, 0x11640,),  # Modi Vowel Sign Aa      ..Modi Sign Ardhacandra
+        (0x116ab, 0x116b7,),  # Takri Sign Anusvara     ..Takri Sign Nukta
+        (0x1171d, 0x1172b,),  # Ahom Consonant Sign Medi..Ahom Sign Killer
+        (0x1182c, 0x1183a,),  # Dogra Vowel Sign Aa     ..Dogra Sign Nukta
+        (0x11930, 0x11935,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign E
+        (0x11937, 0x11938,),  # Dives Akuru Vowel Sign A..Dives Akuru Vowel Sign O
+        (0x1193b, 0x1193e,),  # Dives Akuru Sign Anusvar..Dives Akuru Virama
+        (0x11940, 0x11940,),  # Dives Akuru Medial Ya
+        (0x11942, 0x11943,),  # Dives Akuru Medial Ra   ..Dives Akuru Sign Nukta
+        (0x119d1, 0x119d7,),  # Nandinagari Vowel Sign A..Nandinagari Vowel Sign V
+        (0x119da, 0x119e0,),  # Nandinagari Vowel Sign E..Nandinagari Sign Virama
+        (0x119e4, 0x119e4,),  # Nandinagari Vowel Sign Prishthamatra E
+        (0x11a01, 0x11a0a,),  # Zanabazar Square Vowel S..Zanabazar Square Vowel L
+        (0x11a33, 0x11a39,),  # Zanabazar Square Final C..Zanabazar Square Sign Vi
+        (0x11a3b, 0x11a3e,),  # Zanabazar Square Cluster..Zanabazar Square Cluster
+        (0x11a47, 0x11a47,),  # Zanabazar Square Subjoiner
+        (0x11a51, 0x11a5b,),  # Soyombo Vowel Sign I    ..Soyombo Vowel Length Mar
+        (0x11a8a, 0x11a99,),  # Soyombo Final Consonant ..Soyombo Subjoiner
+        (0x11c2f, 0x11c36,),  # Bhaiksuki Vowel Sign Aa ..Bhaiksuki Vowel Sign Voc
+        (0x11c38, 0x11c3f,),  # Bhaiksuki Vowel Sign E  ..Bhaiksuki Sign Virama
+        (0x11c92, 0x11ca7,),  # Marchen Subjoined Letter..Marchen Subjoined Letter
+        (0x11ca9, 0x11cb6,),  # Marchen Subjoined Letter..Marchen Sign Candrabindu
+        (0x11d31, 0x11d36,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3a, 0x11d3a,),  # Masaram Gondi Vowel Sign E
+        (0x11d3c, 0x11d3d,),  # Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign
+        (0x11d3f, 0x11d45,),  # Masaram Gondi Vowel Sign..Masaram Gondi Virama
+        (0x11d47, 0x11d47,),  # Masaram Gondi Ra-kara
+        (0x11d8a, 0x11d8e,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d90, 0x11d91,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign
+        (0x11d93, 0x11d97,),  # Gunjala Gondi Vowel Sign..Gunjala Gondi Virama
+        (0x11ef3, 0x11ef6,),  # Makasar Vowel Sign I    ..Makasar Vowel Sign O
+        (0x11f00, 0x11f01,),  # Kawi Sign Candrabindu   ..Kawi Sign Anusvara
+        (0x11f03, 0x11f03,),  # Kawi Sign Visarga
+        (0x11f34, 0x11f3a,),  # Kawi Vowel Sign Aa      ..Kawi Vowel Sign Vocalic
+        (0x11f3e, 0x11f42,),  # Kawi Vowel Sign E       ..Kawi Conjoiner
+        (0x13430, 0x13440,),  # Egyptian Hieroglyph Vert..Egyptian Hieroglyph Mirr
+        (0x13447, 0x13455,),  # Egyptian Hieroglyph Modi..Egyptian Hieroglyph Modi
+        (0x16af0, 0x16af4,),  # Bassa Vah Combining High..Bassa Vah Combining High
+        (0x16b30, 0x16b36,),  # Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta
+        (0x16f4f, 0x16f4f,),  # Miao Sign Consonant Modifier Bar
+        (0x16f51, 0x16f87,),  # Miao Sign Aspiration    ..Miao Vowel Sign Ui
+        (0x16f8f, 0x16f92,),  # Miao Tone Right         ..Miao Tone Below
+        (0x16fe4, 0x16fe4,),  # Khitan Small Script Filler
+        (0x16ff0, 0x16ff1,),  # Vietnamese Alternate Rea..Vietnamese Alternate Rea
+        (0x1bc9d, 0x1bc9e,),  # Duployan Thick Letter Se..Duployan Double Mark
+        (0x1bca0, 0x1bca3,),  # Shorthand Format Letter ..Shorthand Format Up Step
+        (0x1cf00, 0x1cf2d,),  # Znamenny Combining Mark ..Znamenny Combining Mark
+        (0x1cf30, 0x1cf46,),  # Znamenny Combining Tonal..Znamenny Priznak Modifie
+        (0x1d165, 0x1d169,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d16d, 0x1d182,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d185, 0x1d18b,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d1aa, 0x1d1ad,),  # Musical Symbol Combining..Musical Symbol Combining
+        (0x1d242, 0x1d244,),  # Combining Greek Musical ..Combining Greek Musical
+        (0x1da00, 0x1da36,),  # Signwriting Head Rim    ..Signwriting Air Sucking
+        (0x1da3b, 0x1da6c,),  # Signwriting Mouth Closed..Signwriting Excitement
+        (0x1da75, 0x1da75,),  # Signwriting Upper Body Tilting From Hip Joints
+        (0x1da84, 0x1da84,),  # Signwriting Location Head Neck
+        (0x1da9b, 0x1da9f,),  # Signwriting Fill Modifie..Signwriting Fill Modifie
+        (0x1daa1, 0x1daaf,),  # Signwriting Rotation Mod..Signwriting Rotation Mod
+        (0x1e000, 0x1e006,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e008, 0x1e018,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e01b, 0x1e021,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e023, 0x1e024,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e026, 0x1e02a,),  # Combining Glagolitic Let..Combining Glagolitic Let
+        (0x1e08f, 0x1e08f,),  # Combining Cyrillic Small Letter Byelorussian-ukr
+        (0x1e130, 0x1e136,),  # Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T
+        (0x1e2ae, 0x1e2ae,),  # Toto Sign Rising Tone
+        (0x1e2ec, 0x1e2ef,),  # Wancho Tone Tup         ..Wancho Tone Koini
+        (0x1e4ec, 0x1e4ef,),  # Nag Mundari Sign Muhor  ..Nag Mundari Sign Sutuh
+        (0x1e8d0, 0x1e8d6,),  # Mende Kikakui Combining ..Mende Kikakui Combining
+        (0x1e944, 0x1e94a,),  # Adlam Alif Lengthener   ..Adlam Nukta
+        (0x1f3fb, 0x1f3ff,),  # Emoji Modifier Fitzpatri..Emoji Modifier Fitzpatri
+        (0xe0001, 0xe0001,),  # Language Tag
+        (0xe0020, 0xe007f,),  # Tag Space               ..Cancel Tag
+        (0xe0100, 0xe01ef,),  # Variation Selector-17   ..Variation Selector-256
+    ),
+}
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/unicode_versions.py b/.venv/lib/python3.13/site-packages/wcwidth/unicode_versions.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e9ccbf7a71aeb8b6df0f5b3e721233c361c5f21
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/unicode_versions.py
@@ -0,0 +1,38 @@
+"""
+Exports function list_versions() for unicode version level support.
+
+This code generated by wcwidth/bin/update-tables.py on 2023-09-14 15:45:33 UTC.
+"""
+
+
+def list_versions():
+    """
+    Return Unicode version levels supported by this module release.
+
+    Any of the version strings returned may be used as keyword argument
+    ``unicode_version`` to the ``wcwidth()`` family of functions.
+
+    :returns: Supported Unicode version numbers in ascending sorted order.
+    :rtype: list[str]
+    """
+    return (
+        "4.1.0",
+        "5.0.0",
+        "5.1.0",
+        "5.2.0",
+        "6.0.0",
+        "6.1.0",
+        "6.2.0",
+        "6.3.0",
+        "7.0.0",
+        "8.0.0",
+        "9.0.0",
+        "10.0.0",
+        "11.0.0",
+        "12.0.0",
+        "12.1.0",
+        "13.0.0",
+        "14.0.0",
+        "15.0.0",
+        "15.1.0",
+    )
diff --git a/.venv/lib/python3.13/site-packages/wcwidth/wcwidth.py b/.venv/lib/python3.13/site-packages/wcwidth/wcwidth.py
new file mode 100644
index 0000000000000000000000000000000000000000..e924020630c96f9df09629090dd898de7b2dc643
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/wcwidth/wcwidth.py
@@ -0,0 +1,345 @@
+"""
+This is a python implementation of wcwidth() and wcswidth().
+
+https://github.com/jquast/wcwidth
+
+from Markus Kuhn's C code, retrieved from:
+
+    http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+
+This is an implementation of wcwidth() and wcswidth() (defined in
+IEEE Std 1002.1-2001) for Unicode.
+
+http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+http://www.opengroup.org/onlinepubs/007904975/functions/wcswidth.html
+
+In fixed-width output devices, Latin characters all occupy a single
+"cell" position of equal width, whereas ideographic CJK characters
+occupy two such cells. Interoperability between terminal-line
+applications and (teletype-style) character terminals using the
+UTF-8 encoding requires agreement on which character should advance
+the cursor by how many cell positions. No established formal
+standards exist at present on which Unicode character shall occupy
+how many cell positions on character terminals. These routines are
+a first attempt of defining such behavior based on simple rules
+applied to data provided by the Unicode Consortium.
+
+For some graphical characters, the Unicode standard explicitly
+defines a character-cell width via the definition of the East Asian
+FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+In all these cases, there is no ambiguity about which width a
+terminal shall use. For characters in the East Asian Ambiguous (A)
+class, the width choice depends purely on a preference of backward
+compatibility with either historic CJK or Western practice.
+Choosing single-width for these characters is easy to justify as
+the appropriate long-term solution, as the CJK practice of
+displaying these characters as double-width comes from historic
+implementation simplicity (8-bit encoded characters were displayed
+single-width and 16-bit ones double-width, even for Greek,
+Cyrillic, etc.) and not any typographic considerations.
+
+Much less clear is the choice of width for the Not East Asian
+(Neutral) class. Existing practice does not dictate a width for any
+of these characters. It would nevertheless make sense
+typographically to allocate two character cells to characters such
+as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+represented adequately with a single-width glyph. The following
+routines at present merely assign a single-cell width to all
+neutral characters, in the interest of simplicity. This is not
+entirely satisfactory and should be reconsidered before
+establishing a formal standard in this area. At the moment, the
+decision which Not East Asian (Neutral) characters should be
+represented by double-width glyphs cannot yet be answered by
+applying a simple rule from the Unicode database content. Setting
+up a proper standard for the behavior of UTF-8 character terminals
+will require a careful analysis not only of each Unicode character,
+but also of each presentation form, something the author of these
+routines has avoided to do so far.
+
+http://www.unicode.org/unicode/reports/tr11/
+
+Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+"""
+from __future__ import division
+
+# std imports
+import os
+import sys
+import warnings
+
+# local
+from .table_vs16 import VS16_NARROW_TO_WIDE
+from .table_wide import WIDE_EASTASIAN
+from .table_zero import ZERO_WIDTH
+from .unicode_versions import list_versions
+
+try:
+    # std imports
+    from functools import lru_cache
+except ImportError:
+    # lru_cache was added in Python 3.2
+    # 3rd party
+    from backports.functools_lru_cache import lru_cache
+
+# global cache
+_PY3 = sys.version_info[0] >= 3
+
+
+def _bisearch(ucs, table):
+    """
+    Auxiliary function for binary search in interval table.
+
+    :arg int ucs: Ordinal value of unicode character.
+    :arg list table: List of starting and ending ranges of ordinal values,
+        in form of ``[(start, end), ...]``.
+    :rtype: int
+    :returns: 1 if ordinal value ucs is found within lookup table, else 0.
+    """
+    lbound = 0
+    ubound = len(table) - 1
+
+    if ucs < table[0][0] or ucs > table[ubound][1]:
+        return 0
+    while ubound >= lbound:
+        mid = (lbound + ubound) // 2
+        if ucs > table[mid][1]:
+            lbound = mid + 1
+        elif ucs < table[mid][0]:
+            ubound = mid - 1
+        else:
+            return 1
+
+    return 0
+
+
+@lru_cache(maxsize=1000)
+def wcwidth(wc, unicode_version='auto'):
+    r"""
+    Given one Unicode character, return its printable length on a terminal.
+
+    :param str wc: A single Unicode character.
+    :param str unicode_version: A Unicode version number, such as
+        ``'6.0.0'``. A list of version levels suported by wcwidth
+        is returned by :func:`list_versions`.
+
+        Any version string may be specified without error -- the nearest
+        matching version is selected.  When ``latest`` (default), the
+        highest Unicode version level is used.
+    :return: The width, in cells, necessary to display the character of
+        Unicode string character, ``wc``.  Returns 0 if the ``wc`` argument has
+        no printable effect on a terminal (such as NUL '\0'), -1 if ``wc`` is
+        not printable, or has an indeterminate effect on the terminal, such as
+        a control character.  Otherwise, the number of column positions the
+        character occupies on a graphic terminal (1 or 2) is returned.
+    :rtype: int
+
+    See :ref:`Specification` for details of cell measurement.
+    """
+    ucs = ord(wc) if wc else 0
+
+    # small optimization: early return of 1 for printable ASCII, this provides
+    # approximately 40% performance improvement for mostly-ascii documents, with
+    # less than 1% impact to others.
+    if 32 <= ucs < 0x7f:
+        return 1
+
+    # C0/C1 control characters are -1 for compatibility with POSIX-like calls
+    if ucs and ucs < 32 or 0x07F <= ucs < 0x0A0:
+        return -1
+
+    _unicode_version = _wcmatch_version(unicode_version)
+
+    # Zero width
+    if _bisearch(ucs, ZERO_WIDTH[_unicode_version]):
+        return 0
+
+    # 1 or 2 width
+    return 1 + _bisearch(ucs, WIDE_EASTASIAN[_unicode_version])
+
+
+def wcswidth(pwcs, n=None, unicode_version='auto'):
+    """
+    Given a unicode string, return its printable length on a terminal.
+
+    :param str pwcs: Measure width of given unicode string.
+    :param int n: When ``n`` is None (default), return the length of the entire
+        string, otherwise only the first ``n`` characters are measured. This
+        argument exists only for compatibility with the C POSIX function
+        signature. It is suggested instead to use python's string slicing
+        capability, ``wcswidth(pwcs[:n])``
+    :param str unicode_version: An explicit definition of the unicode version
+        level to use for determination, may be ``auto`` (default), which uses
+        the Environment Variable, ``UNICODE_VERSION`` if defined, or the latest
+        available unicode version, otherwise.
+    :rtype: int
+    :returns: The width, in cells, needed to display the first ``n`` characters
+        of the unicode string ``pwcs``.  Returns ``-1`` for C0 and C1 control
+        characters!
+
+    See :ref:`Specification` for details of cell measurement.
+    """
+    # this 'n' argument is a holdover for POSIX function
+    _unicode_version = None
+    end = len(pwcs) if n is None else n
+    width = 0
+    idx = 0
+    last_measured_char = None
+    while idx < end:
+        char = pwcs[idx]
+        if char == u'\u200D':
+            # Zero Width Joiner, do not measure this or next character
+            idx += 2
+            continue
+        if char == u'\uFE0F' and last_measured_char:
+            # on variation selector 16 (VS16) following another character,
+            # conditionally add '1' to the measured width if that character is
+            # known to be converted from narrow to wide by the VS16 character.
+            if _unicode_version is None:
+                _unicode_version = _wcversion_value(_wcmatch_version(unicode_version))
+            if _unicode_version >= (9, 0, 0):
+                width += _bisearch(ord(last_measured_char), VS16_NARROW_TO_WIDE["9.0.0"])
+                last_measured_char = None
+            idx += 1
+            continue
+        # measure character at current index
+        wcw = wcwidth(char, unicode_version)
+        if wcw < 0:
+            # early return -1 on C0 and C1 control characters
+            return wcw
+        if wcw > 0:
+            # track last character measured to contain a cell, so that
+            # subsequent VS-16 modifiers may be understood
+            last_measured_char = char
+        width += wcw
+        idx += 1
+    return width
+
+
+@lru_cache(maxsize=128)
+def _wcversion_value(ver_string):
+    """
+    Integer-mapped value of given dotted version string.
+
+    :param str ver_string: Unicode version string, of form ``n.n.n``.
+    :rtype: tuple(int)
+    :returns: tuple of digit tuples, ``tuple(int, [...])``.
+    """
+    retval = tuple(map(int, (ver_string.split('.'))))
+    return retval
+
+
+@lru_cache(maxsize=8)
+def _wcmatch_version(given_version):
+    """
+    Return nearest matching supported Unicode version level.
+
+    If an exact match is not determined, the nearest lowest version level is
+    returned after a warning is emitted.  For example, given supported levels
+    ``4.1.0`` and ``5.0.0``, and a version string of ``4.9.9``, then ``4.1.0``
+    is selected and returned:
+
+    >>> _wcmatch_version('4.9.9')
+    '4.1.0'
+    >>> _wcmatch_version('8.0')
+    '8.0.0'
+    >>> _wcmatch_version('1')
+    '4.1.0'
+
+    :param str given_version: given version for compare, may be ``auto``
+        (default), to select Unicode Version from Environment Variable,
+        ``UNICODE_VERSION``. If the environment variable is not set, then the
+        latest is used.
+    :rtype: str
+    :returns: unicode string, or non-unicode ``str`` type for python 2
+        when given ``version`` is also type ``str``.
+    """
+    # Design note: the choice to return the same type that is given certainly
+    # complicates it for python 2 str-type, but allows us to define an api that
+    # uses 'string-type' for unicode version level definitions, so all of our
+    # example code works with all versions of python.
+    #
+    # That, along with the string-to-numeric and comparisons of earliest,
+    # latest, matching, or nearest, greatly complicates this function.
+    # Performance is somewhat curbed by memoization.
+    _return_str = not _PY3 and isinstance(given_version, str)
+
+    if _return_str:
+        # avoid list-comprehension to work around a coverage issue:
+        # https://github.com/nedbat/coveragepy/issues/753
+        unicode_versions = list(map(lambda ucs: ucs.encode(), list_versions()))
+    else:
+        unicode_versions = list_versions()
+    latest_version = unicode_versions[-1]
+
+    if given_version in (u'auto', 'auto'):
+        given_version = os.environ.get(
+            'UNICODE_VERSION',
+            'latest' if not _return_str else latest_version.encode())
+
+    if given_version in (u'latest', 'latest'):
+        # default match, when given as 'latest', use the most latest unicode
+        # version specification level supported.
+        return latest_version if not _return_str else latest_version.encode()
+
+    if given_version in unicode_versions:
+        # exact match, downstream has specified an explicit matching version
+        # matching any value of list_versions().
+        return given_version if not _return_str else given_version.encode()
+
+    # The user's version is not supported by ours. We return the newest unicode
+    # version level that we support below their given value.
+    try:
+        cmp_given = _wcversion_value(given_version)
+
+    except ValueError:
+        # submitted value raises ValueError in int(), warn and use latest.
+        warnings.warn("UNICODE_VERSION value, {given_version!r}, is invalid. "
+                      "Value should be in form of `integer[.]+', the latest "
+                      "supported unicode version {latest_version!r} has been "
+                      "inferred.".format(given_version=given_version,
+                                         latest_version=latest_version))
+        return latest_version if not _return_str else latest_version.encode()
+
+    # given version is less than any available version, return earliest
+    # version.
+    earliest_version = unicode_versions[0]
+    cmp_earliest_version = _wcversion_value(earliest_version)
+
+    if cmp_given <= cmp_earliest_version:
+        # this probably isn't what you wanted, the oldest wcwidth.c you will
+        # find in the wild is likely version 5 or 6, which we both support,
+        # but it's better than not saying anything at all.
+        warnings.warn("UNICODE_VERSION value, {given_version!r}, is lower "
+                      "than any available unicode version. Returning lowest "
+                      "version level, {earliest_version!r}".format(
+                          given_version=given_version,
+                          earliest_version=earliest_version))
+        return earliest_version if not _return_str else earliest_version.encode()
+
+    # create list of versions which are less than our equal to given version,
+    # and return the tail value, which is the highest level we may support,
+    # or the latest value we support, when completely unmatched or higher
+    # than any supported version.
+    #
+    # function will never complete, always returns.
+    for idx, unicode_version in enumerate(unicode_versions):
+        # look ahead to next value
+        try:
+            cmp_next_version = _wcversion_value(unicode_versions[idx + 1])
+        except IndexError:
+            # at end of list, return latest version
+            return latest_version if not _return_str else latest_version.encode()
+
+        # Maybe our given version has less parts, as in tuple(8, 0), than the
+        # next compare version tuple(8, 0, 0). Test for an exact match by
+        # comparison of only the leading dotted piece(s): (8, 0) == (8, 0).
+        if cmp_given == cmp_next_version[:len(cmp_given)]:
+            return unicode_versions[idx + 1]
+
+        # Or, if any next value is greater than our given support level
+        # version, return the current value in index.  Even though it must
+        # be less than the given value, its our closest possible match. That
+        # is, 4.1 is returned for given 4.9.9, where 4.1 and 5.0 are available.
+        if cmp_next_version > cmp_given:
+            return unicode_version
+    assert False, ("Code path unreachable", given_version, unicode_versions)  # pragma: no cover
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/__init__.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf313039317f42051d01eeca9794556b526a7bb6
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/__init__.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/composer.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/composer.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12e8b3e822cac8d8ea08513245d2f451d422f6be
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/composer.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/constructor.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/constructor.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74cf3c9744d5755c0fef23b7248f149ec814f1e3
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/constructor.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/cyaml.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/cyaml.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..330429650f7592681a986d64bf83a2f7342f62ce
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/cyaml.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/dumper.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/dumper.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e128f76c1ef0083d01432a159081a36a6c9e321
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/dumper.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/emitter.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/emitter.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a46244366450b51adfeeaed48bf6c124e138d34
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/emitter.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/error.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/error.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb9e164fabe66b06b42281da58b08fcbe1d91a8a
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/error.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/events.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/events.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb88bfaed50da1891f2d81be82f0557591231feb
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/events.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/loader.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/loader.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30b0a54dc8503fa8aa0851e02683f92ed3d3bbe8
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/loader.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/nodes.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/nodes.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..954c3a8655cc1aade24e9fd8e8b570493182d786
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/nodes.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/reader.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/reader.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca37463db00091ce0745a0040c55827999cb6d87
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/reader.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/representer.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/representer.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6c3bf07a3caaa488fdefe7e69b40d9eab763bfa
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/representer.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/resolver.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/resolver.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c75f7853c5fc7258b15540c84ca005ecb0940391
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/resolver.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/scanner.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/scanner.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa2f182d86255a5a71e7c7a54a625ac9e2f41039
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/scanner.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/serializer.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/serializer.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6544312b9202c4998e741b9e46523d71bf26b889
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/serializer.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/__pycache__/tokens.cpython-313.pyc b/.venv/lib/python3.13/site-packages/yaml/__pycache__/tokens.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e035a733e221fdb1e6a87620000443dd9d1d7ec
Binary files /dev/null and b/.venv/lib/python3.13/site-packages/yaml/__pycache__/tokens.cpython-313.pyc differ
diff --git a/.venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so b/.venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..eb40a55e187521ebc397535b514d4cd480f04554
--- /dev/null
+++ b/.venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:050db6b19057d0f804667f8e2466d10f53276a45d5e9152223c5db7495baa0ae
+size 358728
diff --git a/.venv/pyvenv.cfg b/.venv/pyvenv.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ab10d88ca8e46fe99dce4e90782e438cbd15cc42
--- /dev/null
+++ b/.venv/pyvenv.cfg
@@ -0,0 +1,6 @@
+home = /opt/homebrew/opt/python@3.13/bin
+implementation = CPython
+uv = 0.6.14
+version_info = 3.13.5
+include-system-site-packages = false
+prompt = npb_data_app_data
diff --git a/2020/pbp_data/2020022304.parquet b/2020/pbp_data/2020022304.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a857016cb988143e1eae017887fae125586f7d09
--- /dev/null
+++ b/2020/pbp_data/2020022304.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc3155b2fe3d913c5d1375d0e1e65d77e4cb30b973eead0038968015a6cbd1f1
+size 17351
diff --git a/2020/pbp_data/2020022305.parquet b/2020/pbp_data/2020022305.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e11b9953b85ad43adf29516dd12158b6aa3c7976
--- /dev/null
+++ b/2020/pbp_data/2020022305.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ceef9dea0e601d4342c9a3703d6778ff398532194f770a48f61071a8595c34f
+size 17567
diff --git a/2020/pbp_data/2020022906.parquet b/2020/pbp_data/2020022906.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..41cbe026ebd72fea058a98f0b57f9b03d016c6bb
--- /dev/null
+++ b/2020/pbp_data/2020022906.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90d6332e0891083c9c06e2da0e05ad5142be1db4dbfa35237263fe6fab6cafaa
+size 16507
diff --git a/2020/pbp_data/2020030106.parquet b/2020/pbp_data/2020030106.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..35931c94d9aa85d7d7aa3787a553d5cc264659b7
--- /dev/null
+++ b/2020/pbp_data/2020030106.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f27f4e36d0266359cdb9d88dd61b128ebbeeeb8da65d5516755a617572d6e9d0
+size 15657
diff --git a/2020/pbp_data/2020030301.parquet b/2020/pbp_data/2020030301.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9a1e26c67f9d52628307178e1140a9f9b64ce15c
--- /dev/null
+++ b/2020/pbp_data/2020030301.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1820151b4029b0c81cdc5fc0d3f6d4170b4c9ec5635d2707d3549ee6b01971ca
+size 16142
diff --git a/2020/pbp_data/2020030402.parquet b/2020/pbp_data/2020030402.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ae79bc5441de2e49232b40cf758f9e6a8a2b543b
--- /dev/null
+++ b/2020/pbp_data/2020030402.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9ce09eb483a45706eb223c8cbd0907eddf761c612f4614760fce56236d5da07
+size 16580
diff --git a/2020/pbp_data/2020030403.parquet b/2020/pbp_data/2020030403.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..35ad55236635b706eb4efec4bb3b49b8db83c1a1
--- /dev/null
+++ b/2020/pbp_data/2020030403.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b13df1889483e0a09a49a7d81be4645dce17fbd104f859e933032a8fed56a239
+size 13298
diff --git a/2020/pbp_data/2020030604.parquet b/2020/pbp_data/2020030604.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..730960889942453d09c54e9b814a31f593d5c056
--- /dev/null
+++ b/2020/pbp_data/2020030604.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aff82cd4afc6470e05d267e93492f8359bafd279a60db44f6b95a0ba2ced88b9
+size 16572
diff --git a/2020/pbp_data/2020030706.parquet b/2020/pbp_data/2020030706.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..8119056ff5a09cf21df8a76420934c6d0475edb8
--- /dev/null
+++ b/2020/pbp_data/2020030706.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d850417d95481b101951af95b9aa46fde371e6d4ad2065f60066f09c83b9e7b
+size 18074
diff --git a/2020/pbp_data/2020030801.parquet b/2020/pbp_data/2020030801.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1965967669cb08754110dc12753417bb8f45e159
--- /dev/null
+++ b/2020/pbp_data/2020030801.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e95ec456fbf2629be5f479dca44804a0827a1eb8c593433c21b658f80ff1c83
+size 135
diff --git a/2020/pbp_data/2020031002.parquet b/2020/pbp_data/2020031002.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1965967669cb08754110dc12753417bb8f45e159
--- /dev/null
+++ b/2020/pbp_data/2020031002.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e95ec456fbf2629be5f479dca44804a0827a1eb8c593433c21b658f80ff1c83
+size 135
diff --git a/2020/pbp_data/2020031003.parquet b/2020/pbp_data/2020031003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1965967669cb08754110dc12753417bb8f45e159
--- /dev/null
+++ b/2020/pbp_data/2020031003.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e95ec456fbf2629be5f479dca44804a0827a1eb8c593433c21b658f80ff1c83
+size 135
diff --git a/2020/pbp_data/2020031101.parquet b/2020/pbp_data/2020031101.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d4ffdf42d985074e4c43743531bda937ddd725b6
--- /dev/null
+++ b/2020/pbp_data/2020031101.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3323f77284f971f2418f0a794fbacd9ae30f6d2e2fd53f55441b679cef20ffd
+size 17259
diff --git a/2020/pbp_data/2020031306.parquet b/2020/pbp_data/2020031306.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..40a2970fa31d4ecc4c408a01d0913eb347955bbf
--- /dev/null
+++ b/2020/pbp_data/2020031306.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46d516b9926e284caaa7dd29b59ee931b861753e9c21a6823b93be68f1f4e9c9
+size 17697
diff --git a/2020/pbp_data/2020031404.parquet b/2020/pbp_data/2020031404.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..146a996803c0f08298aab009dc925924ded4d02b
--- /dev/null
+++ b/2020/pbp_data/2020031404.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff889cae38960a961af02c2e9e880b31339e35cf540a88f0dbb9c8ee8afada2c
+size 16477
diff --git a/2020/pbp_data/2020031405.parquet b/2020/pbp_data/2020031405.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..eacbff82872480e7135ef62d17936a21b5b3a7cf
--- /dev/null
+++ b/2020/pbp_data/2020031405.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4393daf47a5a0810fd986d4c01468034a2cef926f87c87667f516984f3df93d
+size 17750
diff --git a/2020/pbp_data/2020031506.parquet b/2020/pbp_data/2020031506.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3d6e502811c406bb0c85c59a3494d93e0d31d0fb
--- /dev/null
+++ b/2020/pbp_data/2020031506.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6f56a3b537a881d762033ecd3678624cc4b7b460f0d2b1a6739e81e8cff97dd
+size 17046
diff --git a/2020/pbp_data/2020061904.parquet b/2020/pbp_data/2020061904.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7810f2d9f165b08b7a093fb0528f6a49bd9ab525
--- /dev/null
+++ b/2020/pbp_data/2020061904.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b7bebe368b5eb3f14b6b40d33b617a85ca8dd22b54860d5551a31a0e20bebe9
+size 16157
diff --git a/2020/pbp_data/2020061905.parquet b/2020/pbp_data/2020061905.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e26a047e66ddba492dff66240c0df11912e0c7d6
--- /dev/null
+++ b/2020/pbp_data/2020061905.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ba126930698e915945a098b60904d6f70f146abce456fe1d09afbb7a1851632
+size 16701
diff --git a/2020/pbp_data/2020062006.parquet b/2020/pbp_data/2020062006.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d1a721819e3069ef188ab9604918fd5d9a036446
--- /dev/null
+++ b/2020/pbp_data/2020062006.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9eec5a2ff4abd32c3cb3a9264f60300d3eb2fe15f6e755a7368125b01eb01d92
+size 16990
diff --git a/2020/pbp_data/2020062104.parquet b/2020/pbp_data/2020062104.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..10b9224d1ebc4d954ea6536485e5e053dfa4c17e
--- /dev/null
+++ b/2020/pbp_data/2020062104.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3340185e13061d63cf71c927bf8389bc1d6cacbc3a13fc03a136fb68df4b078c
+size 18529
diff --git a/2020/pbp_data/2020062105.parquet b/2020/pbp_data/2020062105.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7fecbb2fdfddad422bc9cf42f6fd3476d1181e51
--- /dev/null
+++ b/2020/pbp_data/2020062105.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae3c41aef1602a07e59a7bd7e5dc231b77367648efdbba71a45dbbc31efad673
+size 16264
diff --git a/2020/pbp_data/2020062302.parquet b/2020/pbp_data/2020062302.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a067a82bf4c4462c91d7ce1f6c7b14e2640f450a
--- /dev/null
+++ b/2020/pbp_data/2020062302.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82233a3dfdb4f8eb477d16dac056fa49e15b81cc64e5c2d3f666e4def4ba498f
+size 16461
diff --git a/2020/pbp_data/2020062303.parquet b/2020/pbp_data/2020062303.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e65a297845381e3611fa8517cef871b3a05a08ae
--- /dev/null
+++ b/2020/pbp_data/2020062303.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3028f56229f390aeb6b91a24c7121b2dc1fa84cb1c4a2d03e30d6993d4c083b7
+size 16557
diff --git a/2020/pbp_data/2020062401.parquet b/2020/pbp_data/2020062401.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1a82e23fb65e04643606a9480157bb40a4bde70d
--- /dev/null
+++ b/2020/pbp_data/2020062401.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:077e260416097c00623757ae7f95bae1c877dbc15b7df6caa46e78f6ba486f73
+size 17237
diff --git a/2020/pbp_data/2020062502.parquet b/2020/pbp_data/2020062502.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1cee918c446e04ce3ff8f64bf45e1ceb2644aa59
--- /dev/null
+++ b/2020/pbp_data/2020062502.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:164138e046fa9ec8a66e41fadd5cc7ad7c83aa3f4231b906db375b48b0922807
+size 16194
diff --git a/2020/pbp_data/2020062503.parquet b/2020/pbp_data/2020062503.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7650334a00bcb67425bf5c1e9c47979b25611538
--- /dev/null
+++ b/2020/pbp_data/2020062503.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb9947756bd2af3850eef97a507e857bcc304f7c5473eb56b5d617232aa68da5
+size 16523
diff --git a/2020/pbp_data/2020062606.parquet b/2020/pbp_data/2020062606.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..790efbc8173ea5170ebfc81c9aa4e5338f625a1f
--- /dev/null
+++ b/2020/pbp_data/2020062606.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d75ced8991c3df9f6f38461b5f0f03447b8bc4271cfd706cdb22a2c1342c076
+size 17324
diff --git a/2020/pbp_data/2020062704.parquet b/2020/pbp_data/2020062704.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9d2db3c8e36c5a3dda015c28c36c3554c2b46c4d
--- /dev/null
+++ b/2020/pbp_data/2020062704.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:827a86255d4f29b240c69e0cbe1d2a686919fecce62ff220f0ab6bd6c198683c
+size 19021
diff --git a/2020/pbp_data/2020062705.parquet b/2020/pbp_data/2020062705.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0a43319afd8ab0d445c153e0b812d18c60424bc7
--- /dev/null
+++ b/2020/pbp_data/2020062705.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e97431533bed833f33d295434408a6a97906b1b18345e60c76ebe27b411cafa1
+size 17423
diff --git a/2020/pbp_data/2020062802.parquet b/2020/pbp_data/2020062802.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..054f99df7522e5786d17dfcb64ba70a6aa29d23d
--- /dev/null
+++ b/2020/pbp_data/2020062802.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4b80adae0e5d11cea10e1096268a7e1f4c20ea791418b3272dd237c0b7bcaac
+size 17211
diff --git a/2020/pbp_data/2020062803.parquet b/2020/pbp_data/2020062803.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..71c022d258d34f8141bcbedb74dfb405aa2b2bd6
--- /dev/null
+++ b/2020/pbp_data/2020062803.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e9ef05fcbf9828e0780ddc9cf72eb642b4295276527ae70da300af5b3b2d1b5
+size 17645
diff --git a/2020/pbp_data/2020063001.parquet b/2020/pbp_data/2020063001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..06ab745f2f9078cdbff04ef5f6a308b9dc18306f
--- /dev/null
+++ b/2020/pbp_data/2020063001.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b712d7d9d1e7556401c20d27c60422d27740e8cf43feab6af5786fe92cde6c3
+size 16944
diff --git a/2020/pbp_data/2020070101.parquet b/2020/pbp_data/2020070101.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a83c8fcfa8df1d6437150c1034da40e95c41336f
--- /dev/null
+++ b/2020/pbp_data/2020070101.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63059782826d2a16b8c8b28db0fe7858858dcaf52506423d43478a3fe5f79bd1
+size 17661
diff --git a/2020/pbp_data/2020070204.parquet b/2020/pbp_data/2020070204.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0ca38ae848a6fd2a71f00cfc0322b8716ad97df6
--- /dev/null
+++ b/2020/pbp_data/2020070204.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c445f6c1c5f8d9d2a5f06113d0d7b760441244b1cd3c8aab601ca9653bd097f7
+size 17848
diff --git a/2020/pbp_data/2020070205.parquet b/2020/pbp_data/2020070205.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9a9e970d37dc5f925d8e756a655ffbcbe64b3242
--- /dev/null
+++ b/2020/pbp_data/2020070205.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c11f9f8c6d55bff016ffe4e7fdf04d189115440964008456af071202c394cc48
+size 17808
diff --git a/2020/pbp_data/2020070306.parquet b/2020/pbp_data/2020070306.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..fdda01daa4c94eb3c6c57ba0b3b827a8ad875c72
--- /dev/null
+++ b/2020/pbp_data/2020070306.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c36a578347caab408cd85e5db88a1e3815fd2923de6c3839f918877e7ae1bb8b
+size 18409
diff --git a/2020/pbp_data/2020070404.parquet b/2020/pbp_data/2020070404.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..6afa16b0b3f36d8737da6d0e25a7131be6f0cc5b
--- /dev/null
+++ b/2020/pbp_data/2020070404.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b26ee77fe8575a3a877dd3255d8e7b592b061b3034e1014ab5a4789c1f34160
+size 16335
diff --git a/2020/pbp_data/2020070405.parquet b/2020/pbp_data/2020070405.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..72d6db0df5e2951e458e8bc0c06c9e6ac86aba58
--- /dev/null
+++ b/2020/pbp_data/2020070405.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2707f4a4cac6d18e76a9f600234494a4ed57b80fb6481c963e900bd51026e31d
+size 15736
diff --git a/2020/pbp_data/2020070506.parquet b/2020/pbp_data/2020070506.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3f429dfaedc755b3fac873662cc75b04469fb3da
--- /dev/null
+++ b/2020/pbp_data/2020070506.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e04fd712f81475798f2c16c38556d3177a7bcbfb391af5b2bccdb24b248aab4
+size 17270
diff --git a/2020/pbp_data/2020070904.parquet b/2020/pbp_data/2020070904.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ef240cd9aa16342f65c7c0a4441bb222b22bd08a
--- /dev/null
+++ b/2020/pbp_data/2020070904.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7ce72861cdafdee12b7104147a025683976f36a83ed8123636a5cb6acfe1fc4
+size 13064
diff --git a/2020/pbp_data/2020070905.parquet b/2020/pbp_data/2020070905.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b1901f14379c2da3864c3a126a2893bd834e5cc1
--- /dev/null
+++ b/2020/pbp_data/2020070905.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1812a8900f3ac938b680cb89d268d37380b2b01c8a6a2dd27aea370214e1e577
+size 18094
diff --git a/2020/pbp_data/2020071004.parquet b/2020/pbp_data/2020071004.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..bee5fa5a5f1850e14826351448f53fa4e9dac09a
--- /dev/null
+++ b/2020/pbp_data/2020071004.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14b3f9c51eca2fb82119841b0bd940569c1f1fd924e9338b38a87c81d11bc498
+size 17214
diff --git a/2020/pbp_data/2020071005.parquet b/2020/pbp_data/2020071005.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..47bf460ba6997829d3e00d863001b75c97d195cc
--- /dev/null
+++ b/2020/pbp_data/2020071005.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d676d3ba30d35ab27da0214b1fe3087636b6d6a6f7ec113bc82c3784de0c00a8
+size 17276
diff --git a/2020/pbp_data/2020071106.parquet b/2020/pbp_data/2020071106.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..de93453ac3b85d709a5c68ef8de3f4783f76d856
--- /dev/null
+++ b/2020/pbp_data/2020071106.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:febd3adaf786eb7b2c59d799626a3e3dcdd57fcc36c151c36784feb9a3d2f28b
+size 16702
diff --git a/2020/pbp_data/2020071202.parquet b/2020/pbp_data/2020071202.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..17106aa4966562de4acd5864a90d45fd4958eae1
--- /dev/null
+++ b/2020/pbp_data/2020071202.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cdde3adc619f3c36aecd133b1f2e163576d098b088586d5a9f16621e8f5fe57
+size 18309
diff --git a/2020/pbp_data/2020071203.parquet b/2020/pbp_data/2020071203.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d8788398b53132893c54fa7abea1858f25b10123
--- /dev/null
+++ b/2020/pbp_data/2020071203.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfb436c12d584efdef9d9b2ce66843453af5c1dbad7e9392664e3cb4860eb931
+size 16582
diff --git a/2020/pbp_data/2020071402.parquet b/2020/pbp_data/2020071402.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..300d1c28cb7aa691591a5f006d5acc0cb07b330b
--- /dev/null
+++ b/2020/pbp_data/2020071402.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f708d3759a085ae282be00a5bb89795ea7f7e46df3f48d753529041b649c193
+size 17002
diff --git a/2020/pbp_data/2020071403.parquet b/2020/pbp_data/2020071403.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d6345cfc112f4152e5543a74a5f608a61b8dace2
--- /dev/null
+++ b/2020/pbp_data/2020071403.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86f70afb172d1d5c595ae9a900f0e020b3312a7d22835a9c4164432370d19d70
+size 18842
diff --git a/2020/pbp_data/2020071501.parquet b/2020/pbp_data/2020071501.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..900604fa3fbea961d475be40fe04363786a49d90
--- /dev/null
+++ b/2020/pbp_data/2020071501.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9cf7505f1bf6fe75ba4e334ee34b071e6b1dcfdeff0c7ec9b75a7ec13ccf1a3
+size 16900
diff --git a/2020/pbp_data/2020071604.parquet b/2020/pbp_data/2020071604.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2dc257c0ccd648459f89352aa83d33696578efde
--- /dev/null
+++ b/2020/pbp_data/2020071604.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68fe7585ef2d4cf238032db99396b019cdf500d1c2adf43fca0dee96b46c84fe
+size 17573
diff --git a/2020/pbp_data/2020071605.parquet b/2020/pbp_data/2020071605.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1489dcffe9c29ef827bafd717f4c877679ebc3d0
--- /dev/null
+++ b/2020/pbp_data/2020071605.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f7cad06238402664bf4f1092343cdaeed8589b9cf60c2f513f7d3fbc950ec39
+size 17778
diff --git a/2020/pbp_data/2020071706.parquet b/2020/pbp_data/2020071706.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d551a3c84384ed129587974a34ad7ce69c4a083c
--- /dev/null
+++ b/2020/pbp_data/2020071706.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b864b0db561b1f265511531f22152de210d41d35b7dbccb49b43812d962fbca6
+size 17340
diff --git a/2020/pbp_data/2020071801.parquet b/2020/pbp_data/2020071801.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2a495fdf385484278c6f5dfd91e8f8d964989f2e
--- /dev/null
+++ b/2020/pbp_data/2020071801.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6b27cd12043880981d0c297aa91b7c720a889efe193ed11a274831e3a3bf359
+size 16447
diff --git a/2020/pbp_data/2020071902.parquet b/2020/pbp_data/2020071902.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a9164dbb022631ec7ed46cd48cf85b6f24c0fcf5
--- /dev/null
+++ b/2020/pbp_data/2020071902.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c660475023b526cbfcef1fa5553a6f29121e0b55d72013ab45e26fc04ddabca
+size 18587
diff --git a/2020/pbp_data/2020071903.parquet b/2020/pbp_data/2020071903.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..963889b53a4323dd9d8cb902f47d1a1e39358be6
--- /dev/null
+++ b/2020/pbp_data/2020071903.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b3ee66eb96e041e4bde52f0ca7164d2e9ebebe9d3c5ca4ca6d796bd3567593e
+size 18367
diff --git a/2020/pbp_data/2020072102.parquet b/2020/pbp_data/2020072102.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9395686d56d67e35cbf2e2c5dd357ef5d556c7b6
--- /dev/null
+++ b/2020/pbp_data/2020072102.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9f9f0f3b33375fffebd1f5cd2433bcedab877806537529600b7da490560f6dc
+size 16537
diff --git a/2020/pbp_data/2020072103.parquet b/2020/pbp_data/2020072103.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..176b0039d4c233f00b1bd1b5c1f5405fc2b3e5aa
--- /dev/null
+++ b/2020/pbp_data/2020072103.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61a8b2501883d1df91dfb38dec827437350ecaa6966cbe45003d2f4c8ca98eaf
+size 17214
diff --git a/2020/pbp_data/2020072206.parquet b/2020/pbp_data/2020072206.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2038f84a07171def80b5f715c420e6f0b2c43a1e
--- /dev/null
+++ b/2020/pbp_data/2020072206.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96b73a433b358c215a3d12671c9d1a8b91f17ad5977dd1a25f46928f3aa80320
+size 17116
diff --git a/2020/pbp_data/2020072304.parquet b/2020/pbp_data/2020072304.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3a842d9c3d8e4962de61c4b9f0e830f2cbf8cd49
--- /dev/null
+++ b/2020/pbp_data/2020072304.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbe5d35fc49a329199ec1d696756947e299ca417b9c3323fb565ae35bc7f0f80
+size 18161
diff --git a/2020/pbp_data/2020072305.parquet b/2020/pbp_data/2020072305.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e2f5cd63b75f473ac18846884cefd81d6424a458
--- /dev/null
+++ b/2020/pbp_data/2020072305.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c716f54d2ebfa1efae30a1913bd46a0c7b4ecb65c559f68a87080c740a34def9
+size 16455
diff --git a/2020/pbp_data/2020072406.parquet b/2020/pbp_data/2020072406.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..83b2d2b2d18506cff825cec425a34887a9271bbb
--- /dev/null
+++ b/2020/pbp_data/2020072406.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25ffdeda542f55cfc372e832c67be59c5689f2978a89fc983720a58ca79c353c
+size 16456
diff --git a/2020/pbp_data/2020072504.parquet b/2020/pbp_data/2020072504.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a9302f7502a48a4d618c99c0aeff21bfbdb18d25
--- /dev/null
+++ b/2020/pbp_data/2020072504.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1159618ef7b4a40da15600f50fc59f7ac957ab28ca4e4d8b568348419fbd386
+size 17056
diff --git a/2020/pbp_data/2020072505.parquet b/2020/pbp_data/2020072505.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..adf64bc94b373fe8123582d584ba78edb1e07cda
--- /dev/null
+++ b/2020/pbp_data/2020072505.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9aa42de3dbc1bb85abfd705bf7c039c6abf9cc07bf6291f950528792303397db
+size 16876
diff --git a/2020/pbp_data/2020072601.parquet b/2020/pbp_data/2020072601.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..04ce2532686aa9e767e53a040d885d236ae337f4
--- /dev/null
+++ b/2020/pbp_data/2020072601.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1183ca81e2d5cf7977edca817fe1099349b7eb5b16b58442c8ff632d594d07d6
+size 17468
diff --git a/2020/pbp_data/2020072804.parquet b/2020/pbp_data/2020072804.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..84a72c74e23fdb7543288ee556a61f6e95a94612
--- /dev/null
+++ b/2020/pbp_data/2020072804.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cde4b7e4c1896060374a0cc56e0441b3e6c4a5675fb1cb0fd2a1d32569beef8
+size 16471
diff --git a/2020/pbp_data/2020072805.parquet b/2020/pbp_data/2020072805.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a643e943a0d5932f43d5244c67dba93779a08629
--- /dev/null
+++ b/2020/pbp_data/2020072805.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9d7698f95d96c829fabe4a91aece84b54b1b077a29f3687fea88c4478ada93d
+size 19092
diff --git a/2020/pbp_data/2020072906.parquet b/2020/pbp_data/2020072906.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..41069d3e8d4174713fc0254550d6dc091549c25b
--- /dev/null
+++ b/2020/pbp_data/2020072906.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:916f188ef5aa57c84d697b2c88e9a2c6e35445cf37852359696da045e2936889
+size 16590
diff --git a/2020/pbp_data/2020073006.parquet b/2020/pbp_data/2020073006.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..bd88d1ed30216379acea629f506012fe6693c74a
--- /dev/null
+++ b/2020/pbp_data/2020073006.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af9e5707f5e08d0c781e08697cadec5cdef9a4847780165bacb2e88bf21b1ced
+size 17121
diff --git a/2020/pbp_data/2020073104.parquet b/2020/pbp_data/2020073104.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7fbf10051f12cd11d87ad0e745e7da85e185a0ae
--- /dev/null
+++ b/2020/pbp_data/2020073104.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a8bc716e7681706eb3e896392ab1789f568c57d5999162cad3c0e725f886288
+size 17642
diff --git a/2020/pbp_data/2020073105.parquet b/2020/pbp_data/2020073105.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a5a24fdf1ba3ec947801ae6424ae61e1c27861e8
--- /dev/null
+++ b/2020/pbp_data/2020073105.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac459b47201a5a4d83072454a29c1192b97f1f85c50cb35b7291f402907ef609
+size 17574
diff --git a/2020/pbp_data/2020080102.parquet b/2020/pbp_data/2020080102.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..16c2d572359889b856c82a83fa0630c196377dad
--- /dev/null
+++ b/2020/pbp_data/2020080102.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45fc9f0c49e6236c1ac522af8524997f0cfffbcca01e4b5f1c075021506be1a7
+size 15595
diff --git a/2020/pbp_data/2020080103.parquet b/2020/pbp_data/2020080103.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..deaf85ca4230e3db5e065d946aecdded683aff14
--- /dev/null
+++ b/2020/pbp_data/2020080103.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c07f95880137e558ea573303cb6c209945c9de367b7e3d7fd23ab5b645b4f17
+size 17201
diff --git a/2020/pbp_data/2020080406.parquet b/2020/pbp_data/2020080406.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2708fd6c0231955cca47c2d9c838687ba4ca9273
--- /dev/null
+++ b/2020/pbp_data/2020080406.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c7166f813f4f378e60cf5e77653595e354f89d19c6c578740b1bbff00d7568c
+size 18559
diff --git a/2020/pbp_data/2020080504.parquet b/2020/pbp_data/2020080504.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b2066a475dad7a48a7ac596bef434ca30eec024e
--- /dev/null
+++ b/2020/pbp_data/2020080504.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55ab9555ad24505c85472b5fd0e1330ef8669eff2462ec1f78439f06755bf6c0
+size 17768
diff --git a/2020/pbp_data/2020080505.parquet b/2020/pbp_data/2020080505.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..59a05b2f8e88e3087493b6f8a5a9ad7af7027d59
--- /dev/null
+++ b/2020/pbp_data/2020080505.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:091002e68141c1c9c221b632c914334b66d56d581ef29b4a5b6759fe239ec4ee
+size 16900
diff --git a/2020/pbp_data/2020080601.parquet b/2020/pbp_data/2020080601.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d8070f3c319d3a2cc4630ee6a32b6e45c45da797
--- /dev/null
+++ b/2020/pbp_data/2020080601.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02e1d2992c8c54903e2280d86374ed3a18c440bb92619edf138f0a05926d651c
+size 17834
diff --git a/2020/pbp_data/2020080702.parquet b/2020/pbp_data/2020080702.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7a500b5990900f1761d5e4e2c008954dc59eb1a5
--- /dev/null
+++ b/2020/pbp_data/2020080702.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f6f78154c04b344f23a5a66ffac7ff707d51ee7a89731ae71bd6d44d7462651
+size 16452
diff --git a/2020/pbp_data/2020080703.parquet b/2020/pbp_data/2020080703.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b64b26b1ec77399c10717ae64140aafe32468d3c
--- /dev/null
+++ b/2020/pbp_data/2020080703.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f8aa1bf007326a753cab17841f51f8c2b1ed4e7aeaf42e43700e653fc29bd72
+size 18206
diff --git a/2020/pbp_data/2020080804.parquet b/2020/pbp_data/2020080804.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0bcd983a66339b8df00a2cb6a2ccbf3bf12126d0
--- /dev/null
+++ b/2020/pbp_data/2020080804.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8393bcfb2fda7f0bd541fe9e4ecabceec199793709240d45027c08ac805c6506
+size 17901
diff --git a/2020/pbp_data/2020080805.parquet b/2020/pbp_data/2020080805.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..fb4a8aed520584099ce2771e038c32f3dcdf2b15
--- /dev/null
+++ b/2020/pbp_data/2020080805.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7de5e6e5b521a865efc1df1a7e90f27319e7d4e1066ceecd5b5f66661fa8b2f8
+size 16603
diff --git a/2020/pbp_data/2020080906.parquet b/2020/pbp_data/2020080906.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..672fc79e7f405f684b6374ca058c10fcfe069776
--- /dev/null
+++ b/2020/pbp_data/2020080906.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b550e539cbce5e8cdec7c802ec33621f588af40dacb780ce633055120b513f74
+size 16741
diff --git a/2020/pbp_data/2020081104.parquet b/2020/pbp_data/2020081104.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..576fb41a1ca0f8177eb3fae18402e1d4e992cfd3
--- /dev/null
+++ b/2020/pbp_data/2020081104.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0615832726b6d44ffa4a5a7bcd0c900356c088d9e4ded64203e33d46064de7ff
+size 17452
diff --git a/2020/pbp_data/2020081105.parquet b/2020/pbp_data/2020081105.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..31116757e0440a2c05ed9b77de3d5de7fdb3f5d2
--- /dev/null
+++ b/2020/pbp_data/2020081105.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5836d8581921ce91a1fa6e788cca88c11dcf492b31b0723da290e0fa84f952a
+size 18109
diff --git a/2020/pbp_data/2020081201.parquet b/2020/pbp_data/2020081201.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ff6737ad8918645dda5487ebec506b77e3d773d3
--- /dev/null
+++ b/2020/pbp_data/2020081201.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e30ea5cc7dabebaae3617779eda5de2e94bae6e6a98bb5b8d90438e4e4192b48
+size 17832
diff --git a/2020/pbp_data/2020081302.parquet b/2020/pbp_data/2020081302.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..f55046bb59ab587a9c3d77b46d69c4d1cf100c53
--- /dev/null
+++ b/2020/pbp_data/2020081302.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edf26b0b72f7c83e818b1952b187037e545451773b7cbe1cf83313c627b9ef13
+size 18160
diff --git a/2020/pbp_data/2020081303.parquet b/2020/pbp_data/2020081303.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..964cd6148790572b133c0644ef719623ef62f4b0
--- /dev/null
+++ b/2020/pbp_data/2020081303.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd17be24404b51490d833eabb5195742b47f51cd6902b8017e5c1c3d373e4dd3
+size 17918
diff --git a/2020/pbp_data/2020081401.parquet b/2020/pbp_data/2020081401.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7b3cc068dd7d2e9c7fb7a4f73012c7d9a03a169e
--- /dev/null
+++ b/2020/pbp_data/2020081401.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5928c08b1b6f0be6782898c34c9e18529d4d488f5919ae84a21209353582b8d
+size 16512
diff --git a/2020/pbp_data/2020081502.parquet b/2020/pbp_data/2020081502.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..4bd79ab5c20b09fbd5ab5e0c9529571a02a85ec8
--- /dev/null
+++ b/2020/pbp_data/2020081502.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0190d18fb5406cecda66a8fc4d33ae28be6fec299555a0cb18bb78672aa1746f
+size 16997
diff --git a/2020/pbp_data/2020081503.parquet b/2020/pbp_data/2020081503.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c0b663a64782d0fa64cf1351f611b96c98f96005
--- /dev/null
+++ b/2020/pbp_data/2020081503.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7f3a86718361d9f785b1787ee9eb252d330739b5e5ac9db8bac785fbac40884
+size 17015
diff --git a/2020/pbp_data/2020081606.parquet b/2020/pbp_data/2020081606.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2e3897752c5580f620649675213eb3b8f085dbe0
--- /dev/null
+++ b/2020/pbp_data/2020081606.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e65c68b35c8525fe6929e1361a22bc2c1acc59543a9b7c4e1d7156eb06d420a2
+size 17907
diff --git a/2020/pbp_data/2020081802.parquet b/2020/pbp_data/2020081802.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..8ea8cf0109d5efa629748611743c85591190a537
--- /dev/null
+++ b/2020/pbp_data/2020081802.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0d62be4f44d217385e4b2658f167aa535272a92e8197edf576cfdeffce168ae
+size 17447
diff --git a/2020/pbp_data/2020081901.parquet b/2020/pbp_data/2020081901.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..da87843325bcce4010bd623f8841fde3222375e5
--- /dev/null
+++ b/2020/pbp_data/2020081901.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9068e3f2ad482d9d2bdbf688717a087c258e2f39b293d87aaa71e227650d360
+size 17311
diff --git a/2020/pbp_data/2020082002.parquet b/2020/pbp_data/2020082002.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..92ff6f18e172693d70ff9980adb6bc4b60a3827d
--- /dev/null
+++ b/2020/pbp_data/2020082002.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbb2af5a7d415b36080118860a26bbb05c259a4ff0aa9f4d5810e03dc828b358
+size 18162
diff --git a/2020/pbp_data/2020082003.parquet b/2020/pbp_data/2020082003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..03124f5296d224da221f6e7e3999abb645898cb4
--- /dev/null
+++ b/2020/pbp_data/2020082003.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec7ca1433d6cd769429ebfb648eecf14898cfa6f24fbdc9812aa5e6741f329c6
+size 17663
diff --git a/2020/pbp_data/2020082101.parquet b/2020/pbp_data/2020082101.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..133d96b53647c1a27d49319c49fbd25e10f16b10
--- /dev/null
+++ b/2020/pbp_data/2020082101.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efb8b0db26821a2c424bbfd4baf9df3fec17dc894eb8c68f2a2558bea3480a02
+size 16681
diff --git a/2020/pbp_data/2020082204.parquet b/2020/pbp_data/2020082204.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..445810de2c59dfd4e8fa1d6c36a79e718ee3b227
--- /dev/null
+++ b/2020/pbp_data/2020082204.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c115464df6b81687f95c3de15a0c9d7856caf3b21c4a8d31a746433f1271e74d
+size 16488
diff --git a/2020/pbp_data/2020082205.parquet b/2020/pbp_data/2020082205.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..922a193f7e5946e13b4d127333ff738b5a296c64
--- /dev/null
+++ b/2020/pbp_data/2020082205.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:635b60a22d7207e08db13676b0c7719d636313518f5306f50e32f91b53bf5eda
+size 17338
diff --git a/2020/pbp_data/2020082306.parquet b/2020/pbp_data/2020082306.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..41a9c8abc5e6d31cd972bf3ecf4fc9d09daf3e35
--- /dev/null
+++ b/2020/pbp_data/2020082306.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1be00c4fe9f13d824e5a48895cf28ffb898817b00fa8c591b8ac99be68780e54
+size 17885
diff --git a/2020/pbp_data/2020082602.parquet b/2020/pbp_data/2020082602.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c5a0d4b9ca87577fd4de7f011f2310f77787c19f
--- /dev/null
+++ b/2020/pbp_data/2020082602.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:122a806cdd37833fb02e79c4b9c6398652a65119556adaf89b0949d5695f2403
+size 15728
diff --git a/2020/pbp_data/2020082603.parquet b/2020/pbp_data/2020082603.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..55c7af1f92d36bdaf9327f66ec55472bc5acbdc0
--- /dev/null
+++ b/2020/pbp_data/2020082603.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94526bd285da1afc74ebf68075758c75732a1a21760e0cee2184ab7100a37fc1
+size 16693
diff --git a/2020/pbp_data/2020082701.parquet b/2020/pbp_data/2020082701.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..af4a4197e5a4759f048f1a543cd77621dde6f747
--- /dev/null
+++ b/2020/pbp_data/2020082701.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf03635539052288a4ec760a59b2ef26a58e294d4999fb6691037e967353dea0
+size 17737
diff --git a/2020/pbp_data/2020082806.parquet b/2020/pbp_data/2020082806.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..43975cf00f8f939c870334eabbbad69e4c0c9cb0
--- /dev/null
+++ b/2020/pbp_data/2020082806.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:182414a9560fafa078ed93fac86031d4db43c66f3170396a51dd31e4d5b886ac
+size 17952
diff --git a/2020/pbp_data/2020082904.parquet b/2020/pbp_data/2020082904.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..6d66a4f51d22e571c84fad24dbcf4a7072f41743
--- /dev/null
+++ b/2020/pbp_data/2020082904.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01049ff3a7c2c43d134e8519bb979d7b577323dc5403cefa2b9526ce9b7c3ccb
+size 17384
diff --git a/2020/pbp_data/2020083004.parquet b/2020/pbp_data/2020083004.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b34c31002fc4c6cca8f357a92d42f1834207ae56
--- /dev/null
+++ b/2020/pbp_data/2020083004.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c654bcbc888e664bcc013ae6bbfe24098059be793bf98c2be54e0dd5e32d278
+size 17119
diff --git a/2020/pbp_data/2020083005.parquet b/2020/pbp_data/2020083005.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..bcc1c762951464a4f236532a36ec29f3db6d9efc
--- /dev/null
+++ b/2020/pbp_data/2020083005.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eaba712af5dfa50c9e3a0fe64a32ff1fc0c905c70600be7e0fd134335b5206d7
+size 16487
diff --git a/2020/pbp_data/2020090104.parquet b/2020/pbp_data/2020090104.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7d3cfa10e548dab7b3e3f53294dc8858fd7e3e6f
--- /dev/null
+++ b/2020/pbp_data/2020090104.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36b7fe51136f32646f575200275b46b02f1bd6c27f997e8b06543b286e9c5bc0
+size 17733
diff --git a/2020/pbp_data/2020090105.parquet b/2020/pbp_data/2020090105.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9b3c5b94f5358675ebea73917ef7ce3d460b0310
--- /dev/null
+++ b/2020/pbp_data/2020090105.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39052a415e41e54df19e75bd1fdc139b9b9bda242e6c4d6d0ea4ff639461a5d9
+size 17410
diff --git a/2020/pbp_data/2020090302.parquet b/2020/pbp_data/2020090302.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e38c62660815c5d72d7ada6e6d67432b024a6f7a
--- /dev/null
+++ b/2020/pbp_data/2020090302.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:601630a538ca5c9e6c6be3e565d21e8d06c5571a48e4f7e29bbf3cf278b032ff
+size 16502
diff --git a/2020/pbp_data/2020090303.parquet b/2020/pbp_data/2020090303.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..41bd13fb992c48b7cfc5351697695e521df78e41
--- /dev/null
+++ b/2020/pbp_data/2020090303.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c0635c59bf54876a3e9fe9d68b94e203d25c746793f574600f7af388972e362
+size 16639
diff --git a/2020/pbp_data/2020090401.parquet b/2020/pbp_data/2020090401.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..72ec99093a2aeb6dc31a4c29ad8dadf0d02d93c3
--- /dev/null
+++ b/2020/pbp_data/2020090401.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2475acd1a4b4fa425c42ed23baa15b29ce7a774aec4d8fa79e28cc6b652e81cc
+size 17044
diff --git a/2020/pbp_data/2020090502.parquet b/2020/pbp_data/2020090502.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..f2e2687279df714682fa34c8bf6c9a0a4cf0fada
--- /dev/null
+++ b/2020/pbp_data/2020090502.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c9dcb75ccf1af7fb51e301b1781d14bf2960084b152a62212fe10fce860de7d
+size 17416
diff --git a/2020/pbp_data/2020090503.parquet b/2020/pbp_data/2020090503.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..785de03b53087a55fc4742bdb62d65e3cb7c447c
--- /dev/null
+++ b/2020/pbp_data/2020090503.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd59bf11660759838e47ea199ce855321213bfc80ca40271ebb24ff4e7c7c81a
+size 17165
diff --git a/2020/pbp_data/2020090606.parquet b/2020/pbp_data/2020090606.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..abb082cfd44eb8aa1d60543c790240253ffe81fd
--- /dev/null
+++ b/2020/pbp_data/2020090606.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31fc6b68ae716d3c0bbed47252ee3d2bb7e1ec3a721a8a5b6c964c16552f8c40
+size 17314
diff --git a/2020/pbp_data/2020090802.parquet b/2020/pbp_data/2020090802.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d0bddbfdb238fa00bbfe29eca9895695a28f6685
--- /dev/null
+++ b/2020/pbp_data/2020090802.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a03b66286d7e2885791f135f7fec9f613b5859d04494ca20f0e5f273eeade88
+size 15903
diff --git a/2020/pbp_data/2020090803.parquet b/2020/pbp_data/2020090803.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..4837e7f979d7b6f57ed225f3c4fd9f9c3e0a1581
--- /dev/null
+++ b/2020/pbp_data/2020090803.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:641ef9130a452c44ba286967ce157dcb0650e1b54f623521fb839352382cb9c3
+size 16791
diff --git a/2020/pbp_data/2020090901.parquet b/2020/pbp_data/2020090901.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c14a0994e49f4d3cac7f490b5e3664f081a33dc0
--- /dev/null
+++ b/2020/pbp_data/2020090901.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:693264e1671280d6730af5e5caecacaddac1e2fc53e47ad485af8a8ed66bd3bb
+size 16961
diff --git a/2020/pbp_data/2020091001.parquet b/2020/pbp_data/2020091001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..4aea71df3ffe0f56b1e219cd482411af1c9f9589
--- /dev/null
+++ b/2020/pbp_data/2020091001.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:064b390154036e677c5f50f33ecda4d6d81f0d156190103e90994b5b33d88266
+size 18091
diff --git a/2020/pbp_data/2020091102.parquet b/2020/pbp_data/2020091102.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..272ea60cbf4c2384bdb214bc898f731e3b084ff9
--- /dev/null
+++ b/2020/pbp_data/2020091102.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a3fddac660ceaaf97cc81b6c0f2df768c97924bf067da340a2f2bc2a329ab98
+size 17067
diff --git a/2020/pbp_data/2020091103.parquet b/2020/pbp_data/2020091103.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d5a2852c5e1e4bc06623655d49b22d2b5063626e
--- /dev/null
+++ b/2020/pbp_data/2020091103.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0069f828ae51a15c3c4d2d5563d4b974dcbc4682553574b0a517874442f02dfa
+size 15613
diff --git a/2020/pbp_data/2020091206.parquet b/2020/pbp_data/2020091206.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1576f4f29d816ef696e1e6f24cbd9e9bafe9acb4
--- /dev/null
+++ b/2020/pbp_data/2020091206.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9cb1b88d5da640ae7ee20ae9f23868b15cd41fa4882925a48189d56a9866c66
+size 17154
diff --git a/2020/pbp_data/2020091304.parquet b/2020/pbp_data/2020091304.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0b23a29e47f589eed3966de37e8e4d237aa557b3
--- /dev/null
+++ b/2020/pbp_data/2020091304.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b57ed0f10390ef6a64970893e0d911808394a95a60693ed24d945d8a7cb97e19
+size 18346
diff --git a/2020/pbp_data/2020091305.parquet b/2020/pbp_data/2020091305.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b3ef21c42643d103980ef01535ff53ffba3bf97d
--- /dev/null
+++ b/2020/pbp_data/2020091305.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7e28de734955cd98b8482489271982f9b03521fb22ae8663626536f0b4909de
+size 17556
diff --git a/2020/pbp_data/2020091504.parquet b/2020/pbp_data/2020091504.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..35b0aff4072f41952a02d842405cf55928dba477
--- /dev/null
+++ b/2020/pbp_data/2020091504.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0556142236efd398fb57c8e3f692870460f65fd40aafed0951165fc7e117be69
+size 16995
diff --git a/2020/pbp_data/2020091601.parquet b/2020/pbp_data/2020091601.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ef96b5609cb804219d6f3a379eacde75c17b010e
--- /dev/null
+++ b/2020/pbp_data/2020091601.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01447d2c8d42773bda2c783dcf097b43eaca8c763b423c3043560506e8020b3a
+size 17373
diff --git a/2020/pbp_data/2020091702.parquet b/2020/pbp_data/2020091702.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b1a7ed631a04b3f2f872657fa9365b16d9f43fbc
--- /dev/null
+++ b/2020/pbp_data/2020091702.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b590fbd0eb7ef0075da1c8011c355a7c2e96bf1996e767f35edba98c02b6df07
+size 17460
diff --git a/2020/pbp_data/2020091703.parquet b/2020/pbp_data/2020091703.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1965967669cb08754110dc12753417bb8f45e159
--- /dev/null
+++ b/2020/pbp_data/2020091703.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e95ec456fbf2629be5f479dca44804a0827a1eb8c593433c21b658f80ff1c83
+size 135
diff --git a/2020/pbp_data/2020091804.parquet b/2020/pbp_data/2020091804.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9f356103cc3e17751107251c22aaa1b4b300b017
--- /dev/null
+++ b/2020/pbp_data/2020091804.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6976e4a1575edd8122319e4e0783c910e9cfb42b1c0ddc5f63a39a48e912503e
+size 18270
diff --git a/2020/pbp_data/2020091805.parquet b/2020/pbp_data/2020091805.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..faac641fe12d918786eabfa06605db3e8fa694b9
--- /dev/null
+++ b/2020/pbp_data/2020091805.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:009196738731a46de53246824000221775738a4f33ffc2a22f57a2082fa3b7fb
+size 17680
diff --git a/2020/pbp_data/2020092004.parquet b/2020/pbp_data/2020092004.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ed3bc5a5f6ab93102687bf06c198bc72c66d9d20
--- /dev/null
+++ b/2020/pbp_data/2020092004.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fd407f924a0f666f70dbbf427e4955728596f3a4a5493775dba2688a5b64d3b
+size 18640
diff --git a/2020/pbp_data/2020092005.parquet b/2020/pbp_data/2020092005.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..7967f379328aaf58c3852bc3dff4c7328198ad73
--- /dev/null
+++ b/2020/pbp_data/2020092005.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adbba1a8c3a7f2b1c62cf4a059976382ac043e1cd1d2566ea5798f46e6b13dbd
+size 16891
diff --git a/2020/pbp_data/2020092202.parquet b/2020/pbp_data/2020092202.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2c63b5ef846ade873b2c952bcea80423294808b9
--- /dev/null
+++ b/2020/pbp_data/2020092202.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cd9977e019a4ea6d2167fe591cb63382317ea9fb73c376df063788517f91065
+size 15891
diff --git a/2020/pbp_data/2020092203.parquet b/2020/pbp_data/2020092203.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c0667ba9c7047862848c7dd7fe9b287cc8c10e3d
--- /dev/null
+++ b/2020/pbp_data/2020092203.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ba3ba36fc62131dedc0b4977cc21fb48f70e100300e142938fa64c4a8346266
+size 16794
diff --git a/2020/pbp_data/2020092301.parquet b/2020/pbp_data/2020092301.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0380f9d7ee190fde6f52669d2d113cacab17c615
--- /dev/null
+++ b/2020/pbp_data/2020092301.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99bbbf5b72907f6dd9c4b48534e4645695fc130a008de66e310b364bafea8282
+size 16702
diff --git a/2020/pbp_data/2020092402.parquet b/2020/pbp_data/2020092402.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b44fd7739b1c07afa36d4191a1ff61615754a79e
--- /dev/null
+++ b/2020/pbp_data/2020092402.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84fb362c83f1dba03ee69af9f1a52201d025b1d748f560a616d7b23ade5d47c4
+size 17897
diff --git a/2020/pbp_data/2020092403.parquet b/2020/pbp_data/2020092403.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3adea6da8f9dc439465aedfc97d6878c9f74b6de
--- /dev/null
+++ b/2020/pbp_data/2020092403.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0dd32d68a730958f449fa92acf625d9754b991e77cf127eba972b364b1e43a39
+size 17710
diff --git a/2020/pbp_data/2020092501.parquet b/2020/pbp_data/2020092501.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5f681b8236044f8e519a787d368f52e470341a74
--- /dev/null
+++ b/2020/pbp_data/2020092501.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b01898cf48adc4c824c41c2e2fc620fb2bfee72ba68a58239571b10898ab66
+size 17786
diff --git a/2020/pbp_data/2020092604.parquet b/2020/pbp_data/2020092604.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e62ad24ebfe895e0f019f088509384a5b3b741f5
--- /dev/null
+++ b/2020/pbp_data/2020092604.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ceb300fbedcdd343991292a76d9b7ee469d53c8ed841f3a06471658d2b5aeec2
+size 17188
diff --git a/2020/pbp_data/2020092605.parquet b/2020/pbp_data/2020092605.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..fcafa8255d5e1ae5370c4e4e9d8892cbb9dae4a9
--- /dev/null
+++ b/2020/pbp_data/2020092605.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ade6632918b1e26424d0c04b76abdd07d7dea0d36ede2726ebd79addeb87095
+size 18262
diff --git a/2020/pbp_data/2020092706.parquet b/2020/pbp_data/2020092706.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..364ddc166e3998870fcb758b13d72b1d6d568d78
--- /dev/null
+++ b/2020/pbp_data/2020092706.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20b0e38b394d9b8316d00ea2b3b4f1f797c20499578818b782d8998f06e7518a
+size 18284
diff --git a/2020/pbp_data/2020092801.parquet b/2020/pbp_data/2020092801.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..f68d03e90324b176393ceb543cf29d799eea8ffa
--- /dev/null
+++ b/2020/pbp_data/2020092801.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e789a716a9fbf782f30afdd32426fd1125424a58d7ce1ec9b09cba3f36e440c2
+size 16775
diff --git a/2020/pbp_data/2020092902.parquet b/2020/pbp_data/2020092902.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..4658f04e8e46081cf4240b7eeb3954355f3da7ff
--- /dev/null
+++ b/2020/pbp_data/2020092902.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f36946beb096553aa73ec0b11eb3e4947e984c3bcbaa5e1a8ca94f65d014f9f0
+size 17476
diff --git a/2020/pbp_data/2020092903.parquet b/2020/pbp_data/2020092903.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..27dac17467e013dceac7600106e5c4df41f2fbc6
--- /dev/null
+++ b/2020/pbp_data/2020092903.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e828b3f9e7da30d81004766f090141c267ee6f9d265ef3e97d90334dd8102dc5
+size 17249
diff --git a/2020/pbp_data/2020093002.parquet b/2020/pbp_data/2020093002.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..bacee6d92eb976d5719bd6624ee9ab47c0bbf7e0
--- /dev/null
+++ b/2020/pbp_data/2020093002.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fdbbf1cc8bc163a373a54091230eedc17a776c3b06d549552d6358a75ae64d2
+size 17106
diff --git a/2020/pbp_data/2020100104.parquet b/2020/pbp_data/2020100104.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..73b539de47d2cda8b2133422227d823b0491f942
--- /dev/null
+++ b/2020/pbp_data/2020100104.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1c7fbd32a087cc0574a6fc721501109359345cea2e2de7897e825d987b65903
+size 17964
diff --git a/2020/pbp_data/2020100105.parquet b/2020/pbp_data/2020100105.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..665077abcf839fb76158ce89ad458139b5dac861
--- /dev/null
+++ b/2020/pbp_data/2020100105.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b18dd3e4c3d36e166fdf9069af639edfa99c2b024df6732772b7560272fb93a
+size 17076
diff --git a/2020/pbp_data/2020100201.parquet b/2020/pbp_data/2020100201.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..21da3997039d485f4232729617235d0e0c7cca2d
--- /dev/null
+++ b/2020/pbp_data/2020100201.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b5c175f047ffc8bf17bdbdda80cff7e94a3199ac2a9022aadad4b6eb4f986cb
+size 18051
diff --git a/2020/pbp_data/2020100302.parquet b/2020/pbp_data/2020100302.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..a8b9111cbc097725e17d2c9f06ab9647b623da36
--- /dev/null
+++ b/2020/pbp_data/2020100302.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dfaebf64a1e155373fc2c6c6b02c3cfccac74fd408f38c2f5d97795dfa49887
+size 17377
diff --git a/2020/pbp_data/2020100303.parquet b/2020/pbp_data/2020100303.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..332c11b4951e8aaaf9ecfe7782fe3d58afd00749
--- /dev/null
+++ b/2020/pbp_data/2020100303.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44bac215acb25ec3220abceb6952095534f67802340aedffa7be614137635fa1
+size 18099
diff --git a/2020/pbp_data/2020100401.parquet b/2020/pbp_data/2020100401.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..ccb917a25c868a8a5226dbaf55f99dfa31f5eff2
--- /dev/null
+++ b/2020/pbp_data/2020100401.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75d12e400df2c9d6c7b014fea352ee7317011d6a8ab7c7d4b3cb1a9f831a47d7
+size 17633
diff --git a/2020/pbp_data/2020100606.parquet b/2020/pbp_data/2020100606.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b800a0b4d4a644183214ec3a1bb67480ac5e1393
--- /dev/null
+++ b/2020/pbp_data/2020100606.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2785a6267568317f79bd5cf9debf7b510085f258a8f9b47bbda8d8fb1559808
+size 16094
diff --git a/2020/pbp_data/2020100704.parquet b/2020/pbp_data/2020100704.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..86d0dd1bf2edabcf7083d97b14ccf258334aff9d
--- /dev/null
+++ b/2020/pbp_data/2020100704.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e33d544150259699a5e22f92324a560090062ad0afeb150fcfb6d8b54e4ebc4d
+size 18477
diff --git a/2020/pbp_data/2020100705.parquet b/2020/pbp_data/2020100705.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9e776967d1286ffd578097b0c895bc990fec4f5a
--- /dev/null
+++ b/2020/pbp_data/2020100705.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cca9c63c648d4bc4270aff814ce4133f668e3e0a5c5e31eba070d705b5d2c7d2
+size 18057
diff --git a/2020/pbp_data/2020100802.parquet b/2020/pbp_data/2020100802.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..85ae91899bdce679b54e2c3ef1a428b89afa6dfa
--- /dev/null
+++ b/2020/pbp_data/2020100802.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36589f9d624539a629d063faa4281ffed5882a0386a214a075946a26e3e6fb60
+size 17108
diff --git a/2020/pbp_data/2020100803.parquet b/2020/pbp_data/2020100803.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d06e33e109a54553f55446f29b6335207047dc0f
--- /dev/null
+++ b/2020/pbp_data/2020100803.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc5a34257d0ce3634f278dcca7e0c6adcc2522d1ce5cad3cc6ddcde4a76d8e66
+size 17610
diff --git a/2020/pbp_data/2020101001.parquet b/2020/pbp_data/2020101001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..53f78b8f08f54ccf93e89160160e5b08a956ec50
--- /dev/null
+++ b/2020/pbp_data/2020101001.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2b58e55f9ee3f120e2b128b2fe7e0d1dc432cd1d8dffab0f423408eaef80926
+size 17310
diff --git a/2020/pbp_data/2020101102.parquet b/2020/pbp_data/2020101102.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..636753f55db5968169634ea0873938335b7eb37b
--- /dev/null
+++ b/2020/pbp_data/2020101102.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78212170fd525b11d54e068c9f467fc9b7590d257fd4e819055ac14af512454e
+size 16090
diff --git a/2020/pbp_data/2020101103.parquet b/2020/pbp_data/2020101103.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3be2a6e76a0ab548bffad96b923a8ec7bb479a39
--- /dev/null
+++ b/2020/pbp_data/2020101103.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00012b386af8e7dd766f544229e0cb51006e4b0adfcbf107b610ffa4e68b842e
+size 17232
diff --git a/2020/pbp_data/2020101304.parquet b/2020/pbp_data/2020101304.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..6d635c48ef3b9b7085ceba2e5589e2a793427f32
--- /dev/null
+++ b/2020/pbp_data/2020101304.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a87f8a56bc5a188e52b27e45f7d6e6845faeaba2d0bc2ebe9d57eba9232d2e2c
+size 17390
diff --git a/2020/pbp_data/2020101305.parquet b/2020/pbp_data/2020101305.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2541319d859dd71f487612afa4be4ca2cd822ad2
--- /dev/null
+++ b/2020/pbp_data/2020101305.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5904d4743e65bc56cb35b2669d8cff2ba2e04c7f6c2df0f623f0bfa82d642cb
+size 16792
diff --git a/2020/pbp_data/2020101406.parquet b/2020/pbp_data/2020101406.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c86c5159364763bc16cd641b1be1889bd919e79b
--- /dev/null
+++ b/2020/pbp_data/2020101406.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb59e01c69d4ca13dee14ed209a7c211ad4b6b9f2b6bc217ad939f1cf6a31a20
+size 16904
diff --git a/2020/pbp_data/2020101504.parquet b/2020/pbp_data/2020101504.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..16b5d59ed10267b2ea40fa833abfee7b76d2bbd3
--- /dev/null
+++ b/2020/pbp_data/2020101504.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7b76c8bc14b4181283a7b758922743ad4c790411d5c9b8a0043e9b43ae6b83f
+size 18156
diff --git a/2020/pbp_data/2020101505.parquet b/2020/pbp_data/2020101505.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c208d2ceb6d346f22b72fbfc49585492cd81a513
--- /dev/null
+++ b/2020/pbp_data/2020101505.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86b665a803184db175c1f9c8b649f6d47e23592f22d6a4104fdc2a8d6f35e487
+size 16453
diff --git a/2020/pbp_data/2020101601.parquet b/2020/pbp_data/2020101601.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2c98441e0b02830577d0465e490488f3352c024b
--- /dev/null
+++ b/2020/pbp_data/2020101601.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:459de82d4bc4aaeb452641097358480b33ebe53ee3eba64e7df92d1d5e1d9e7d
+size 17009
diff --git a/2020/pbp_data/2020101702.parquet b/2020/pbp_data/2020101702.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..1965967669cb08754110dc12753417bb8f45e159
--- /dev/null
+++ b/2020/pbp_data/2020101702.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e95ec456fbf2629be5f479dca44804a0827a1eb8c593433c21b658f80ff1c83
+size 135
diff --git a/2020/pbp_data/2020101703.parquet b/2020/pbp_data/2020101703.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..4b9fcdef9302d696c945e81573e402b0489b85c0
--- /dev/null
+++ b/2020/pbp_data/2020101703.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a5bb17cd39ecda7624a31ae33e7300e79f06b4772a4964e8f5d8150bb705cc7
+size 16660
diff --git a/2020/pbp_data/2020101804.parquet b/2020/pbp_data/2020101804.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..fa4474f979ac6ae00fbe6080d883097e099efd03
--- /dev/null
+++ b/2020/pbp_data/2020101804.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69a180b4c36d9aff936fab87cd0023343b1dc288931bb4f377980def727346f0
+size 16033
diff --git a/2020/pbp_data/2020101805.parquet b/2020/pbp_data/2020101805.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d8a31e7000a5d891a94c2ef449c5ed7df24cbcd0
--- /dev/null
+++ b/2020/pbp_data/2020101805.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c58bfe98b7854385717980c675df6909a43ace12bd3e491445d2d75a008980c
+size 17356
diff --git a/2020/pbp_data/2020102005.parquet b/2020/pbp_data/2020102005.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..271f9fcb82c692831df5510d442a155840bec7a2
--- /dev/null
+++ b/2020/pbp_data/2020102005.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bd77709ffe5edb115cfbf074b21e32df355ca973be3dc6a6f82fdfdf513fa7f
+size 17541
diff --git a/2020/pbp_data/2020102106.parquet b/2020/pbp_data/2020102106.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b24882294af9d3dbc08ef9b492f3fb6e5c763ef0
--- /dev/null
+++ b/2020/pbp_data/2020102106.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13e7c91aa7e0a99e3555290be168f4626b99098b3e838eb5dd70fd55b3b6a56e
+size 16978
diff --git a/2020/pbp_data/2020102202.parquet b/2020/pbp_data/2020102202.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..020a69222fd35c959bfbecd9763a49319399dcf5
--- /dev/null
+++ b/2020/pbp_data/2020102202.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9acc641caad446470b3671aee12e477e63c8957cb5d6c3258e5a1c9f695d1452
+size 15495
diff --git a/2020/pbp_data/2020102203.parquet b/2020/pbp_data/2020102203.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..f15be42b25bc56f57294d43b9cb52fcb83572f95
--- /dev/null
+++ b/2020/pbp_data/2020102203.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3eb16e5fb4ceeb56b204099d7d56f8db2519099937e2193a8d9590b35e3c193d
+size 17241
diff --git a/2020/pbp_data/2020102301.parquet b/2020/pbp_data/2020102301.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e5bf4e508d841a2a0bfcd9add5db1da07c1f0af8
--- /dev/null
+++ b/2020/pbp_data/2020102301.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a334345c3893dc26d075b4c4bc635c2fb53a38b4f6ed46cb177a9cfe610ea80
+size 16886
diff --git a/2020/pbp_data/2020102402.parquet b/2020/pbp_data/2020102402.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..844b67c4b22b3867a1d90ac804cd298166c6b240
--- /dev/null
+++ b/2020/pbp_data/2020102402.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15be5256415d558880f7cdb9f5d69538a14cb66238b01fd192d78d8297c1bd60
+size 18122
diff --git a/2020/pbp_data/2020102403.parquet b/2020/pbp_data/2020102403.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5aa10d77fc4f8aa384c562f17743598c31a877ef
--- /dev/null
+++ b/2020/pbp_data/2020102403.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed5924ba598849c1502eb92a8cb1837ce16f68f0ed7e5e3aa295c7f37701d4e8
+size 17590
diff --git a/2020/pbp_data/2020102501.parquet b/2020/pbp_data/2020102501.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b601a5666ca7d7327829b7c6cab83d41f5a8295e
--- /dev/null
+++ b/2020/pbp_data/2020102501.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a087a21eba32037b81c6811fdaa55641668618d5349437e5886a5c10680d3708
+size 16481
diff --git a/2020/pbp_data/2020102706.parquet b/2020/pbp_data/2020102706.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b54af6cf4a2c498169173256b3e7db56886b477b
--- /dev/null
+++ b/2020/pbp_data/2020102706.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f422ba0b05d3acb600a8da08a27a0e4ae5307a4783581e958c97d0aefb22e04
+size 17120
diff --git a/2020/pbp_data/2020102801.parquet b/2020/pbp_data/2020102801.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c53dc21de978f02fec01ed3ad022fbcc11306891
--- /dev/null
+++ b/2020/pbp_data/2020102801.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:698b9d5e3d4054473837bc6f1a26afcff7c6503c1db8d7e211a5851fd8ee92d9
+size 18256
diff --git a/2020/pbp_data/2020102902.parquet b/2020/pbp_data/2020102902.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d06b7fc5095577f5688267ec58ba0a7b07f4b990
--- /dev/null
+++ b/2020/pbp_data/2020102902.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9860a02051ef084e3ed5a26ac2220c2d4af8658c4d4ee4ae8858edc92e14c5be
+size 16046
diff --git a/2020/pbp_data/2020102903.parquet b/2020/pbp_data/2020102903.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..99d22b0f79657cd17bcd25c061527d2e69dbf04f
--- /dev/null
+++ b/2020/pbp_data/2020102903.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:747555ae42cc8632b48818a6ef0f529f35cc61e1475cea2b8e1ae9f1d04f69e7
+size 17952
diff --git a/2020/pbp_data/2020103002.parquet b/2020/pbp_data/2020103002.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..0a26acf85f5680a0c6d750259d65db57f4c44c76
--- /dev/null
+++ b/2020/pbp_data/2020103002.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:367be37913816ead0734b3f2161a8660052d23ae711183b82d403e692f6d2e66
+size 18095
diff --git a/2020/pbp_data/2020103003.parquet b/2020/pbp_data/2020103003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..9b01bc247af88c0723da7d0776b89c345ce84061
--- /dev/null
+++ b/2020/pbp_data/2020103003.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f989e9d5fd7c40bcafd4ddc2503d0fc61b4060ac4c8f6fbab9bbc07f579e35dc
+size 17513
diff --git a/2020/pbp_data/2020103101.parquet b/2020/pbp_data/2020103101.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..71501d4c329a2f9aa2599473537159e1ac13b4d6
--- /dev/null
+++ b/2020/pbp_data/2020103101.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93b87de21a0b0291ce1959e44524f0b9c9a19937892cb1d7b3534b3bb32225cc
+size 17373
diff --git a/2020/pbp_data/2020110102.parquet b/2020/pbp_data/2020110102.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..434cf2949d564edb88bb36e2150b3d28567b5d0b
--- /dev/null
+++ b/2020/pbp_data/2020110102.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf7f9a9e2685bd75c0e4ad54bf55fca974545edcbfb8790877c3d6a834c5ccfb
+size 17278
diff --git a/2020/pbp_data/2020110103.parquet b/2020/pbp_data/2020110103.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5191b706500b22d4f88039aaa697b639347d2262
--- /dev/null
+++ b/2020/pbp_data/2020110103.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9319cdfc2af76a2c9a62f34f9972868989f6b0d8755cf83255471775dd196eb7
+size 16755
diff --git a/2020/pbp_data/2020110304.parquet b/2020/pbp_data/2020110304.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..bdc23a6d74327ce0005c362cb2e1d536e8cf4da4
--- /dev/null
+++ b/2020/pbp_data/2020110304.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a472207511e26aee13bd30e58db1f0a5c8963ff212dc619393ef404adc7be0f
+size 17693
diff --git a/2020/pbp_data/2020110305.parquet b/2020/pbp_data/2020110305.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..6e4b65f13f51c932de3c328fdf6ff51c3c983438
--- /dev/null
+++ b/2020/pbp_data/2020110305.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93f2541d9d10f3b808bb16154dc94786016d992bf5dfa59b5bac5502756a2b30
+size 17422
diff --git a/2020/pbp_data/2020110406.parquet b/2020/pbp_data/2020110406.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b3f066cd4460e0e5afcbd79d98dd440dd88c447c
--- /dev/null
+++ b/2020/pbp_data/2020110406.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2aaf25cf6aeafac4e1e31e566cc8dad8abf6f69924b361416f349680e822a4
+size 17835
diff --git a/2020/pbp_data/2020110504.parquet b/2020/pbp_data/2020110504.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d9ecf227f543383fb2cce6b79480257c211ab9dd
--- /dev/null
+++ b/2020/pbp_data/2020110504.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:287d553049d0f26585606d276a3391297a58d205b9f257db1f925cbfa59b2e26
+size 16140
diff --git a/2020/pbp_data/2020110505.parquet b/2020/pbp_data/2020110505.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..3ae4307896e1c717e8ed1d7d4da70f4dbabc672b
--- /dev/null
+++ b/2020/pbp_data/2020110505.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a856f94c31bccf555674ba48851ed877f8e1c2f5c0652d91530029988751070a
+size 16900
diff --git a/2020/pbp_data/2020110601.parquet b/2020/pbp_data/2020110601.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5913b6bc1b1b8b6b0229bfb56e958584b4399695
--- /dev/null
+++ b/2020/pbp_data/2020110601.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:679513545d995bbfb6525b63d7cea012e40ce7aa42a61dd7aa4f8a1e51bad65c
+size 18861
diff --git a/2020/pbp_data/2020110702.parquet b/2020/pbp_data/2020110702.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..470ab679d10dd613f9b05df887c3080b30fcea36
--- /dev/null
+++ b/2020/pbp_data/2020110702.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83e784495424353288582a72c428847838bd2cbbcf266c73408b07d50d349dd3
+size 15644
diff --git a/2020/pbp_data/2020111401.parquet b/2020/pbp_data/2020111401.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..812c48844d869b98fdb4f0f409d7f138b485e878
--- /dev/null
+++ b/2020/pbp_data/2020111401.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:765dae44afbe66e0e847eafce4c3679a750335f59f4875478767e5c73293a826
+size 16720
diff --git a/2020/pbp_data/2020112101.parquet b/2020/pbp_data/2020112101.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5129b0a2d6d581c315a8fe8878af40b7118919f5
--- /dev/null
+++ b/2020/pbp_data/2020112101.parquet
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e61bd859a5c9fd3c55d000edcf8cf4f2b47c3ffcef5bdaf2f567cf64b986144
+size 17379
diff --git a/2023/.DS_Store b/2023/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..eb47d2d32f89bae82a71ef03b54e95c6d03997c9
Binary files /dev/null and b/2023/.DS_Store differ
diff --git a/2024/.DS_Store b/2024/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..15914ddb95c61da94150d3d95b49278c83ddd15a
Binary files /dev/null and b/2024/.DS_Store differ